说明
本系列文章以spring-framework-5.3.10为例 ， 本篇文章的目的就是使各位读者能在使用Spring的基础上对Spring的一些比较核心的内容有一个大概的认识，并不是特别全面，会在后续的文章中一一讲解，不仅仅是停留在Spring简单的使用 ， 而是方便后面源码的阅读以及实现方式的理解 ， 文章仅是作者自己在学习Spring过程中的案例演示以及知识总结 ， 如果表达不当 ， 还请及时指教
Spring的IOC(控制反转)和DI(依赖注入)
首先我们来看一段代码
public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Spring.xml"); UserService userService = (UserService) applicationContext.getBean("userService"); userService.test(); System.out.println("userService..." + userService); }
APPConfig代码
@ComponentScan("com.lyh") public class AppConfig{ }
从代码实现方式不难看出 , ClassPathXmlApplicationContext是用来加载xml配置文件的Context，而AnnotationConfigApplicationContext是用来加载注解配置的Context。虽然直接父类不同，但是都有一个共同的祖先类AbstractApplicationContext。以及同样有一个对象BeanFactory提供容器作用。
但是用ClassPathXmlApplicationContext其实已经过时了，在新版的Spring MVC和Spring Boot的底层主要用的都是AnnotationConfigApplicationContext
Spring容器创建完之后 , 接下来就是从Spring容器中getBean() , 那么这个bean一定是Spring容器帮我们创建的 , 这也就是Spring容器的一个核心: IOC(控制反转)
IOC(控制反转) : 将创建对象及生命周期的管理交给Spring容器 , 在开发中 , 我们不需要关注对象的创建以及生命周期的管理 , 而是由Spring来提供 , 这个由Spring来管理创建对象以及生命周期的机制就称为控制反转 , 也就是IOC
那么我们getBean()得到的对象和我们直接new UserService()得到的对象有什么不同呢?我们用代码举个例子
@Component public class OrderService { @Autowired private UserService userService; } @Component public class UserService { }
现在我们有两个类 , 一个是OrderServer , 一个是UserServer , 通过@Autowired将UserServer 注入到OrderServer 中, 那么通过getBean()拿到OrderServer 这个对象 , 它的UserServer属性一定是有值的 , 而通过new OrderServer()的方式拿到的对象 , UserServer的值一定是空的 , 所以区别也就显而易见了
通过getBean()拿到的对象 , 它的属性是是有值的 , 而直接new出来的对象, 它的属性就是空的
而给属性赋值的过程就可以称为DI(依赖注入)
Spring是如何创建这个对象的
其实通过上面的代码示例可以稍微进行推测 , 其实不管是AnnotationConfigApplicationContext还是ClassPathXmlApplicationContext，目前，我们都可以简单的将它们理解为就是用来创建Java对象的容器，比如调用getBean()就可能去创建对象 , 但是也有可能不创建 , 在Java语言中，肯定是根据某个类来创建一个对象的
当我们调用context.getBean(“userService”)时，就会去创建一个对象，但是getBean方法内部怎么知道"userService"对应的是UserService类呢？
我们可以分析出来当new AnnotationConfigApplicationContext(AppConfig.class)的时候, 他就会大概进行一些操作
解析AppConfig , 然后得到扫描路径
遍历扫描路径下的所有Java类，如果发现某个类上存在@Component、@Service等注解，那么Spring就把这个类记录下来，存在一个Map中，比如Map<String, Class>。（实际上，Spring源码中确实存在类似的这么一个Map，叫做BeanDefinitionMap，后续文章会有说明）
Spring会根据某个规则生成当前类对应的beanName，作为key存入Map，当前类作为value
然后我们getBean()的时候就可以根据"userService"找到UserService类，从而就可以去创建对象了
Bean的创建过程
通过以上示例代码我们大概可以看出一个简单的过程就是这样
1.找到需要创建的类(扫描)
2.通过默认的无参构造方法得到一个对象(但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做推断构造方法)
3. 给加了@Autowired等注解的属性进行赋值(依赖注入)
4. …
5. 然后得到一个bean
一个比较完整的流程大致如下
1.找到需要创建的类(扫描)
2.通过默认的无参构造方法得到一个对象(但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做推断构造方法)
3.给加了@Autowired等注解的属性进行赋值(依赖注入)
4.依赖注入后，Spring会判断该对象是否实现了BeanNameAware接口、BeanClassLoaderAware接口、BeanFactoryAware接口，如果实现了，就表示当前对象必须实现该接口中所定义的setBeanName()、setBeanClassLoader()、setBeanFactory()方法，那Spring就会调用这些方法并传入相应的参数（Aware回调）
5.Aware回调后，Spring会判断该对象中是否存在某个方法被@PostConstruct注解了，如果存在，Spring会调用当前对象的此方法（初始化前）
6.紧接着，Spring会判断该对象是否实现了InitializingBean接口，如果实现了，就表示当前对象必须实现该接口中的afterPropertiesSet()方法，那Spring就会调用当前对象中的afterPropertiesSet()方法（初始化）
7.最后，Spring会判断当前对象需不需要进行AOP，如果不需要那么Bean就创建完了，如果需要进行AOP，则会进行动态代理并生成一个代理对象做为Bean（初始化后）
那么Bean对象创建出来之后
1.如果当前Bean是单例Bean，那么会把该Bean对象存入一个Map<String, Object>，Map的key为beanName，value为Bean对象。这样下次getBean时就可以直接从Map中拿到对应的Bean对象了。（实际上，在Spring源码中，这个Map就是单例池）
2.如果当前Bean是原型Bean，那么后续没有其他动作，不会存入一个Map，下次getBean时会再次执行上述创建过程，得到一个新的Bean对象
如图所示
上述Bean生命周期并不是完整的 , 它中间还有好多 , 后面的文章再慢慢详解, 接下来把上述步骤做一个说明
推断构造方法
什么是推断构造方法？
Spring需要根据某一个类的构造方法得到一个普通对象 ， 它首先得判断它使用哪个构造方法以及需要什么参数 ， 下面用一些例子来进行演示
例1：如果有一个无参构造和一个有参构造 , 那么Spring会使用哪个构造方法?
代码如下:
@Component public class UserService { @Autowired private OrderService orderService; public UserService() { System.out.println("无参构造"); } public UserService(OrderService orderService) { this.orderService = orderService; System.out.println("有参构造"); } }
运行之后可以发现 , Spring使用的是无参构造方法
例2：如果有两个有参构造呢?
@Component public class UserService { @Autowired private OrderService orderService; public UserService(OrderService orderService) { this.orderService = orderService; System.out.println("有参构造1"); } public UserService(OrderService orderService , OrderService orderService1) { this.orderService = orderService; System.out.println("有参构造2"); } }
直接就是运行报错 , 报错信息如下 , 那么为什么会运行报错呢?不妨把有参构造注释掉一个
Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.lyh.service.UserService]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.lyh.service.UserService.()
@Component public class UserService { @Autowired private OrderService orderService; // public UserService(OrderService orderService) { // this.orderService = orderService; // System.out.println("有参构造1"); // } public UserService(OrderService orderService , OrderService orderService1) { this.orderService = orderService; System.out.println("有参构造2"); } }
运行之后发现 , 没有报错 , 首先证明了一点, 这样写是没有问题的 , 那么想一下 , Spring要通过构造方法去创建对象 , 但是现在有两个 , 那么到底用哪一个呢?Spring是不知道的 , 所以就抛了异常
接下来我们再分析报错信息 : No default constructor found , 没有找到一个默认的构造方法 , 现在我们是因为写了多个有参的构造从而报的错 , 那么为什么会报一个没有默认的构造方法的错呢?
其实Spring在有多个有参构造时会去找无参的构造方法 ,因为无参的构造也有一种默认的意义, 而我们又没有默认的构造方法 , 所以就抛了这个异常
如果非要有两个有参构造 ， 也不是不行 ， 既然它不知道用哪一个 ， 那么就加一个@Autowired告诉它用哪一个 ， 例如这样：
@Component public class UserService { @Autowired private OrderService orderService; public UserService(OrderService orderService) { this.orderService = orderService; System.out.println("有参构造1"); } @Autowired public UserService(OrderService orderService , OrderService orderService1) { this.orderService = orderService; System.out.println("有参构造2"); } }
例3：只有一个有参构造方法的情况下 ,这个方法的入参会不会有值?
首先说明 ， 如果只有一个有参构造 ， 那么就会覆盖整个默认无参的构造方法 ， 如果还需要有无参的 ， 就需要自己把它定义出来
@Component public class UserService { @Autowired private OrderService orderService; public UserService(OrderService orderService) { System.out.println("orderService : " + orderService); this.orderService = orderService; System.out.println("有参构造1"); } }
运行之后发现是有值的 , 那么这个值会从哪里来呢?
首先在创建UserService 这个类的时候 ， 会使用这个唯一的有参构造 ，Spring就会找一个OrderService的Bean来赋值 ， 前提是OrderService必须是一个Bean
那么根据什么找呢？
通常我们说一个Bean ， 这个Bean肯定有一个类型的 ， 还有一个名称 ，那无非就是入参的类型：OrderService， 以及参数名称： orderService
可能有人会想到 ， 在Bean创建完成之后 ， 会把该Bean对象存入一个Map<String, Object>，Map的key为beanName，value为Bean对象 ， 也就是单例池 ， 那么把参数名称orderService当作key ， 来这个map获取 ， 这种方式可行吗？
可行是可行 ， 但是有一个问题，类型是不对应的 ， 很有可能注入的时候是这样注入的：
@Autowired
private OrderService memberService;
那么这样直接通过名称过去出来的类型就是不对应的 ， 由此可见 ， 这个名称其实不是那么的重要 ,重要的是类型
所以最保险的方式就是根据类型去找 ， 但是通过类型会找到多个 ， 比如代码是这样写的情况：
@ComponentScan("com.lyh") public class AppConfig{ @Bean public OrderService orderService1(){ return new OrderService(); } @Bean public OrderService orderService2(){ return new OrderService(); } }
可以思考一个问题 ，现在Spring容器中有几个OrderService 类型的Bean？
AppConfig中定义了两个 ， 还有我们通过@Component来声明的一个 ， 那么就是三个
我们可以运行代码看看结果
public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); Object orderService = applicationContext.getBean("orderService"); System.out.println("orderService : " + orderService); Object orderService1 = applicationContext.getBean("orderService1"); System.out.println("orderService1 : " + orderService1); Object orderService2 = applicationContext.getBean("orderService2"); System.out.println("orderService2 : " + orderService2); }
运行结果：
orderService : com.lyh.service.OrderService@49b0b76 orderService1 : com.lyh.service.OrderService@769f71a9 orderService2 : com.lyh.service.OrderService@4c9f8c13
很显然 ， 都是有值的 ， 那么通过类型找到三个 ， 不可能把这三个都传进来 ， 需要确定一个 ， 怎么去确定其中一个呢？
我们可以通过有参构造入参的参数名称orderService 去找 ， 这样是不是就可以找到一个 ， 然后赋值 ， 这个名字是不会重名的，如果有重名，可能会直接覆盖 ， 因为他是存在map中的 ， 而map的key是不允许重复的
例4：只有一个有参构造方法的情况下 ，参数名称改变 ， 会抛出异常？还是正常执行
@Component public class UserService { @Autowired private OrderService orderService; public UserService(OrderService orderService3) { this.orderService = orderService3; System.out.println("有参构造1"); }
运行之后肯定是报错的 ， 报错信息如下：
Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.lyh.service.OrderService’ available: expected single matching bean but found 3: orderService,orderService1,orderService2
大概意思就是找到了三个Bean ： orderService,orderService1,orderService2 ， 但是没有符合条件的bean，这个条件就是参数名称是orderService3的
例5：只有一个有参同时只定义一个OrderService类型的bean， 然后参数名称改变
对上面的代码进行简单改造 ， 使OrderService类型的bean只有一个 ， 注掉AppConfig类的相关代码
@ComponentScan("com.lyh") public class AppConfig{ //@Bean //public OrderService orderService1(){ // return new OrderService(); //} //@Bean //public OrderService orderService2(){ // return new OrderService(); //} }
UserService
@Component public class UserService { @Autowired private OrderService orderService; public UserService(OrderService orderService3) { this.orderService = orderService3; System.out.println("有参构造 ： " + orderService3); } }
OrderService
//@Component public class OrderService { public OrderService() { }
运行之后，程序正常
有参构造 ： com.zhouyu.service.OrderService@d83da2e
因为它通过类型就从Spring容器中找到了一个 ， 所以直接赋值
例6：那么取消定义OrderService这个Bean呢
//@Component public class OrderService { public OrderService() { }
运行之后发现报错了 , 报错类型如下
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type ‘com.lyh.service.OrderService’ available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {}
大概就是说预计有一个OrderService的bean ， 但是没有找到这个bean ， 因为他想从Spring容器中找一个OrderService类型的bean来注入 ，但是现在没有这个bean ， 所以就报了这个错误
构造方法推断完成之后就得到了一个普通的对象 ， 那么Spring拿到整个对象之后就可以为属性去赋值了 ， 那么也就是接下来要说的DI(依赖注入)
DI(依赖注入)
例1： Spring给属性赋值 ， 赋的是什么值呢？去哪里找这个值呢？
AppConfig
@ComponentScan("com.lyh") public class AppConfig{ }
UserService
@Component public class UserService { @Autowired private OrderService orderService;// 赋的是什么值呢？ public UserService(OrderService orderService) { this.orderService = orderService; System.out.println("有参构造 ： " + orderService); } }
OrderService
@Component public class OrderService { public OrderService() { } }
先根据类型 ， 再根据名称 ， 也就是先byType ， 再byName ， 结合上面的推断构造方法是不是就对依赖注入也通畅了一点
初始化前
初始化前也就是执行@PostConstruct注解的方法 ， 通过反射去判断那些方法加了@PostConstruct ， 然后执行
初始化
初始化也就是执行实现了InitializingBean接口的afterPropertiesSet()方法
初始化后
初始化后也就是我们的AOP ，那么我们还是通过例子来说明
例1：使某个类成为代理对象 ， 那么代理对象中的属性会不会有值
@Component public class UserService { @Autowired private OrderService orderService; public void test(){ System.out.println("UserService test 方法执行"); } }
定义切面类
@Aspect @Component public class LyhAspect { @Before("execution(public void com.lyh.service.UserService.test())") public void lyhBefore(JoinPoint joinPoint) { System.out.println("zhouyuBefore"); } }
开启代理
@ComponentScan("com.lyh") @EnableAspectJAutoProxy public class AppConfig{
测试
public class TestSpring { public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); UserService userService = (UserService) applicationContext.getBean("userService"); userService.test(); } }
我们可以现在userService.test();这行代码打个断点
可以发现 ，他确实是一个代理对象 ， 同时也可以看到orderService = null ， 表示它确实没有值 ， 为什么呢？难道开了AOP之后依赖注入不生效了吗？其实不是这样的 ， 通过阅读上面的文章我们发现 ， 再bean初始化之后并没有依赖注入这个步骤 ， 也就是说Spring就没有这么设计
然后我们在UserService这个类中的test()方法中的 System.out.println(“UserService test 方法执行”); 打个断点 ， 然后继续往下走 ， 你会发现 ， 一旦进入到test方法 ， 它orderService属性就有值了
也就是说@Autowired注解还是生效的 ， 并且在test方法中也可以使用
那么为什么代码在进入到test()方法之后orderService属性才有值？
这个时候我们首先要明白Cglib的工作原理 , 他的原理大概是这样: 动态生成被代理类的子类 , 对于上面的例子而言 , 也就是说Cglib会生成一个userService的子类 , 并且继承userService , 伪代码如下
public class UserServiceProxyCGlib extends UserService { @Override public void test() { // @Before切面逻辑 super.test(); // @after切面逻辑...等等 } }
那么我们在调用test()方法的时候 , 其实执行的是UserServiceProxyCGlib的test();然后再执行super.test(); , 这个时候肯定没有值 , 因为他只是一个方法的调用而已 , 但是我们又希望他有值 . 那么怎么做呢? 上面提到过 , 推断完构造方法之后会得到一个普通对象 , 然后给这个普通对象进行依赖注入 , 那么我们是不是就可以使用这个普通对象,代码原理代码实现如下所示
public class UserServiceProxyCGlib extends UserService { UserService target; @Override public void test() { // @Before切面逻辑 target.test(); // @after切面逻辑...等等 } }
这样的话 , 等你这正执行test()方法的时候 , 已经是经过依赖注入的对象 , 那么就肯定是有值的, 通过debug也可以很清楚的看到 , 因为从Srping容器获取到的就是一个代理对象 , 那么执行代理对象的test()方法 , orderService的值肯定是空的 , 但是target是有值的 , 所以通过执行target.test();orderService也就是有值的
Spring它怎么知道这个Bean要进行AOP呢？
首先他肯定会从容器中拿到所有的切面Bean ， 然后去遍历拿出来的这些切面Bean ， 然后再遍历这些切面Bean中的方法来判断它有没有@Before之类的注解 ， 如果有那么就判断这个注解里面定义的表达式是否和我当前创建的Bean匹配 ， 如果匹配 ， 难么Spring就知道当前类是需要AOP的 ， 然后Spring会把所有和当前创建类匹配的所有的方法给缓存起来 ， 存到一个map中 ，等真正要执行切面逻辑的时候 ， 再从缓存获取 ， 然后直接执行
这个过程还是非常重要的 ，在这里先简单讲一下原理 ，等后面会用源码来验证
自此 , Bean生命周期几个比较重要的流程也就大概过了一遍 , 后面的文章还会源码的分析来一步步看到这些过程
Spring事务
例1: 开始事务 , 然后执行sql并抛异常 , 数据库会不会有数据?
@ComponentScan("com.lyh") @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("jdbc:mysql://127.0.0.1:3306/world?characterEncoding=utf-8&useSSL=false"); dataSource.setUsername("root"); dataSource.setPassword("root"); return dataSource; } @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean(); sessionFactoryBean.setDataSource(dataSource()); return sessionFactoryBean.getObject(); } }
@Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/world?characterEncoding=utf-8&useSSL=false"); dataSource.setUsername("root"); dataSource.setPassword("root"); return dataSource; } @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean(); sessionFactoryBean.setDataSource(dataSource()); return sessionFactoryBean.getObject(); } }
@Component public class UserService { @Autowired private JdbcTemplate jdbcTemplate; @Transactional public void test(){ jdbcTemplate.execute("INSERT INTO `world`.`user`(`name`, `username`) VALUES ('2', '2')"); throw new NullPointerException(); }
然后我们来运行
public class TestSpring { public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class); UserService userService = (UserService) applicationContext.getBean("userService"); userService.test(); } }
通过观察数据库的数据 , 发现数据确实是写到数据库了 , 但是为什么呢?不是跑了异常吗?不应该回滚吗?
其实我们的代码都没有问题 , 但是我们少加了一个@Configuration的注解 , 我们把它加到AppConfig试一试 ,再次操作 , 发现依然报错 , 但是数据是没有写进去了 , 这是为什么呢?
首先我们需要明白的一点就是 , 当我们加了@Transactional注解之后 , Spring在创建这个类时会创建一个代理对象 , 所以我们从Spring容器拿出来的也是一个代理对象 , 现在它就不是AOP的代理对象 , 他是Spring事务所产生的代理对象 , 那么他的逻辑就是这样的
public class UserServiceProxyCGlib extends UserService { UserService target; @Override public void test() { // 判断有没有加@Transactional // 如果有 , 那么由Spring事务管理器创建一个数据库连接 // 设置autocommit属性为false , 这个属性默认为true ,就是自动提交的意思 , 如果每执行一个sql提交一次, 那么@Transactional的意义何在呢?如果前面的sql执行完了 , 后面抛异常了 , 那我还回滚什么东西呢? target.test(); // 执行完之后调用commit()方法提交 // 如果抛异常 , 那么调用rollback()方法 } }
这是Spring事务他大体的一个工作原理
我们来看transactionManager()和jdbcTemplate()方法都是在调用dataSource() , 调用dataSource()方法就会产生一个DriverManagerDataSource对象 , 所以调用两次就会产生两个不同的DriverManagerDataSource对象 , 所以问题也就出来了 : 我们执行jdbcTemplate.execute()时的datasource对象是两个不同的对象 , 也就是说Spring事务管理器创建的一个数据库连接根本没有用 , 但是如果加了@Configuration ,(当然还有其他一些逻辑) 那么就能保证它的datasource就是同一个 , 但是前提是datasource为同一个 , 那么为什么会是同一个呢?这里也和代理模式是有关系 , 加了@Configuration之后AppConfig也会成为一个代理对象 , 那么代理逻辑就是当我们执行datasource()方法的时候 , 它会先去Spring容器看看有没有 , 如果有那么就直接返回 , 如果没有那就真正执行datasource()方法 , 但是如果是这样写的就有问题
@ComponentScan("com.lyh") @EnableTransactionManagement public class AppConfig{ @Bean public JdbcTemplate jdbcTemplate() { return new JdbcTemplate(dataSource()); } @Bean public PlatformTransactionManager transactionManager() { DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); transactionManager.setDataSource(**dataSource1()**); return transactionManager; } @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/world?characterEncoding=utf-8&useSSL=false"); dataSource.setUsername("root"); dataSource.setPassword("root"); return dataSource; } @Bean public DataSource dataSource1() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/world?characterEncoding=utf-8&useSSL=false"); dataSource.setUsername("root"); dataSource.setPassword("root"); return dataSource; } @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean(); sessionFactoryBean.setDataSource(dataSource()); return sessionFactoryBean.getObject(); } }
配了两个dataSource , 那么还是会出现问题的
例2: 事务失效场景之一
改在一个UserService类代码如下 , 并且把传播度等级设置为NEVER , NEVER就表示 , 如果有一个事务的话 , 就会抛异常
@Component public class UserService { @Autowired private JdbcTemplate jdbcTemplate; @Transactional public void test(){ jdbcTemplate.execute("INSERT INTO `world`.`user`(`name`, `username`) VALUES ('3', '3')"); this.test1(); } @Transactional(propagation = Propagation.NEVER) public void test1(){ } }
按理说他这个如果运行是要报错的 , 但是真正运行发现没有报错 , 那么是为什呢?
我们可以仔细理解一下 , 这个test1()方法到底是谁在调用?他的执行逻辑还是相同
public class UserServiceProxyCGlib extends UserService { UserService target; @Override public void test() { // 判断有没有加@Transactional // 如果有 , 那么由Spring事务管理器创建一个数据库连接 // 设置autocommit属性为false , 这个属性默认为true ,就是自动提交的意思 , 如果每执行一个sql提交一次, 那么@Transactional的意义何在呢?如果前面的sql执行完了 , 后面抛异常了 , 那我还回滚什么东西呢? target.test(); // 执行完之后调用commit()方法提交 // 如果抛异常 , 那么调用rollback()方法 } }
但是是由target调用的test()方法 , target不就是UserService吗 , 所以test1()方法的调用者也是target , 那么target是一个执行这个test1()方法 , 这个@Transactional注解有什么用呢?
这就是我们经常会遇到的一个事务失效的场景 , 那么怎么解决呢?
首先我们需要根据业务理清楚加了@Transactional注解的方法到底是谁在调用 , 在调用的时候是不是代理对象在调这个test1()方法 , 只要是代理对象在调用 , 那么@Transactional注解就是生效的
或许有人是这样解决的
新增一个类 :
@Component public class UserServiceBase { @Transactional(propagation = Propagation.NEVER) public void test1(){ } }
然后这样调用
@Component public class UserService { @Autowired private JdbcTemplate jdbcTemplate; @Autowired private UserServiceBase userServiceBase; @Transactional public void test(){ jdbcTemplate.execute("INSERT INTO `world`.`user`(`name`, `username`) VALUES ('3', '3')"); userServiceBase.test1(); }
然后我们可以运行 , 会发现报错了
Exception in thread “main” org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation ‘never’
这个才是我们想要看的结果 ,我们可以简单分析一下 , userServiceBase的test1()方法也是有事务存在的 , 同时userServiceBase也是一个Bean , 它最终也会产生一个代理对象去当做一个Bean , 碎玉UserService而言 , 我要给userServiceBase这个属性去赋值 , 那么他肯定要从Spring容器中找到一个userServiceBase的一个Bean来赋值 , 所以他找到的就是Spring事务所产生的userServiceBase的代理对象 , 所以这个注解就是有用的
其实如果明白了上面的逻辑 , 那么还有一种简单的办法 , 就是自己注入自己
@Component public class UserService { @Autowired private JdbcTemplate jdbcTemplate; @Autowired private UserService userService; @Transactional public void test(){ jdbcTemplate.execute("INSERT INTO `world`.`user`(`name`, `username`) VALUES ('3', '3')"); userService.test1(); } @Transactional(propagation = Propagation.NEVER) public void test1(){ } }
最终还是要给这个userService属性去赋值 , 那么就会从Spring容器中去找 , 找到的就是一个userService的代理对象
以上就是对Spring比较重要的几个过程 , 可以稍微了解一下 , 方便对后面的源码的阅读
