Spring

Spring核心和设计思想

spring:包含众多工具方法的IoC容器,帮忙进行管理对象的生命周期(对生命周期的反转)
IoC:inversion of Control(控制反转)
对象的生命周期进行控制控制
为什么要使用Ioc?

传统方式:

public class Car {
    private Tire tire ;
    public Car(){
        tire = new Tire();
    }
    public void init(){
        System.out.println("执行了Car init");
        tire.init();
        /**
         * 创建车  只有创建轮胎才能创建车
         */
    }
}
public class Tire {
    /**
     * 轮胎  如果轮胎的颜色  大小要变
     * 	  底层的类发生改变	那么依赖轮胎的其他类都要变  程序耦合程度太高
     * 		
     */
    private int size = 20;
    public Tire(int size){
		this,size= size;
}
    public Tire(){
        System.out.println("创建了轮胎");
    }
    public void init(){
        System.out.println("轮胎初始化,轮胎大小:"+size);
    }
}

public class App {//启动类
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

注入:

public class Car {
    private Tire tire ;
    public Car(Tire tire){
        this.tire =tire;
    }
    public void init(){
        System.out.println("执行了Car init");
        tire.init();
        /**
         * 创建车  只有创建轮胎才能创建车
         */
    }
}
public class Car {
    private Tire tire ;
    public Car(Tire tire){
        /**
         * 传统方式:  从上往下执行  耦合程度高
         *              修改这个类,依赖这个类的对象都要进行修改
         *              spring:使用注入的方式   从下往上执行   修改这个类,不需要修改注入的类
         */
        this.tire =tire;
    }
    public void init(){
        System.out.println("执行了Car init");
        tire.init();
        /**
         * 创建车  只有创建轮胎才能创建车
         */
    }
}

public class App {
    public static void main(String[] args) {
        Tire tire = new Tire(15);
        Car car = new Car(tire);
        car.init();
        //使用注入的方式   从下往上执行   修改这个类,不需要修改注入的类
    }
}

对比:

2Spring Ioc容器

前提:
配置spring.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans htt
p://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

容器: 存和取.
DI:依赖注入 在程序运行的时候,动态的将某个对象注入到当前的机制.

存:
1创建对象
2将对象注册到spring中
2.1 使用bean注册到xml中 or 配置扫描路径

取:
1 得到spring对象
2使用getbean方法获取bean对象(id不同可以注入多次class相同的bean对象)
example: User user = context.getBean(“user”, User.class);

Application和BeanFactory的区别:
相同:
1都是来自spring的顶级接口
2都可以得到spring上下文对象
不同:
1都是顶级接口 但是Application继承 BeanFactory
2Application支持资源传播,国际化访问.事件传播等
3Application性能好: 因为启动的时候一次性加载所有的Bean对象
BeanFcatory需要什么,才会加载什么.

更简单的存取:: 核心是使用注解的方式
前置工作:配置扫描路径.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package="com.bit.service"></content:component-scan>
</beans>

存:
类注解:@Controller @Service @Repository @Component(组件) @Configuration
方法注解 @Bean 可以注入多个同类对象(支持设置name属性)

取:
对象分配:
1属性注入

   /**
     * 1属性注入
     * 缺点: 1 不能注入final对象
     * 声明final对象必须直接赋值 or 在构造方法赋值
     * private final int a = 5 ;
     *     2 只适用于Ioc容器
     *     3更加容易违背单一设计原则
     *
     */
    @Autowired
    public User user;

对象;
优点:实现简单
缺点:1功能性问题 没有办法注入一个final对象
2只适用与Ioc容器

2 set注入

 /**
     * set注入  	
     *   没有注解则 空指针异常
     *  优点 写法复杂  所以违背单一设计原则的概率低
     * 缺点: 1 不能注入一个final修饰的对象
     * 	final修饰的对象只能直接赋值 或者 由构造方法赋值
     * 		2注入对象可被修改 
     *  因为set方法是普通方法,可以被重复调用,所以注入的对象可以被修改
     */

    public User user;
    @Autowired
    public void setUser(User user) {
        this.user = user;
        //从spring中取的对象赋值给当前对象
    }

4 Java提供:@Resource

   @Resource(name = "s1")
    private User user;

如果返回类型有多个相同的Bean,注入对象怎么选择?

1 @Autowired
    public User user1;
    	   类型  方法名
    	   //适用类型+方法名的方式定位
2 @Autowired
    @Qualifier("方法名")
    public User user1;
3  @Resource(value = "方法名");

@Resource VS @Autowired
功能实现: 1A 支持属性 setter 构造方法注入
R 支持属性 setter注入 不支持构造方法注入
2来源不同: R来自JDK Autowired来自spring
3参数不同 Autowired只支持是否必须

1类名首字母小写怎么取对象? 和首字母大写一样.都是首字母小写
2类名前几个字母大写怎么取对象? 使用原类名
3类都在java目录下怎么设置扫描路径? 扫描路径设置星星
星星: 匹配跟路径和根下所有子路径

五大类注解的关系:
其他四大类内部依赖Component

Bean作用域和生命周期

Bean是什么?
spring存放的对象

Bean的作用域:Bean在spring框架中的某种行为模式.

•  1. singleton:在该作用域下的Bean在Ioc容器下只存在一个实例
  

  •  2. prototype:原型作用域  每次请求都会创建新的实例(克隆)
    

  •  3. request:请求作用域.   每次http请求都会创建一个新的实例.  限定springMVC
    

  •  4. session: 会话作用域.  每次会话共享一个实例.             限定springMVC
    

  •  5. Application   全局作用域    在http servlet context中, 定义一个Bean  限定springMVC
    

  •  6.websocket 在一个http WebSocket中定义一个Bean对象
    

  • 区别:   Singleton:  spring core的作用域   作用于Ioc容器
    

  •      Application: springWeb    作用于servlet
    

  •    设置作用域:存到spring的时候设置作用域
    

  •        @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    

  •        @Bean
    

  spring执行流程:
  1启动容器
  2读取配置文件,初始化:
  a:直接在xml中注册Bean
  b:配置扫描路径
  3 使用注解注册Bean,存储到spring
  4读取对象,把对象装配到类中

  Bean的生命周期:
  1实例化(分配内存空间)
  2设置属性(初始化的时候有可能用到属性)
  3Bean的初始化
  a:实现各种Aware通知的方法.
  b:执行BeanPostprocessor初始化前置工作
  c:执行初始化@PostConstruct初始化方法.和init-method方法.
  d:执行初始化后置方法BeanPostProcessor
  4使用Bean
  销毁Bean