前言
这篇文章在前一段时间看到一位大佬写的,因为写的逻辑清晰、通俗易懂,当时我就整理了一下笔记,希望日后自己也行写出这样的文章。如果想对spring了解和入门的同学,相信认真阅读了本篇文章定会收获颇丰。
特此说明:此篇文章主要目的是当做范文,以此鼓励自己在不断学习总结中创作出更多更好的优质原创文章;找了半天没有找到原文章,如有打扰即刻删除。
主要内容:
默认题主说的Spring是Spring framework,而不是Spring家族
- 盲点
- Spring说,万物皆可定义
- 默默付出的后置处理器
- 利用后置处理器返回代理对象
盲点
如果你从未独立看过源码(和我一样),那么你很可能至今都不曾注意某两个概念。
你以为我会说IOC和AOP?No。
看到这里,一部分读者心里一惊:卧槽,说的啥玩意,Spring不就IOC和AOP吗?!这两个都不说,你这篇文章为啥能写这么长?
不错,我就是这么长。其实我要讲的是:
- BeanDefinition
- BeanPostProcessor
大部分人一听到“请你谈谈对Spring的理解”,就会下意识搬出IOC和AOP两座大山,赶紧糊弄过去。大概是这样的:
IOC
所谓的控制反转。通俗地讲,就是把原本需要程序员自己创建和维护的一大堆bean统统交由Spring管理。
所谓的面向切面编程。通俗地讲,它一般被用来解决一些系统交叉业务的织入,比如日志啦、事务啥的。打个比方,UserService的method1可能要打印日志,BrandService的method2可能也需要。亦即:一个交叉业务就是要切入系统的一个方面。具体用代码展示就是:
交叉业务的编程问题即为面向切面编程。AOP的目标就是使交叉业务模块化。做法是将切面代码移动到原始方法的周围:
- 首先,这与AOP的底层实现方式有关:动态代理其实就是代理对象调用目标对象的同名方法,并在调用前后加增强代码。
- 其次,这两种最终运行效果是一样的,所以没什么好纠结的。
而所谓的模块化,我个人的理解是将切面代码做成一个可管理的状态。比如日志打印,不再是直接硬编码在方法中的零散语句,而是做成一个切面类,通过通知方法去执行切面代码。
我相信大部分培训班出来的朋友也就言尽于此,讲完上面内容就准备收拾打卡下班了。
怎么说呢,IOC按上面的解释,虽然很浅,但也马马虎虎吧。然而AOP,很多人对它的认识是非常片面的...
这样吧,我问你一个问题,现在我自己写了一个UserController,以及UserServiceImpl implements UserService,并且在UserController中注入Service层对象:
@Autowired
private UserService userService;
复制代码
如果你听不懂我要问什么,说明你对Spring的AOP理解还是太少了。
实际上,Spring依赖注入的对象并不一定是我们自己写的类的实例,也可能是userServiceImpl的代理对象。下面分别演示这两种情况:
- 注入userServiceImpl对象
- 注入userServiceImpl的代理对象(CGLib动态代理)
因为第二次我给UserServiceImpl加了@Transactional 注解。
看到这里,我仿佛听到有一部分兄弟默默说了句:卧槽...
但是,上面对IOC和AOP的理解,也仅仅是应用级别,是一个面。仅仅了解到这个程度,对Spring的了解还是非常扁平的,不够立体。
Spring说,万物皆可定义
上帝说,要有光。于是特斯拉搞出了交流电。
Java说,万物皆对象。但是Spring另外搞了BeanDefinition...
什么BeanDefinition呢?其实它是bean定义的一个顶级接口:
哎呀卧槽,啥玩意啊。描述一个bean实例?我咋想起了Class类呢。
其实,两者并没有矛盾。
- 单例吗?
- 是否需要延迟加载?
- 需要调用哪个初始化方法/销毁方法?
大部分初学者以为Spring解析或者@Bean后,就直接搞了一个bean存到一个大Map中,其实并不是。
- Spring首先会扫描解析指定位置的所有的类得到Resources(可以理解为.Class文件)
- 然后依照TypeFilter和@Conditional注解决定是否将这个类解析为BeanDefinition
- 稍后再把一个个BeanDefinition取出实例化成Bean
就好比什么呢?你从海里吊了一条鱼,但是你还没想好清蒸还是红烧,那就干脆先晒成鱼干吧。一条咸鱼,其实蕴藏着无线可能,因为它可能会翻身!
默默付出的后置处理器
接下来,我们讨论一下咸鱼如何翻身。
最典型的例子就是AOP。上面AOP的例子中我说过了,如果不加@Transactional,那么Controller层注入的就是普通的userServiceImpl,而加了以后返回的实际是代理对象。
为什么要返回代理对象?因为我们压根就没在UserServiceImpl中写任何commit或者rollback等事务相关的代码,但是此时此刻代理对象却能完成事务操作。毫无疑问,这个代理对象已经被Spring加了佐料。
那么Spring是何时何地加佐料的呢?说来话长。
大部分人把Spring比作容器,其实潜意识里是将Spring完全等同于一个Map了。其实,真正存单例对象的map,只是Spring中很小很小的一部分,仅仅是BeanFactory的一个字段,我更习惯称它为“单例池”。
/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
复制代码
所以,很多人把Spring理解成一个大Map,还是太浅了。就拿ApplicationContext来讲,它也实现了BeanFactory接口,但是作为容器,其实它是用来包含各种各样的组件的,而不是存bean:
后置处理器其实可以分好多种,属于Spring的扩展点之一。
@Autowired
ApplicationContext annotationConfigApplicationContext;
复制代码
除了利用Spring本身的IOC容器自动注入以外,你还有别的办法吗?
我们可以让Bean实现ApplicationContextAware接口:
Spring官方文档:一般来说,您应该避免使用它,因为它将代码耦合到Spring中,并且不遵循控制反转样式
这是我认为Spring最牛逼的地方:代码具有高度的可扩展性,甚至你自己都懵逼,为什么实现了一个接口,这个方法就被莫名其妙调用,还传进了一个对象...
这其实就是后置处理器的工作!
什么意思呢?
就是说啊,明面上我们看得见的地方只要实现一个接口,但是背地里Spring在自己框架的某一处搞了个for循环,遍历所有的BeanPostProcessor,其中就包括处理实现了ApplicationContextAware接口的bean的后置处理器:ApplicationContextAwareProcessor。
上面这句话有点绕,大家停下来多想几遍。
if (bean instanceof Aware) {
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
}
}
复制代码
所以,此时此刻一个类实现ApplicationContextAware接口,有两层含义:
- 作为后置处理器的判断依据,只有你实现了该接口我才处理你
- 提供被后置处理器调用的方法
利用后置处理器返回代理对象
大致了解Spring Bean的创建流程后,接下来我们尝试着用BeanPostProcessor返回当前Bean的代理对象。
pom.xml
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.12.RELEASE</version>
</dependency>
</dependencies>
复制代码
AppConfig
@Configuration//JavaConfig方式,即当前配置类相当于一个applicationConotext.xml文件
@ComponentScan//默认扫描当前配置类(AppConfig)所在包及其子包
public class AppConfig {
}
复制代码
Calculator
public interface Calculator {
public void add(int a, int b);
}
复制代码
CalCulatorImpl
@Component
public class CalculatorImpl implements Calculator {
public void add(int a, int b) {
System.out.println(a+b);
}
}
复制代码
后置处理器MyAspectJAutoProxyCreator
使用步骤:
- 实现BeanPostProcessor
- @Component加入Spring容器
@Component
public class MyAspectJAutoProxyCreator implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
final Object obj = bean;
//如果当前经过BeanPostProcessors的Bean是Calculator类型,我们就返回它的代理对象
if (bean instanceof Calculator) {
Object proxyObj = Proxy.newProxyInstance(
this.getClass().getClassLoader(),
bean.getClass().getInterfaces(),
new InvocationHandler() {
public Object invoke(Object proxy,Method method, Object[] args) throws Throwable {
System.out.println("开始计算....");
Object result = method.invoke(obj, args);
System.out.println("结束计算...");
return result;
}
}
);
return proxyObj;
}
//否则返回本身
return obj;
}
}
复制代码
测试类
public class TestPostProcessor {
public static void main(String[] args) {
System.out.println("容器启动成功!");
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
//打印当前容器所有BeanDefinition
for (String beanDefinitionName : beanDefinitionNames) {
System.out.println(beanDefinitionName);
}
System.out.println("============");
//取出Calculator类型的实例,调用add方法
Calculator calculator = (Calculator)applicationContext.getBean(Calculator.class);
calculator.add(1, 2);
}
复制代码
先把MyAspectJAutoProxyCreator的@Component注释掉,此时Spring中没有我们自定义的后置处理器,那么返回的就是CalculatorImpl: