[Java知识库]Spring-Aop

JDK动态代理

Cglib动态代理实现

1、目标

public class Target {
	private static final Logger log = LoggerFactory.getLogger(Target.class);
	
	public void doSomething(){
		log.info("doSomething...");
	}
}

2、增强

public class Advice {
	private static final Logger log = LoggerFactory.getLogger(Advice.class);
	
	public void before(){
		log.info("before...");
	}
	
	public void after(){
		log.info("after...");
	}
}

3、代理实现

public class ProxyGclip {
	
	@Test
	public void test(){
		Target target = new Target();//目标
		Advice advice = new Advice();//增强
		Enhancer enhancer = new Enhancer();//创建增强器
		enhancer.setSuperclass(Target.class);//设置目标
		enhancer.setCallback(new MethodInterceptor() {//设置回调
			
			@Override
			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				advice.before();
				Object invoke = method.invoke(target, args);
				advice.after();
				return invoke;
			}
		});
		//创建代理对象
		Target proxy = (Target) enhancer.create();
		proxy.doSomething();
	}
}

JDK动态代理

1、目标:同上，实现了接口
2、增强:同上
3、接口

public interface TargetInterface {
	void doSomething();
}

4、代理实现

public class TargetProxy {

	@Test
	public void test(){
		Target target = new Target();//目标
		Advice advice = new Advice();//增强
		TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
				target.getClass().getClassLoader(), //目标对象类加载器
				target.getClass().getInterfaces(), //目标对象相同的接口字节码对象数组
				new InvocationHandler() {
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				advice.before();
				Object invoke = method.invoke(target, args);
				advice.after();
				return invoke;
			}
		});
		proxy.doSomething();
			
	}
	
}

对比总结

1、spring优先对接口进行代理(jdk代理)，如果代理对象没有实现任何接口，才会对类进行代理(cglib代理)
2、对接口进行代理优于对类进行代理，因为相对来说更加松耦合，对类代理是备用方案
3、标记为final的方法无法进行代理，因为代理对象需要对目标对象的方法进行覆写。final 修饰的方法是无法进行覆写的
4、spring只支持动态代理，所以只支持方法连接点，不支持属性连接点，因为spring认为属性拦截破坏了封装。面向对象的概念是对象自己处理工作，其他对象只能通过方法调用的得到的结果

xml实现动态代理

1、导入maven坐标

<!-- aspectj的织入 -->
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.13</version>
	</dependency>

2、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans 
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       ">
       
       <!-- 目标 -->
       <bean name="target" class="cn.sp.aop.xml.Target"/>
       <!-- 增强 -->
       <bean name="advice" class="cn.sp.aop.xml.Advice"/>
       <aop:config>
       	<!-- 声明切面(=切点+通知) -->
       	<aop:aspect ref="advice">
       		<!-- 切点 -->
       		<aop:pointcut id="myPointcut" expression="execution(* cn.sp.aop.xml.Target.*(..))" />
       		<!-- 通知 -->
       		<aop:before method="before" pointcut-ref="myPointcut"/>
       		<aop:after method="after" pointcut-ref="myPointcut"/>
       	</aop:aspect>
       </aop:config>   
</beans>

3、代码同上

注解实现动态代理

1、配置xml组件扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans 
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       ">
       
	<context:component-scan base-package="cn.sp.aop.anno" />
	
	<!-- aop自动代理 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>       
</beans>

2、目标：同上
3、目标接口：同上
4、增强

@Component
@Aspect
public class MyAspect {
	
	private static final Logger log = LoggerFactory.getLogger(MyAspect.class);
	
	@Before("MyAspect.myPoint()")
	private void before(){
		log.info("before...");
	}
	
	@After("MyAspect.myPoint()")
	private void after(){
		log.info("after...");
	}
	
	@Pointcut("execution(* cn.sp.aop.anno.*.*(..))")
	private void myPoint(){
		
	}
	
}

5、调用

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:test-aop-anno.xml")
public class TestAopAnno {
	
	@Autowired
	private TargetInterface target;
	
	@Test
	public void test(){
		target.doSomething();
	}
}

总结

1、Advice(通知，增强)：通知中封装了切面的工作，即需要增强的功能。
前置通知（Before）：在目标方法被调用之前调用通知功能
后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么
返回通知（After-returning）：在目标方法成功执行之后调用通知
异常通知（After-throwing）：在目标方法抛出异常后调用通知
环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和之后执行自定义的行为

2、连接点：指的是可以被增强的所有的点，可以插入切面的点
3、切点：已经增强的连接点
4、织入：将增强的方法织入到连接点的过程，动态代理是运行时织入
5、引入：（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知，通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口
5、aop的应用场景：
场景一： 记录日志
场景二： 监控方法运行时间 （监控性能）
场景三： 权限控制
场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）