Spring高级（原理）

一、Spring创建Bean

personService -> 构造方法 -> 普通对象 -> 依赖注入（byType->byName） -> 初始化前(@PostConstruct) -> 初始化(InitializingBean) -> 初始化后(AOP) -> 代理对象 -> 将代理对象放入到Map单例池中 -> Bean对象

public class PersonService{
	@Autowiren
	private UserService uservice;
	public String getStr(){
		return "HELLO";
	}
}

• 创建Bean：Spring创建Bean时是基于Bean的构造方法创建出来的。
• 依赖注入：当Bean创建完成后，Spring会把值注入到包含了注入注解（@Autowiren,@Resource…）的属性上，并不是给所有属性注入值。

举例

// 通过无参构造方法得到一个对象
PersonService personService = new PersonService();
// 通过反射得到属性，判断哪些属性是需要注入值的
for(Field field : personService.getClass().getDeclaredFields()){
	if(field.isAnnotationPresent(Autowiren.class)){
		field.set(personService,???);
	}
}

personService --> 构造方法得到对象 --> 对象 --> 依赖注入 --> Bean对象

二、Spring中的单例池和作用

单例池：Map<beanName,Bean对象>

• Spring单例池是一个Map<beanName,Bean对象>来存储Bean的，所以通过application.getBean("beanName");得到的Bean是同一个对象。

• 如果通过application.getBean("beanName");获取不到Bean时，Spring会帮我们创建一个Bean，并把需要赋值的属性都注入值，然后将这个Bean存放到Map<beanName,Bean对象>中来，以供我们来获取使用。

AnnotationConfigApplicationContext application = new AnnotationConfigApplicationContext(AppConfig.class);
// 单例Bean
PersonService personService1 = (PersonService)application.getBean("personService");
PersonService personService2 = (PersonService)application.getBean("personService");
PersonService personService3 = (PersonService)application.getBean("personService");
// 结果为true
boolean bool = personService1.equals(personService2) && personService2.equals(personService3); // true

PersonService personService4 = new PersonService();
PersonService personService5 = new PersonService();
PersonService personService6 = new PersonService();
// false
boolean boo = personService4.equals(personService5) || personService5.equals(personService6); // false
/** 如果每次得到的Bean都是不一样的，那么也就没必要放到Map<beanName,Bean对象>中了 */

三、推断构造方法

• Spring创建对象时会优先选择无参构造方法，当对象中没有无参构造方法并且有且仅有一个有参构造方法时，Spring会使用该有参构造为我们创建一个对象。
• 当对象中有无参构造方法和多个有参构造方法时，Spring会默认使用无参构造方法为我们创建一个Bean对对象。
• 当对象中没有无参构造方法，且有多个有参构造方法时，Spring便会在初始化时抛出异常，因为没有无参构造方法时，Spring无法在多个有参构造方法中选择。
  Caused by: java.lang.NoSuchMethodException Create breakpoint : ....PersonService.<init>()
• 当对象中没有无参构造方法，且有多个有参构造方法时，我们可以使用@Autowried注解来告诉Spring默认使用具体的那个构造方法来帮我们创建出Bean对象。

public class PersonService{
	private UserService uservice;
	
	//public PersonService(){}
	
	public PersonService(UserService uservice){}
	
	@Autowried
	public PersonService(UserService uservice1,UserService uservice2){
		System.out.println("告诉Spring使用当前构造方法创建Bean对象！");
	}
}

四、构造方法参数注入

• Spring在使用有参构造方法创建Bean对象时，发现需要传入参数，Spring会先从单例池（Map<beanName,Bean对象>）中获取，有值则会传进来，没值Spring则会创建一个Bean对象，然后传到构造方法中。
• 当创建PersonService对象的时候发现参数为空，Spring会为我们创建一个UserService对象当作参数，此时会出现一个循环依赖问题，Spring是通过三级缓存来解决循环依赖的。

