Spring框架(一)：基础_随笔

Spring框架(一)：基础

1、Spring

优点

Spring是一个开源的免费框架（容器）
Spring是一个轻量级的、非入侵式的框架
IOC控制反转、AOP面向切面编程
支持事务的处理、对框架整合

Spring就是一个轻量级的控制反转和面向切面变成的框架。

2、Spring组成

1. Spring Core
框架的最基础部分，提供 IoC 容器，对 bean 进行管理。

2.Spring Context
基于 bean，提供上下文信息，扩展出JNDI、EJB、电子邮件、国际化、校验和调度等功能。

3．Spring DAO
提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码，还提供了声明性事务管理方法。

4.Spring ORM
提供了常用的“对象/关系”映射APIs的集成层。其中包括JPA、JDO、Hibernate、MyBatis 等。

5.Spring AOP
提供了符合AOP Alliance规范的面向方面的编程实现。

6.Spring Web
提供了基础的 Web 开发的上下文信息，可与其他 web 进行集成。

7.Spring Web MVC
提供了 Web 应用的 Model-View-Controller 全功能实现。

3、Spring Boot

Sping Boot

一个快速开发的脚手架
基于Spring Boot可以快速的开发耽搁微服务
约定大于配置

Spring Cloud

Spring Cloud基于SpringBoot实现

4、Spring配置 4.1、别名

4.2、bean的配置

4.3、import

一般用于团队开发使用，可以将多个配置文件导入合并为一个。

xml的正常名称：applicationContect.xml

5、依赖注入 5.1、构造函数注入

5.2、set方法注入（***）

依赖：bean对象的创建依赖容器

注入：bean对象所有属性由容器注入

普通注入：value

bean注入：ref

空值注入：

数组：

property注入：

list:

set:

map:

5.3、p/c空间注入

我们可以使用p空间和c空间注入

注意：p和c空间不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6、Bean的作用域

bean的作用范围调整

bean对象默认是单例

bean标签的scope属性：作用：用于指定bean的取值范围取值：常用：单例和多例 singleton:单例（默认）

prototype：多例

request：作用于web应用的请求范围

session：作用于web应用的会话范围

global-session:：作用于集群环境的会话范围（全局会话范围），当不是集群时，他就是session

1、单例模式(Spring默认)

容器中一个类只有一个对象

  
     
     
     

需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法后面的值一致。
会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid。

setDog----dog----id="dog"。setCat ----cat------id="cat" 。

    

7.3、byType自动装配

需要保证所有bean的class 唯一，并且这个bean需要和自动注入的属性的类型一致。
会自动在容器上下文中查找，和自己对象属性类型相同的bean，必须保证容器中类型全局唯一。

    

7.4、注解自动装配

jdk1.5支持注解，spring2.5支持注解开发

使用注解须知：

1、导入约束（.../context）

2、配置注解的支持()

 

 

public class People {

    //如果显示定义了Autowired的rerequired属性为false,说明这个属性可以为null,否则不允许为空
    @Autowired(required = false)
    private Cat cat;
    private Dog dog;
    private String name;

    //表示name可以为空，为空时不报错
    public People(@Nullable String name){
        this.name = name;
    }
}

*   用于注入数据：
*       他们的作用和在xml配置文件中bean标签中写一个标签一样
*       @Autowired:
*           作用：自动按照类型注入，只要容器中有唯一一个bean对象类型和要注入的变量类型匹配，就可以注入成功
*                如果IOC容器中没有任何bean的类型和要注入的变量的类型匹配，报错
*                如果IOC容器中有多个类型匹配时：
*           出现位置：
*                  可以是变量上，也可以方法上
*            细节：在使用注解注入时，set方法不是必须的
*        @Qualifier:
*             作用：在按照类中注入的基础之上再按照名称注入。他在给类成员注入时不能单独使用。但是再给方法参数注入时可以。
*             属性：value：用于指定注入bean的id
*       @Resource
*             作用：直接按照bean的id注入，他可以独立使用
*             属性：name,用于指定bean的id
*        以上三个注解都只能注入其他bean类型的数据，而基本数据类型和String类型无法使用上述注解实现。
*        另外，集合类型的注入只能通过XML实现。
*        @Value:
*               作用：用于注入基本类型和String类型的数据
*               属性：value:用于指定数据的值，他可以使用spring的spEl(spring的el表达式)
*                     spEL写法：  ${表达式}

