万字对深入Spring的底层核心原理解析
class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}class userServiceProxy extends UserService(){ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}spring原理分析主要了解spring全家桶最基本的原理、内容
Spring Framework
-
AOP
-
依赖注入
springboot是基于Spring Framework
@Component
public class OrderService{
}@Component
public class UserService{
@Autowired
private OrderService orderService;
public void test(){
System.out.println("test");
}
}AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService)context.getBean("userService");
userService.test();ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService)context.getBean("userService");
userService.test();以上两句都是学习spring时较为重要的两句话
第一句在springboot加载时被调用了 在spring3.0增加了该类 这个是以一个class的方式一个类的形式来充当一个配置文件 直接可以通过使用注解来定义扫描路径（同样也是创建一个spring容器）
第二句在使用springmvc时也调用了类似的PathXml了 作用是创建一个容器，传一个配置文件给spring容器（文件中可以定义一下扫描路径等操作） spring入门级时使用较多
然后可以通过上面的context来getBean获取bean对象，再执行方法
二者其实很相像，一个是以类class的形式，另一个是以xml配置的方式
spring中的bean与我们Java中普通对象有什么区别
这个我们可以测试
新增一个OrderService类这个类使用component注解标注为组件
并且在UserService中进行依赖注入(@Autowired)
这个时候我们观看语句一中context.getBean的userService中的orderService是否有值呢？
-
肯定是有值的，因为OrderService是用@component注解标准，且在UserService中使用@Autowired依赖注入orderService
-
此时我们再测试一下自己new UserService对象出来，看看其中OrderService是否有值---没有值
这就是spring中的bean与Java中普通对象的区别
一个小小的区别用来理解这个bean
现在开始关注spring是如何创建的bean(userService)呢
无参构造得到对象
UserService.class--->构造方法---》对象(得到一个普通对象)
-
无论如何spring怎么操作，肯定是使用了UserService中的构造方法--》得到一个对象(可以发现UserService只有一个构造方法也就是无参构造方法---通过无参构造方法来获取对象)，此时该对象中的orderService属性肯定是没有值的
依赖注入
这个时候就可以发现
UserService.class--->无参构造方法--->对象--->？--->bean
中间是什么操作使得对象中orderService有值(因为bean对象中的有值)
？==依赖注入(属性赋值)
spring会给加了@Autowired注解的属性赋值
依赖注入大概的工作原理（假设userService，其实任意对象均可以)
for(Field field:userService.getClass().getFields()){//获取userService对象中所有属性
if(field.isAnnotationPresent(Autowired.class)){//判断属性上是否携带了@Autowired注解
field.set(userService,????); //进行设置值
}
}这时候还有一个问题是 值 应该从哪里来
初始化前
又可以得出新的路线
UserService.class--->无参构造方法--->对象--->依赖注入(属性赋值)--->初始化前--->初始化--->初始化后--->bean
引入一个小需求
定义了一个User对象(希望可以在mysql中保存数据-User对象-admin)
再UserService中定义了这个user属性admin
如果我们在User对象上加@Component注解以及在UserService的User.admin加@Autowired注解
那我们在userService对象中的admin是否有值，是否是我们需要的值呢
有值，但是不满足我们的需求不是我们需要的值，它此时的值就相当于是一个new User对象
因为我们没有做过任何对mysql进行操作的命令，spring根本不晓得到底连那个数据库等等，所以值是new User对象
因此我们应该编写一个方法，该方法内应该定义一系列对数据库的操作返回什么结果，赋值给我们的admin(这一系列操作应该在我们的初始化前这里进行操作)
UserService.class--->无参构造方法--->对象--->依赖注入(属性赋值)--->初始化前(方法调用)--->初始化--->初始化后--->bean
在UserService中有多个方法，如何让spring去调用你指定得方法呢？需要告诉spring在创建这个bean的过程中间去调用这个方法(@PostConstruct)
spring找的就是当前对象的哪些方法上面加了@PostConstruct注解
spring内部初始化前调用方法大概实现
for(Method method:userService.getClass().getMethods()){//获取到userService对象中的所有方法
if(method.isAnnotationPresent(PostConstruct.class)){//看看那个方法上有@PostConstruct注解
method.invoke(userService,参数);//执行那个方法并且传递什么参数
}
}初始化
其实最开始spring只有初始化操作，没有初始化前与初始化后
以上初始化前的操作可以有另一种实现方式（不调用定义的方法不加@PostConstruct）
而是userService实现InitalizingBean并且实现其内部的afterPropertiesSet()方法
把以前定义的方法的内容全部放在这个afterPropertiesSet中
spring就会去调用这个afterPropertiesSet方法的内容
源码分析
//初始化
try{
invokeInitMethods(beanName,wrappedBean,mbd);
}catch(Throwable ex){
throw new BeanCreationException(
mbd!=null?mbd.getResourceDescription():null),
beanName,"Invocation of init method failed",ex);
}
进入invokeInitMethods方法查看会发现
protected void invokeInitMethods(String beanName,Object bean，@Notable RootBeanDefinition mbd )
这个Object bean其实就是我们spring根据某一个类创建的对象bean
执行bean instanceof InitalizingBean得到一个结果boolean initalizingBean
进行判断 这个bean是否为true实现了InitalizingBean接口么
为true就会判断是否打开安全管理器 再执行 ((InitalizingBean)bean).afterPropertiesSet()方法
为false就直接执行((InitalizingBean)bean).afterPropertiesSet()方法初始化后
重点：实现了AOP
bean的创建生命周期
UserService.class--->无参构造方法--->对象(得到一个普通对象)--->依赖注入(属性赋值)--->初始化前(@PostConstruct)--->初始化(initializingBean)--->初始化后(AOP)--->代理对象--->bean
aop与spring事务联系紧密
定义了一个类
@Aspect
@Component
public class HHXYAspect{
@Before("execution(public void xxx.xxx.UserService.test())") //切的UserService里的test方法 UserService有一个切面
public void HHXYBefore(JoinPoint joinPoint){
System.out.println("hhxybefore")
}
}开启AOP可以使用注解 @EnableAspectJAutoProxy
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService)context.getBean("userService");
userService.test();在userService处打断点为什么userService中orderService没有值呢？为null
难道开启aop后依赖注入都不生效了么？？？ 并不是 其实我们如上面的步骤就可以发现了
UserService.class--->无参构造方法--->对象(得到一个普通对象)--->依赖注入(属性赋值)--->初始化前(@PostConstruct)--->初始化(initializingBean)--->初始化后(AOP)--->代理对象--->bean
spring进行初始化后(aop)--->得到代理对象--->bean 经过aop得到代理对象后续没有任何操作了直接变成bean了 设计时得到代理对象后续就没有依赖注入这种操作了
此时我们可以假设通过aop后得到代理对象中orderService属性就是空的
但是debug进入到UserService中的test方法就会发现orderService此时是有值的
这是为什么呢？？？
分析
UserService此时进行aop应该使用的是什么 cglib
cglib是通过什么进行aop也就是生成代理对象----》通过代理，父子量继承
//以上spring流程中代理对象其实也就是通过代理类生成的代理对象
//UserServiceProxy--->代理对象
//cglib底层大概原理
class userServiceProxy extends UserService{ //生成代理类去继承UserService
public void test(){ //就可以重写test方法
}
}再看回过来看这个方法。其实也就是拿到代理对象，接着调用代理对象中的test方法
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = context.getBean("userService");
userService.test();进入到代理类的test方法
//为什么生成代理类因为有一个切面HHXYAspect
class userServiceProxy extends UserService{ //生成代理类去继承UserService
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
super.test();//子类的test方法可以调用父类的test方法 也就是调用被代理的那个test方法
}
}但是我们回过头来仔细思考 它这里只发生了一下方法调用 (子类的test调用，父类的方法调用，中间的切面方法) 那么我的UserService里的OrderService为什么会有值呢
思路是正确的，但是具体是怎么做的呢？？？
//UserServiceProxy--->代理对象--->代理对象.target==普通对象
//因为这个普通对象通过属性赋值(依赖注入)，它的orderService是有值的
//其实这一步可以认为是生成代理对象的一步
class userServiceProxy extends UserService{ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}为什么spring没有在代理对象那一步进行属性赋值呢----没太必要
通常切面都是用来切方法的 最终我会生成某一个代理对象
代理对象最重要的意义是啥 当这个代理对象去执行某个方法的时候 会来执行这些切面的逻辑
这时候在切面中为某一个属性进行赋值，用处不大
切面中最重要的还是那个方法 而且joinPoint.getTarget()一样可以获取到普通对象
为啥 代理对象.target==普通对象
创建bean的流程
查看方法doCreateBean
Object bean = instanceWrapper.getWrappedInstance() //通过构造方法得到一个对象
Object exposedObject =bean;
//填充属性
populateBean(beanName,mbd,instanceWrapper)
//初始化
exposedObject = initializeBean(beanName,exposedObject,mbd)
进入到initializeBean方法
会将刚刚那个bean对象传递进来
会将对象传到
wrappedBean = applyBeanProcessorAfterInitialization(wrappedBean,beanName) //这个方法就会进行aop了
这个方法就可以看作生成一个代理类，代理类实例化成代理对象，再把这个wrappedBean赋值给这个代理对象就OK了
UserService.class--->无参构造方法--->对象(得到一个普通对象)--->依赖注入(属性赋值)--->初始化前(@PostConstruct)--->初始化(initializingBean)--->初始化后(AOP)--->代理对象--->bean
这个步骤中要如何判断UserService要aop呢 因为UserService中的一个方法test被切面切了所以要aop
那么我UserService从最开始bean流程走的时候怎么知道自己要不要进行aop，被切了呢？
切面也加了@Aspect**@Component**注解 也在spring容器中 切面bean 一个方法不一定是被一个切面bean来切，并不是只有一个切入点
-
1,找到所有的切面Bean（找到@Aspect,@Component）
-
2,遍历所有切面Bean
-
3,遍历切面Bean中所有切面方法，找方法上是否标准了@Before、@After等注解的方法
-
4,有类似这种注解的话，查看该注解中是否定义了的表达式
-
5,拿着这些定义了的表达式去与当前spring正在创建的UserService去匹配
-
6,当前所遍历的方法与UserService匹配，那么就说明我这个UserService是需要进行aop的
-
7,就会将UserService匹配的方法 全部放到map<UserService.class,methods>里缓存起来
代理对象.test();
class userServiceProxy extends UserService{ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//先执行@Before
//再执行被代理的逻辑
target.test();//所以代理类先调用子类test，接着调用切面逻辑，再而调用普通对象UserService的test方法(此时orderService是有值的)
}
}方法存储起来的map，可以在@Before这里执行
可以知道此时这个代理对象就是UserService 代理对象.test()方法 首先执行切面的逻辑 也就是上面的@Before需要执行业务逻辑
执行切面逻辑可以直接通过UserService中map缓存里的方法全部都匹配出来
这样代理对象.test()可以执行的更快了
所以这个流程可以有两个方面好处：
1，一方面是看我这个UserService要不要进行aop 要进行aop就可以把这些方法都缓存起来
2，而当我真正要执行时(代理对象.test()时) ，就可以从缓存中把所有的UserService匹配的方法全部拿出来，执行切面的逻辑
接着了解下spring事务
加上注解@EnableTransactionManagement 开启事务管理
//AppConfig
//都是一些需要操作数据库使用的
@Component
@EnableTransactionManagement
public class AppConfig{
@Bean
public JdbcTemplate jdbcTemplate(){
return new JdbcTemplate(dataSource());
}
@Bean
public PlatformTransactionManager transactionManager(){//配置事务管理器
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource());
return transactionManager;
}
@Bean
public DataSource dataSource(){
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setUrl("xxx连接信息");
dataSource.setUsername("用户名");
dataSource.setPassword("密码");
return dataSource;
}
}有一个表 giao 五个字段都是空的
在UserService中改造
//UserService.class
@Component
public class UserService{
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void test(){
jdbcTemplate.execute("insert giao values(1,1,1,1,1)");
throw new NullPointerException();
}
}//Test.class
public class Test {
public static void main(String []args){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService)context.getBean("userService");
userService.test();
}
} 这个时候猜测数据库中是否插入数据 后台报NullPointerException
但是数据库中已经存在数据了
为什么会添加到数据库呢（没有在AppConfig类上添加@Configuration注解）
加了该注解后再执行一遍Test.class的mian方法
发现抛出NullPointerException异常，且数据库中没有数据
我们再userService.test()这里打断点 会发现这是一个代理对象 是由spring事务创建的一个代理对象那么看看spring事务的代理对象.test
class userServiceProxy extends UserService{ //生成代理类去继承UserService
UserService target;
public void test(){ //就可以重写test方法
//代理逻辑是怎么样的呢
//1，判断当前代理对象所执行方法上是否有@Transactional注解
//2，创建一个数据库连接Conn(事务管理器dataSource)
//3，conn.autocommit = true 默认是true 自动提交 spring将conn.autocommit = false 改成false
可以执行方法完毕后，进行手动提交conn.commit();
若是执行方法抛出异常，就可以调用conn.rollback();
target.test();//这个时候就是调用普通方法的test(),也就是加了UserService中加了@Transactional注解的方法
假设该方法中有几条需要执行的sql语句，有conn.autocommit = true 就会执行一条sql就会提交一次 那么此时我们的@Transactional注解还有什么意义呢 sql都提交了后面的sql执行在提交，后面异常也要抛出，那么这个回滚还回滚什么呢
}
}事务失效的场景了解
//改造UserService.class
//UserService.class
@Component
public class UserService{
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void test(){
jdbcTemplate.execute("insert giao values(1,1,1,1,1)");
a();
}
@Transactional(propagation=Propagation.NEVER)//当传播机制-NEVER 以非事务的方式执行，存在一个事务就会抛一个异常
public void a(){
}
}
按照理论是会抛出一个异常，因为已经test方法开启了一个事务 但是运行测试会发现并没有抛异常 为什么呢，我们查看a()是谁在调用 可以发现代理对象.test()不就是执行代理的test()，再执行普通对象UserService调用test() 在普通对象上加@Transactional是没有作用的
该如何解决这种事务失效的场景
要明确加了 @Transactional(propagation=Propagation.NEVER)注解该注解有没有用
是谁在调用 被调用的时候是不是代理对象在调用这个方法
只要是代理对象调用这个方法，那么上面写的这个注解它就有用
方案可以重新创建一个UserServiceBase类
就把a()方法写在里面
再从UserService中使用@Autowired注解依赖注入UserServiceBase()
再在test方法下把a()改成 userServiceBase.a();
运行测试可以发现确实抛出异常了 ----IllegalTransactionStateException
其实也可以不用拆分出UserServiceBase类
直接在UserService类中使用@Autowired注解自己依赖注入自己在UserService中
@Autowired
private UserService userService;
//spring会将UserService的代理对象赋值给userService这个属性
//也就是userService.a()就是一个代理对象调用a()方法
//就会出现上述异常为什么没加@Configuration注解事务失效，加了之后事务成功呢
没有加@Configuration可以发现代理类中的dataSource与代理对象.test()的dataSource不是同一个
没有加@Configuration时，AppConfig.class中JdbcTemplate与DataSourceManager持有的是两个dataSource，两个单独的dataSource，不是同一个
在代理对象.test()时
我是拿着事务管理器的dataSource去创建数据库连接，修改autocommit属性
而target.test()执行时，是由jdbcTemplate的dataSource去建立一个新的数据库连接 所以它执行的SQL就自动提交了
加了@Configuration注解时，可以确保jdbcTemplate与DataSourceManger的dataSource是同一个 这样事务才能生效
为什么这里添加了@Configuration注解就能确保dataSource保持一致呢
与spring中的代理模式有关
我们要使用jdbcTemplate与DataSourceManger都是要使用AppConfig这个类的
如果我们加上了@Configuration注解就可以使得jdbcTemplate与DataSourceManger使用的是AppConfig的代理对象
@Component
@EnableTransactionManagement
@Configuration//保证datasource一致事务才会生效
public class AppConfig{//AppConfig代理对象
@Bean
public JdbcTemplate jdbcTemplate(){
return new JdbcTemplate(dataSource());//此时dataSource()直接到spring容器中寻找，有的话就直接返回了
//如果没有找到dataSource这个bean那就要真正执行下面的DataSource方法创建dataSource
}
@Bean
public PlatformTransactionManager transactionManager(){//配置事务管理器
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource());此时dataSource()直接到spring容器中寻找，有的话就直接返回了
//如果没有找到dataSource这个bean那就要真正执行下面的DataSource方法创建dataSource
return transactionManager;
}
@Bean
public DataSource dataSource(){
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setUrl("xxx连接信息");
dataSource.setUsername("用户名");
dataSource.setPassword("密码");
return dataSource;
}
}