AOP
Spring-AOP 是对 AOP框架之一。其他比如还有AspectJ
Aspect-Oriented-Programming(面向切面编程),一种编程思想。
切面:Aspect,由
切入点
和额外功能(增强)
组成。作用:提供了新的编程角度,不再只是考虑
类、对象
,而可以考虑切面
。切面和目标形成代理
,解决项目业务中额外功 能冗余的问题。
概念,切面,为什么aop,好处是什么
1. 业务中的问题
业务层中存在问题:两类逻辑=核心业务+额外功能,其中额外功能存在大量的代码冗余,
:使得项目维护存在极大隐患。
class UserServiceImpl implements UserService{
private UserDAO ud;
public void updateUser(User user){
System.out.println("事务管理功能");//额外功能 冗余
ud.update(user); //核心功能
}
public void inserUser(User user){
System.out.println("事务管理功能");//额外功能 冗余
ud.insertUser(user);//核心功能
}
public User queryUser(Integer id){
System.out.println("事务管理功能");//额外功能 冗余
ud.queryUser(id);//核心功能
}
}
2. 静态代理
代目标类打理了额外功能
目标类:UserServiceImpl ,即,被代理的类
代理类原则:要和原始的业务(target)实现同样的接口,保持功能一致。
代理类组成:额外功能(Advice) +目标(Target)解决了目标类的冗余问题,但自身却依然有冗余!!
class UserServiceProxy implements UserService{//代理类
UserService us=new UserServiceImpl();
public void updateUser(User user){
System.out.println("事务管理功能"); //代理类负责额外功能
us.updateUser(user); // 目标自己负责核心功能
}
public void inserUser(User user){
System.out.println("事务管理功能");//代理类负责额外功能
us.insertUser(user);// 目标自己负责核心功能
}
public User queryUser(Integer id){
System.out.println("事务管理功能");//代理类负责额外功能
us.queryUser(user);// 目标自己负责核心功能
}
}
// 创建代理对象,完成业务
UserService userService = new UserServiceProxy();
userService.insertUser(user);
3. 动态代理
通过动态字节码技术,在运行时动态生成代理( 反射 )。
则既不用维护代理类,有可以有代码打理额外功能。
动态代理的实现方案:
- jdk代理 ( jdk在反射包中提供的一套api ) 通过和目标实现相同的接口保证功能一致
- cglib代理 ( 第三方cglib库中的一套api ) 通过继承目标保证功能一致
Spring的AOP章节,底层采纳了如上两种代理实现,并对动态代理提供了,简单的,可操作性强的决绝方案。
当项目中需要使用代理解决问题时,可以采用AOP章节的内容加以解决。
org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy()中spring做了jdk代理和cglib代理的选择。
4. AOP 编码流程
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>4.3.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>4.3.6.RELEASE</version>
</dependency>
<!-- spring-aspects 会传递导入
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
<scope>compile</scope>
</dependency>
而aspectweaver 即 AspectJ 的一个库,(可以github搜索“AspectJ”,查看在Github上的镜像)。
spring-AOP模块,并没有独立提供完整的AOP实现,而是集成了【AspectJ框架(AOP框架)】
spring-aspects就是负责集成AspectJ。
-->
<!-- AOP联盟,可省略,spring4.3.6中的 aop模块中添加了其中的api( 兼容了AOP联盟 )
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
-->
4.1 准备 Target
public class UserServiceImpl implements UserService{
private UserDAO userDAO;
// set/get...
@Override
public void updateUser(User user) {
System.out.println("update in service===============");
userDAO.updateUser(user);
}
@Override
public void insertUser(User user) {
System.out.println("insert in service===============");
userDAO.insertUser(user);
}
}
4.2 准备 Advice
public class MyBeforeAdvice implements MethodBeforeAdvice{
/**
* @param method 当前执行的方法
* @param args 当前执行的方法中的参数
* @param target 目标对象
* @throws Throwable
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("before~~~");
}
}
4.3 编织 Weave
所谓编织,即,将Target 和 Advice 组装 形成代理。
当然组装过程由spring管理,开发者只需要做出配置,告知spring需要组装谁即可
<!-- 声明 Target + Advice -->
<!-- 声明 Target -->
<bean id="userService" class="com.zhj.service.UserServiceImpl">
<!-- 为userDAO属性赋值,值为id=“userDAO”的组件 -->
<property name="userDAO" ref="userDAO"/>
</bean>
<!-- Advice -->
<bean id="myBefore" class="com.zhj.advice.MyBeforeAdvice"/>
<!-- 编织 配置 -->
<aop:config>
<!-- ref="引入MyAdvice" -->
<aop:aspect ref="myAdvice">
<!-- 切入点=pointcut
execution()表达式:描述切入位置
组成:修饰符 返回值 包 类 方法名 参数表
public Integer com.xx.xxx.AA.xxxXXX(int,String)
* com.service.UserServiceImpl.*(..):com.service包下UserServiceImpl类中,返回值修饰符任意,方法名任意,
参数表任意
* com.service.UserServiceImpl.queryUser(..):同上,只是方法名不是任意,而是 ”queryUser“
-->
<aop:pointcut id="pc" expression="execution(* com.service.UserServiceImpl.queryUser(..))"/>
<aop:advisor advice-ref="myBefore" pointcut-ref="pc"/>
</aop:aspect>
</aop:config>
4.4 测试
UserService userService = (UserService)context.getBean("userService");
userService.insertUser(new User(...));
4.5 多种Advice
4.5.1 前置额外功能
public class MyBeforeAdvice implements MethodBeforeAdvice{
/**
* @param method 当前执行的方法
* @param args 当前执行的方法中的参数
* @param target 目标对象
* @throws Throwable
*/
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("before~~~");
}
}
4.5.2 后置额外功能
public class MyAfterAdvice implements AfterReturningAdvice{
/**
*
* @param returnValue 目标业务方法返回值
* @param method 当前执行的业务方法对象
* @param args 方法的参数
* @param target 目标对象
* @throws Throwable
*/
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("after~~~");
}
}
4.5.3 环绕额外功能
public class MyMethodInterceptor implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("begin~~");
Object ret = invocation.proceed();//执行目标业务方法
System.out.println("end~~");
return ret;//返回目标业务方法返回值
}
}
4.5.4 异常额外功能(了解)
public class MyThrows implements ThrowsAdvice{
//目标业务方法中抛出异常时,执行此方法。ex=抛出的异常对象
public void afterThrowing(Exception ex){
System.out.println(ex.getMessage()+"~~~");
}
}
4.5.5 最终额外功能(了解)
在核心之后执行( 即使核心中出现了异常,依然执行额外 )
4.5.5 编织
<!-- 声明 target+advice -->
<bean id="userService" class="xxxxx"></bean>
<bean id="myXXAdvice" class="xxxxx"></bean>
<aop:config>
<aop:pointcut id="pc" expression="execution(* com..UserService*.*(..))"/>
<aop:advisor advice-ref="advice的BeanId" pointcut-ref="pc"/>
</aop:config>
4.6 切入点表达式
4.6.1 execution
1> * com.service.UserServiceImpl.queryUser(..)
修饰符:任意
返回值:任意
包:com.service
类:UserServiceImpl
方法:queryUser
参数表:任意
2> * com.service.UserServiceImpl.*(..)
修饰符:任意
返回值:任意
包:com.service
类:UserServiceImpl
方法:所有,任意
参数表:任意
3> * com..UserServiceImpl.*(..)
修饰符:任意
返回值:任意
包:com包,及其子包
类:UserServiceImpl
方法:所有,任意
参数表:任意
4> * com.service.*.*(..)
修饰符:任意
返回值:任意
包:com.service
类:所有,任意
方法:所有,任意
参数表:任意
5> * *(..) 不建议
修饰符:任意
返回值:任意
包:任意
类:所有,任意
方法:所有,任意
参数表:任意
6> * com.service.UserServiceImpl.query*(..) 【技巧:批量切入】
修饰符:任意
返回值:任意
包:com.service
类:UserServiceImpl
方法:所有,任意
参数表:任意
*注意:尽量精确,避免不必要的切入
4.6.2 within
描述
包
和类
,类
中所有方法都切入
within(com.service.UserServiceImpl) 类中的所有方法
within(com..UserServiceImpl) com包和com子包下的名字为UserServiceImpl类中的所有方法
<aop:pointcut id="pc" expression="within(com..UserServiceImpl)"/>
4.6.3 args
描述
参数表
,符合的方法都切入
args(int,String,com.entity.User) 参数表如此的方法
<aop:pointcut id="pc" expression="args(int,String,com.entity.User)"/>
4.6.4 联用
不同种类的表达式之间,可以使用逻辑运算:
and or not
<aop:pointcut id="pc" expression="execution(* com.zhj.service.UserServiceImpl.*(..)) and args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) or args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) and not args(com.User)"/>
5. JDK代理
// JDK动态代理
//目标
final UserService us = new UserServiceImpl();
//额外功能
InvocationHandler handler = new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("事务开启");
method.invoke(us, args);
System.out.println("事务结束");
return null;
}
};
//动态组建代理类
UserService proxy = (UserService)Proxy.newProxyInstance(Test.class.getClassLoader(),
us.getClass().getInterfaces(),
handler);
6.CGLib代理
// CGLIB动态代理
//目标
final UserService us = new UserServiceImpl();
//额外功能
MethodInterceptor mi = new MethodInterceptor(){
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)
throws Throwable {
System.out.println("### before invocation");
Object result = method.invoke(us, objects);
System.out.println("### end invocation");
return result;
}
}
Enhancer enhancer = new Enhancer();
// 设置需要代理的对象
enhancer.setSuperclass(us.getClass());
// 设置代理人
enhancer.setCallback(mi);
UserServiceImpl proxy = (UserServiceImpl)enhancer.create();
org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy()中spring做了jdk代理和cglib代理的选择。
7. AOP底层细节
7.1 后处理器
/**
* 定义bean后处理器
* 作用:在bean的创建之后,进行再加工
*/
public class MyBeanPostProcessor implements BeanPostProcessor{
/**
*
* @param bean 原始的bean对象
* @param beanName beanid
* @return
* @throws BeansException
*/
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("后处理器 在init之前执行~~~"+bean.getClass());
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("后处理器 在init之后执行~~~"+bean.getClass());
return bean;// 此处的返回是 getBean() 最终的返回值
}
}
<!-- 后处理器,将对工厂中所有的bean声明周期进行干预 -->
<bean class="com.qianfeng.beanpostprocessor.MyBeanPostProcessor"></bean>
7.2 Bean的生命周期
构造
》注入属性 满足依赖
》初始化
》返回
》销毁
完整周期
构造
》注入属性 满足依赖
》后处理器前置过程
》初始化
》后处理器后置过程
》返回
》销毁
AbstractAutowireCapableBeanFactory#doCreateBean(){
if (instanceWrapper == null) {
//创建Bean对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
...
try {
//完成注入
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//执行初始化过程
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
}
AbstractAutowireCapableBeanFactory#initializeBean(){
//....
if (mbd == null || !mbd.isSynthetic()) {
// 后处理器的 前置过程
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 调用后处理器的 后置过程
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
}
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization(){
//....
// 遍历所有后处理器,对bean做后处理
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
}
7.3 动态代理构建
构建时刻:在bean的后处理器的后置过程中,会将基于bean定制一个他的代理类(对象)
// 工厂启动时,会注册一些 后处理器,其中就包含 AspectJAwareAdvisorAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator{
...
}
AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
...
}
// AbstractAutoProxyCreator是 AspectJAwareAdvisorAutoProxyCreator的父类
// 该父类中定义了 后处理器的功能实现,有父类发起动态代理的定制
AbstractAutoProxyCreator#postProcessAfterInitialization(Object bean, String beanName){
if (!this.earlyProxyReferences.contains(cacheKey)) {、
// 开始动态定制代理
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
AbstractAutoProxyCreator#wrapIfNecessary(){
....
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
}
AbstractAutoProxyCreator#createProxy(){
....
return proxyFactory.getProxy(getProxyClassLoader());
}
ProxyFactory#getProxy(ClassLoader classLoader) {
// 最后调用:JdkDynamicAopProxy.getProxy();或 ObjenesisCglibAopProxy.getProxy()
// 获取代理对象
return createAopProxy().getProxy(classLoader);
}
ProxyCreatorSupport#createAopProxy() {
...
// DefaultAopProxyFactory.createAopProxy(this)
// 获取创建代理对象的 对象 ,返回JdkDynamicAopProxy 或 ObjenesisCglibAopProxy
return getAopProxyFactory().createAopProxy(this);
}
DefaultAopProxyFactory#createAopProxy(){
// 判断决定使用 jdk代理 还是 cglib代理,
// 会最终返回 JdkDynamicAopProxy 或 ObjenesisCglibAopProxy
// JdkDynamicAopProxy 或 ObjenesisCglibAopProxy的 getProxy方法最终返回代理对象
// 如果需要优化,如果设置了proxy-target-class="true" 如果目标类没有接口
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("...");
}
// 如果目标是接口,如果目标已经是一个代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
JdkDynamicAopProxy#getProxy(ClassLoader classLoader) {
...
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
7.3 切入顺序
<!-- order值越小,切入顺序就越优先 -->
<aop:advisor advice-ref="before05" pointcut-ref="pc05" order="2"/>
<aop:advisor advice-ref="before04" pointcut-ref="pc05" order="1"/>
7.4 cglib选择
<!-- 强制使用cglib代理 -->
<aop:config proxy-target-class="true">