8、使用注解开发

在Spring4之后，要使用注解开发，必须保证aop的包导入了

使用注解需要导入context约束，增加注解的支持。

1、bean 2、属性如何注入

3、衍生注解

4、自动装配

5、作用域

6、小结 9、使用Java的方式配置Spring

我们现在完全不使用spring的xml配置了，全权交给Java来做

JavaConfig是spring的一个子项目，在Spring 4之后成为一个核心功能

1、实体类

2、配置类

3、测试类

这种存java配置方式，在springboot随处可见

10、代理模式

为什么使用代理模式，因为这是AOP底层

10.1、静态代理

public interface Rent {
}


public class Host implements Rent{

    public void rent(){
        System.out.println("房东要出租房子");
    }
}



public class Proxy implements Rent{

    Host host = new Host();

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent(){
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    public void hetong(){
        System.out.println("中介跟你签合同");
    }

    public void fare(){
        System.out.println("中介收中介费");
    }
}

public class Client {

    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理，中介帮房东出租房子，有一些附加 *** 作
        Proxy proxy = new Proxy(host);
        //直接找代理
        proxy.rent();
    }
}

AOP

【静态代理实战(在所有方法上加个日志)】

public interface UserService {

    public void add();
    public void delete();
    public void update();
    public void query();
}

package designpattern;

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}
package designpattern;

public class UserProxy implements UserService {

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log (String msg){
        System.out.println("【debug】使用了一个"+msg+"方法");
    }
}

10.2、动态代理

public class MyInvokeHandler implements InvocationHandler {

    //真实类（被代理类），被代理类接口
    Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //获取代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //调用方法
    //处理代理实例，并返回结果
    //调用 getProxy 方法会自动调用invoke方法，因为传入InvocationHandler
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target,args);
        return result;
    }

    public void log (String msg){
        System.out.println("执行了"+msg+"方法");
    }

}


public class ClientProxy {

    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色,不存在
        MyInvokeHandler myInvokeHandler = new MyInvokeHandler();

        //设置要代理的对象
        myInvokeHandler.setTarget(userService);
        //生成动态代理类
        UserService proxy = (UserService)myInvokeHandler.getProxy();
        proxy.add();
    }
}

11、AOP 1、AOP

2、AOP在spring中作用

3、使用Spring实现AOP

业务逻辑和增强的代码分开实现

通过xml 织入关系

public interface UserService {

    public Boolean add();
    public void delete();
    public void update();
    public void query();
}

public class UserServiceImpl implements UserService {

    @Override
    public Boolean  add() {
        System.out.println("增加了一个用户");
        return true;
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}


public class Log implements MethodBeforeAdvice {

    
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName() +"被执行了");
    }
}


public class AfterLog implements AfterReturningAdvice {

    
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
    }
}

总结：使用切面aspect（类）中的通知advice （方法）在切入点pointcut （待增强的方法处）

public class DiyPointcut {

    public void after(){
        System.out.println("方法之后执行");
    }

    public void before(){
        System.out.println("方法之前执行");
    }
}

12、整合mybatis

12.1、mybatis步骤

@Data
public class User {

    private int id;
    private String name;
    private String pwd;
}

public interface UserMapper {

    public List selectUser();
}

public class Mytest {

    @Test
    public void test() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream is = Resources.getResourceAsStream(resources);

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = factory.openSession(true);

        UserMapper userMapper = session.getMapper(UserMapper.class);
        List users = userMapper.selectUser();

        for (User u:users) {
            System.out.println(u);
        }
    }
}

问题1:org.apache.ibatis.binding.BindingException: Type interface mybatis.mapper.UserMapper is not known to the MapperRegistry.

因为需要在配置文件mybatis-config.xml中引入mapper.xml

问题2:org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): mybatis.mapper.UserMapper.selectUser

此时运行后没有在target里生成UserMapper.xml文件

方法：在pom中添加



        
            
                src/main/java
                
                    **/*.xml
                
                true

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/4688118.html

Spring框架(一)：基础

发表评论

评论列表（0条）