搜索到
2
篇与
Bean
的结果
-
Spring 源码阅读第三节 - Bean的生命周期 Bean的生命周期Bean的生成过程生成BeanDefinition合并BeanDefinition加载类实例化前实例化BeanDefinition的后置处理实例化后自动注入处理属性执行Aware初始化前初始化初始化后Bean的销毁过程Bean的生成过程1. 生成BeanDefinitionSpring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage) 扫描某个包路径，并得到BeanDefinition的Set集合。首先，通过ResourcePatternResolver获得指定包路径下的所有 .class 文件（Spring源码中将此文件包装成了Resource对象）遍历每个Resource对象利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选（条件注解并不能理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition再基于metadataReader判断是不是对应的类是不是接口或抽象类如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有：获取类的名字、获取父类的名字获取所实现的所有接口名获取所有内部类的名字判断是不是抽象类判断是不是接口判断是不是一个注解获取拥有某个注解的方法集合获取类上添加的所有注解信息获取类上添加的所有注解类型集合值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的<bean/>，或者@Bean注解得到BeanDefinition对象。（后续会分析@Bean注解是怎么生成BeanDefinition的）。2. 合并BeanDefinition通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在Spring中支持父子BeanDefinition，和Java父子类类似，但是完全不是一回事。父子BeanDefinition实际用的比较少，使用是这样的，比如：<bean id="parent" class="com.demo.service.Parent" scope="prototype"/> <bean id="child" class="com.demo.service.Child"/>这么定义的情况下，child是单例Bean。<bean id="parent" class="com.demo.service.Parent" scope="prototype"/> <bean id="child" class="com.demo.service.Child" parent="parent"/>但是这么定义的情况下，child就是原型Bean了。因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。3. 加载类BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的createBean()方法中，一开始就会调用：Class<?> resolvedClass = resolveBeanClass(mbd, beanName);这行代码就是去加载类，该方法是这么实现的：... if (mbd.hasBeanClass()) { return mbd.getBeanClass(); } if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ‐> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext()); } else { return doResolveBeanClass(mbd, typesToMatch); } ...public boolean hasBeanClass() { return (this.beanClass instanceof Class); }如果beanClass属性的类型是Class，那么就直接返回，如果不是，则会根据类名进行加载（doResolveBeanClass方法所做的事情）会利用BeanFactory所设置的类加载器来加载类，如果没有设置，则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载。ClassUtils.getDefaultClassLoader()优先返回当前线程中的ClassLoader线程中类加载器为null的情况下，返回ClassUtils类的类加载器如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器4. 实例化前当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但是...在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：@Component public class DemoBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { if ("userService".equals(beanName)) { System.out.println("实例化前"); } return null; } }如上代码会导致，在userService这个Bean实例化前，会进行打印。值得注意的是，postProcessBeforeInstantiation()是有返回值的，如果这么实现：@Component public class DemoBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { if ("userService".equals(beanName)) { System.out.println("实例化前"); return new UserService(); } return null; } }5. 实例化在这个步骤中就会根据BeanDefinition去创建一个对象了。5.1 Supplier创建对象首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。得直接使用BeanDefinition对象来设置Supplier，比如：AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition(); beanDefinition.setInstanceSupplier(new Supplier<Object>() { @Override public Object get() { return new UserService(); } }); context.registerBeanDefinition("userService", beanDefinition);5.2 工厂方法创建对象如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod，也就是工厂方法，有两种方式可以设置factoryMethod，比如：方式一：<bean id="userService" class="com.demo.service.UserService" factory‐ method="createUserService" />对应的UserService类为：public class UserService { public static UserService createUserService() { System.out.println("执行createUserService()"); UserService userService = new UserService(); return userService; } public void test() { System.out.println("test"); } }方式二：<bean id="commonService" class="com.demo.service.CommonService"/> <bean id="userService1" factory‐bean="commonService" factory‐method="createUserService" />对应的CommonService的类为：public class CommonService { public UserService createUserService() { return new UserService(); } }Spring发现当前BeanDefinition方法设置了工厂方法后，就会区分这两种方式，然后调用工厂方法得到对象。值得注意的是，我们通过@Bean所定义的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常类似，@Bean所注解的方法就是factoryMethod，AppConfig对象就是factoryBean。如果@Bean所所注解的方法是static的，那么对应的就是方式一。5.3 推断构造方法推断完构造方法后，就会使用构造方法来进行实例化了。额外的，在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象意外，会还判断是否在对应的类中是否存在使用@Lookup注解了方法。如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。在实例化时，如果判断出来当前BeanDefinition中没有LookupOverride，那就直接用构造方法反射得到一个实例对象。如果存在LookupOverride对象，也就是类中存在@Lookup注解了的方法，那就会生成一个代理对象。@Lookup注解就是方法注入，使用demo如下：@Component public class UserService { private OrderService orderService; public void test() { OrderService orderService = createOrderService(); System.out.println(orderService); } @Lookup("orderService") public OrderService createOrderService() { return null; } } 6. BeanDefinition的后置处理Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring又提供了一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工，比如：@Component public class DemoMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor { @Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { if ("userService".equals(beanName)) { beanDefinition.getPropertyValues().add("orderService", new OrderService()); } } }在Spring源码中，AutowiredAnnotationBeanPostProcessor就是一个MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中会去查找注入点，并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）。7. 实例化后在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：@Component public class DemoInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if ("userService".equals(beanName)) { UserService userService = (UserService) bean; userService.test(); } return true; } }上述代码就是对userService所实例化出来的对象进行处理。这个扩展点，在Spring源码中基本没有怎么使用。8. 自动注入这里的自动注入指的是Spring的自动注入，后续依赖注入单独讲。9. 处理属性这个步骤中，就会处理@Autowired、@Resource、@Value等注解，也是通过InstantiationAwareBeanPostProcessor.postProcessProperties()扩展点来实现的，比如我们甚至可以实现一个自己的自动注入功能，比如：@Component public class DemoInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { if ("userService".equals(beanName)) { for (Field field : bean.getClass().getFields()) { if (field.isAnnotationPresent(DemoInject.class)) { field.setAccessible(true); try { field.set(bean, "123"); } catch (IllegalAccessException e) { e.printStackTrace(); } } } } return pvs; } } 关于@Autowired、@Resource、@Value的底层源码，会在后续的依赖注入中详解。10. 执行Aware完成了属性赋值之后，Spring会执行一些回调，包括：BeanNameAware：回传beanName给bean对象。BeanClassLoaderAware：回传classLoader给bean对象。BeanFactoryAware：回传beanFactory给对象。11. 初始化前初始化前，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessBeforeInitialization()，比如：@Component public class DemoBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if ("userService".equals(beanName)) { System.out.println("初始化前"); } return bean; } }利用初始化前，可以对进行了依赖注入的Bean进行处理。在Spring源码中：InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法，ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：EnvironmentAware：回传环境变量EmbeddedValueResolverAware：回传占位符解析器ResourceLoaderAware：回传资源加载器ApplicationEventPublisherAware：回传事件发布器MessageSourceAware：回传国际化资源ApplicationStartupAware：回传应用其他监听对象，可忽略ApplicationContextAware：回传Spring容器ApplicationContext12. 初始化查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()方法执行BeanDefinition中指定的初始化方法13. 初始化后这是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessAfterInitialization()，比如：@Component public class DemoBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if ("userService".equals(beanName)) { System.out.println("初始化后"); } return bean; } }可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。总结BeanPostProcessorInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()实例化MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()自动注入InstantiationAwareBeanPostProcessor.postProcessProperties()Aware对象BeanPostProcessor.postProcessBeforeInitialization()初始化BeanPostProcessor.postProcessAfterInitialization()Bean的销毁过程Bean销毁是发送在Spring容器关闭过程中的。在Spring容器关闭时，比如：AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); UserService userService = (UserService) context.getBean("userService"); userService.test(); // 容器关闭 context.close();在Bean创建过程中，在最后（初始化之后），有一个步骤会去判断当前创建的Bean是不是DisposableBean：当前Bean是否实现了DisposableBean接口或者，当前Bean是否实现了AutoCloseable接口BeanDefinition中是否指定了destroyMethod调用DestructionAwareBeanPostProcessor.requiresDestruction(bean)进行判断ApplicationListenerDetector中直接使得ApplicationListener是DisposableBeanInitDestroyAnnotationBeanPostProcessor中使得拥有@PreDestroy注解了的方法就是DisposableBean把符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（一个LinkedHashMap）在Spring容器关闭过程时：首先发布ContextClosedEvent事件调用lifecycleProcessor的onCloese()方法销毁单例Bean遍历disposableBeans把每个disposableBean从单例池中移除调用disposableBean的destroy()如果这个disposableBean还被其他Bean依赖了，那么也得销毁其他Bean如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉(inner bean参考https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-inner-beans)清空manualSingletonNames，是一个Set，存的是用户手动注册的单例Bean的beanName清空allBeanNamesByType，是一个Map，key是bean类型，value是该类型所有的beanName数组清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例Bean这里涉及到一个设计模式：适配器模式在销毁时，Spring会找出实现了DisposableBean接口的Bean。但是我们在定义一个Bean时，如果这个Bean实现了DisposableBean接口，或者实现了AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。所以，这里就需要进行适配，将实现了DisposableBean接口、或者AutoCloseable接口等适配成实现了DisposableBean接口，所以就用到了DisposableBeanAdapter。会把实现了AutoCloseable接口的类封装成DisposableBeanAdapter，而DisposableBeanAdapter实现了DisposableBean接口。 -
Spring 源码阅读第一节 SpringBean的生命周期底层原理依赖注入底层原理初始化底层原理推断构造方法底层原理AOP底层原理Spring事务底层原理入门使用Spring的代码：ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (UserService) context.getBean("userService"); userService.test();这三行代码底层都做了什么，比如：第一行代码，会构造一个ClassPathXmlApplicationContext对象，ClassPathXmlApplicationContext该如何理解，调用该构造方法除开会实例化得到一个对象，还会做哪些事情？第二行代码，会调用ClassPathXmlApplicationContext的getBean方法，会得到一个UserService对象，getBean()是如何实现的？返回的UserService对象和我们自己直接new的UserService对象有区别吗？第三行代码，就是简单的调用UserService的test()方法，不难理解。光看这三行代码，其实并不能体现出来Spring的强大之处，也不能理解为什么需要ClassPathXmlApplicationContext和getBean()方法，随着的深入将会改变你此时的观念，而对于上面的这些疑问，也会随着深入逐步得到解决。对于这三行代码，你现在可以认为：如果你要用Spring，你就得这么写。就像你要用Mybatis，你就得写各种Mapper接口。但是用ClassPathXmlApplicationContext其实已经过时了，在新版的Spring MVC和Spring Boot的底层主要用的都是AnnotationConfigApplicationContext，比如：AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); //ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (UserService) context.getBean("userService"); userService.test();可以看到AnnotationConfigApplicationContext的用法和ClassPathXmlApplicationContext是非常类似的，只不过需要传入的是一个class，而不是一个xml文件。而AppConfig.class和spring.xml一样，表示Spring的配置，比如可以指定扫描路径，可以直接定义Bean，比如：spring.xml中的内容为：<context:component-scan base-package="com.demo"/> <bean id="userService" class="com.demo.service.UserService"/>AppConfig中的内容为：@ComponentScan("com.demo") public class AppConfig { @Bean public UserService userService(){ return new UserService(); } } 所以spring.xml和AppConfig.class本质上是一样的。目前，我们基本很少直接使用上面这种方式来用Spring，而是使用Spring MVC，或者Spring Boot，但是它们都是基于上面这种方式的，都需要在内部去创建一个ApplicationContext的，只不过：Spring MVC创建的是XmlWebApplicationContext，和ClassPathXmlApplicationContext类似，都是基于XML配置的Spring Boot创建的是AnnotationConfigApplicationContext。因为AnnotationConfigApplicationContext是比较重要的，并且AnnotationConfigApplicationContext和ClassPathXmlApplicationContext大部分底层都是共同的Spring中是如何创建一个对象？其实不管是AnnotationConfigApplicationContext还是ClassPathXmlApplicationContext，目前，我们都可以简单的将它们理解为就是用来创建Java对象的，比如调用getBean()就会去创建对象（此处不严谨，getBean可能也不会去创建对象，后续详解）。在Java语言中，肯定是根据某个类来创建一个对象的。我们在看一下实例代码：AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); UserService userService = (UserService) context.getBean("userService"); userService.test();当我们调用context.getBean("userService")时，就会去创建一个对象，但是getBean方法内部怎么知道"userService"对应的是UserService类呢？所以，我们就可以分析出来，在调用AnnotationConfigApplicationContext的构造方法时，也就是第一行代码，会去做一些事情：解析AppConfig.class，得到扫描路径遍历扫描路径下的所有Java类，如果发现某个类上存在@Component、@Service等注解，那么Spring就把这个类记录下来，存在一个Map中，比如Map<String, Class>。（实际上，Spring源码中确实存在类似的这么一个Map，叫做BeanDefinitionMap，后续会讲到）Spring会根据某个规则生成当前类对应的beanName，作为key存入Map，当前类作为value这样，但调用context.getBean("userService")时，就可以根据"userService"找到UserService类，从而就可以去创建对象了。Bean的创建过程那么Spring到底是如何来创建一个Bean的呢，这个就是Bean创建的生命周期，大致过程如下利用该类的构造方法来实例化得到一个对象（但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做推断构造方法）得到一个对象后，Spring会判断该对象中是否存在被@Autowired注解了的属性，把这些属性找出来并由Spring进行赋值（依赖注入）依赖注入后，Spring会判断该对象是否实现了BeanNameAware接口、BeanClassLoaderAware接口、BeanFactoryAware接口，如果实现了，就表示当前对象必须实现该接口中所定义的setBeanName()、setBeanClassLoader()、setBeanFactory()方法，那Spring就会调用这些方法并传入相应的参数（Aware回调）Aware回调后，Spring会判断该对象中是否存在某个方法被@PostConstruct注解了，如果存在，Spring会调用当前对象的此方法（初始化前）紧接着，Spring会判断该对象是否实现了InitializingBean接口，如果实现了，就表示当前对象必须实现该接口中的afterPropertiesSet()方法，那Spring就会调用当前对象中的afterPropertiesSet()方法（初始化）最后，Spring会判断当前对象需不需要进行AOP，如果不需要那么Bean就创建完了，如果需要进行AOP，则会进行动态代理并生成一个代理对象做为Bean（初始化后）通过最后一步，我们可以发现，当Spring根据UserService类来创建一个Bean时：如果不用进行AOP，那么Bean就是UserService类的构造方法所得到的对象。如果需要进行AOP，那么Bean就是UserService的代理类所实例化得到的对象，而不是UserService本身所得到的对象。Bean对象创建出来后：如果当前Bean是单例Bean，那么会把该Bean对象存入一个Map<String,Object>，Map的key为beanName，value为Bean对象。这样下次getBean时就可以直接从Map中拿到对应的Bean对象了。（实际上，在Spring源码中，这个Map就是单例池）如果当前Bean是原型Bean，那么后续没有其他动作，不会存入一个Map，下次getBean时会再次执行上述创建过程，得到一个新的Bean对象。推断构造方法Spring在基于某个类生成Bean的过程中，需要利用该类的构造方法来实例化得到一个对象，但是如果一个类存在多个构造方法，Spring会使用哪个呢？Spring的判断逻辑如下：如果一个类只存在一个构造方法，不管该构造方法是无参构造方法，还是有参构造方法，Spring都会用这个构造方法如果一个类存在多个构造方法这些构造方法中，存在一个无参的构造方法，那么Spring就会用这个无参的构造方法这些构造方法中，不存在一个无参的构造方法，那么Spring就会报错Spring的设计思想是这样的：如果一个类只有一个构造方法，那么没得选择，只能用这个构造方法如果一个类存在多个构造方法，Spring不知道如何选择，就会看是否有无参的构造方法，因为无参构造方法本身表示了一种默认的意义不过如果某个构造方法上加了@Autowired注解，那就表示程序员告诉Spring就用这个加了注解的方法，那Spring就会用这个加了@Autowired注解构造方法了需要重视的是，如果Spring选择了一个有参的构造方法，Spring在调用这个有参构造方法时，需要传入参数，那这个参数是怎么来的呢？Spring会根据入参的类型和入参的名字去Spring中找Bean对象（以单例Bean为例，Spring会从单例池那个Map中去找）：先根据入参类型找，如果只找到一个，那就直接用来作为入参如果根据类型找到多个，则再根据入参名字来确定唯一一个最终如果没有找到，则会报错，无法创建当前Bean对象确定用哪个构造方法，确定入参的Bean对象，这个过程就叫做推断构造方法。AOP大致流程AOP就是进行动态代理，在创建一个Bean的过程中，Spring在最后一步会去判断当前正在创建的这个Bean是不是需要进行AOP，如果需要则会进行动态代理。如何判断当前Bean对象需不需要进行AOP:找出所有的切面Bean遍历切面中的每个方法，看是否写了@Before、@After等注解如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配如果匹配则表示当前Bean对象有匹配的的Pointcut，表示需要进行AOP利用cglib进行AOP的大致流程：生成代理类UserServiceProxy，代理类继承UserService代理类中重写了父类的方法，比如UserService中的test()方法代理类中还会有一个target属性，该属性的值为被代理对象（也就是通过UserService类推断构造方法实例化出来的对象，进行了依赖注入、初始化等步骤的对象）代理类中的test()方法被执行时的逻辑如下：执行切面逻辑（@Before）调用target.test()当我们从Spring容器得到UserService的Bean对象时，拿到的就是UserServiceProxy所生成的对象，也就是代理对象。UserService代理对象.test()--->执行切面逻辑--->target.test()，注意target对象不是代理对象，而是被代理对象。Spring事务当我们在某个方法上加了@Transactional注解后，就表示该方法在调用时会开启Spring事务，而这个方法所在的类所对应的Bean对象会是该类的代理对象。Spring事务的代理对象执行某个方法时的步骤：判断当前执行的方法是否存在@Transactional注解如果存在，则利用事务管理器（TransactionMananger）新建一个数据库连接修改数据库连接的autocommit为false执行target.test()，执行程序员所写的业务逻辑代码，也就是执行sql执行完了之后如果没有出现异常，则提交，否则回滚Spring事务是否会失效的判断标准：某个加了@Transactional注解的方法被调用时，要判断到底是不是直接被代理对象调用的，如果是则事务会生效，如果不是则失效.
