Spring底层核心原理解析

偏执的太偏执、 2023-10-03 22:04 5阅读 0赞

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

在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要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;
        }
     }