@Autowried
public PersonService(UserService uservice){
	System.out.println("Spring会创建uservice的Bean对象作为参数传过来！");
}

五、先byteType再byName

当Spring单例池（Map<beanName,Bean对象>）中存在多个UserService单例Bean时，Spring选择时先byteType再byName的机制

import cn.molu.service.UserService;
@Component
public class AppConfig{ 
	@Bean
	public UserService uservice(){  // Map<uservice,UserService>
		return new UserService();
	}
	@Bean
	public UserService uservice1(){ // Map<uservice1,UserService>
		return new UserService();
	}
	@Bean
	public UserService uservice2(){ // Map<uservice2,UserService>
		return new UserService();
	}
}

• 当Spring在单例池（Map<beanName,Bean对象>）中发现有多个单例Bean时，Spring会先以UserService(cn.molu.service)的类型来匹配(此时发现存在3个UserService )，之后在以入参的名称uservice来匹配Bean对象，之后返回该Bean对象。
• 当Spring在单例池（Map<beanName,Bean对象>）中未找到Bean或者按照Type找到多个而按照Name没找到时，Spring就会抛出异常。

六、Spring底层AOP的操作

首先Spring的代理对象（UserServiceProxy）会继承被代理对象（UserService）
代理对象（UserServiceProxy）中会有一个属性为普通对象（UserService target;）
代理对象重写父类（被代理对象）中的方法，最后使用普通对象（UserService target;）执行对应的方法。
UserServiceProxy -> UserService代理对象 -> UserService代理对象.target=普通对象(UserService) -> 存放到Map<beanName,Bean对象>代理池中

class UserServiceProxy extends UserService{
	UserService target;// 普通对象
	@Override
	public void method(){
		//@Before切面逻辑
		target.method();// 最终执行普通对象中的method方法
	} 
}

七、Spring中的事务

Spring的事务只有在Spring创建的代理对象中执行才会有效，普通对象调用带有事务的方法方法时，事务是不会生效的（AOP）

@Component
public class UserService{
	private JdbcTemplate jdbcTemplate;
	@Transactional
	public void testA(){
		jdbcTemplate.exexute("insert into T1(t1,t2,t3,t4) values(1,2,3,4)");
		//int i = 0 / 0;
		testB();// 调用该方法事务不会生效,相当于（new UserService().testB();）通过普通对象调用
	}
	@Transactional
	public void testB(){
		jdbcTemplate.exexute("insert into T1(t1,t2,t3,t4) values(4,3,2,1)");
		int i = 0 / 0;
	}
}

事务失效场景

• 1、就是@Transactional注解保证的是每个方法处在一个事务，如果有try一定在catch中抛出运行时异常。

@Transactional
public static void main(){
     Map<String,Object> params = null;
   try{
       params.get("test");
   }catch(Exception e){
       throw new RuntimeException();
   }
}

• 2、方法必须是public修饰符。否则注解不会生效，但是加了注解也没啥毛病，不会报错，只是不起作用。

@Transactional //使用private时该注解不起作用，必须为public才可
private static void main(){
     Map<String,Object> params = null;
   try{
       params.get("test");
   }catch(Exception e){
       throw new RuntimeException();
   }
}

• 3、this.本方法的调用，被调用方法上注解是不生效的，因为无法再次进行切面增强。

@Transactional//开启事务
public void main(){
    Map<String,Object> params = new HashMap<String,Object>();
    params.put("test","测试事务。。。");
    this.method1(params);
}
@Transactional // 该事务不会生效
public void method1(Map<String,Object> params){
    System.out.println("入参数据："+params);
}

• 4、try{}中的代码块会脱离Spring的事务，想要事务生效必须要在catch(){}中抛出RuntimeException运行时异常。此时出现异常后，Spring会捕获回滚，来保证事务的一致性。在throw new RuntimeException(“抛出异常了”);之前代码均处于同一事物中，所有内容都会回滚，包括catch(){}中的方法代码也会回滚掉。

八、循环依赖和三级缓存

循环依赖：A对象创建时需要B --> B创建时需要A对象 --> A对象创建需要B --> B对象需要A...

Spring中使用三级缓存解决了循环依赖问题

Bean概念

由spring容器管理的对象统称为Bean对象。Bean就是普通的java对象，和我们自己new的对象其实是一
样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些
bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数
据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象

BeanFactory接口

spring容器中具有代表性的容器就是BeanFactory接口，这个是spring容器的顶层接口，提供了容器最
基本的功能。

常用的几个方法

//按bean的id或者别名查找容器中的bean 
Object getBean(String name) throws BeansException 
//这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象 
<T> T getBean(String name, Class<T> requiredType) throws BeansException; 
//返回容器中指定类型的bean对象 
<T> T getBean(Class<T> requiredType) throws BeansException; 
//获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲 
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

ApplicationContext 接口

org.springframework.context.ApplicationContext

这个接口继承了BeanFactory接口，所以内部包含了BeanFactory所有的功能，并且在其上进行了扩展，
增加了很多企业级功能，比如AOP、国际化、事件支持等等

ClassPathXmlApplicationContext 类

org.springframework.context.support.ClassPathXmlApplicationContext

这个类实现了ApplicationContext接口，注意一下这个类名称包含了ClassPath Xml，说明这个容器类可
以从classpath中加载bean xml配置文件，然后创建xml中配置的bean对象，

AnnotationConfigApplicationContext 类

org.springframework.context.annotation.AnnotationConfigApplicationContext

这个类也实现了ApplicationContext接口，注意其类名包含了Annotation和config两个单词，上面我们
有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用
到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。

@Configration和 @Bean注解

spring中，类上加不加@Configuration注解，有什么区别？

两者区别：

1. @Configuration这个注解可以加在类上，让这个类的功能等同于一个bean xml配置文件
2. 有没有@Configuration注解，@Bean都会起效，都会将@Bean修饰的方法作为bean注册到容器中
3. 被@Configuration修饰的bean最后输出的时候带有EnhancerBySpringCGLIB 的字样，而没有@Configuration注解的bean没有Cglib的字样（有EnhancerBySpringCGLIB 字样的说明这个bean被cglib处理过的，变成了一个代理对象。）
4. 被@Configuration修饰的类，spring容器中会通过cglib给这个类创建一个代理，代理会拦截所有被@Bean 修饰的方法，默认情况（bean为单例）下确保这些方法只被调用一次，从而确保这些bean是同一个bean，即单例的。

总结：

1. @Configuration这个注解可以加在类上，让这个类的功能等同于一个bean xml配置文件
2. @Configuration注解修饰的类，会被spring通过cglib做增强处理，通过cglib会生成一个代理对
   象，代理会拦截所有被@Bean注解修饰的方法，可以确保一些bean是单例的
3. 不管@Bean所在的类上是否有@Configuration注解，都可以将@Bean修饰的方法作为一个bean
   注册到spring容器中

@ComponentScan、@ComponentScans

@ComponentScan工作的过程：

1. Spring会扫描指定的包，且会递归下面子包，得到一批类的数组
2. 然后这些类会经过上面的各种过滤器，最后剩下的类会被注册到容器中

第一个：需要扫描哪些包？通过 value、backPackages、basePackageClasses 这3个参数来控制
第二：过滤器有哪些？通过 useDefaultFilters、includeFilters、excludeFilters 这3个参数来
控制过滤器

默认情况下，任何参数都不设置的情况下，此时，会将@ComponentScan修饰的类所在的包作为扫描
包；默认情况下useDefaultFilters为true，这个为true的时候，spring容器内部会使用默认过滤器，
规则是：凡是类上有 @Repository、@Service、@Controller、@Component 这几个注解中的任何一
个的，那么这个类就会被作为bean注册到spring容器中，所以默认情况下，只需在类上加上这几个注解中的任何一个，这些类就会自动交给spring容器来管理了