spring之AOP

什么是AOP

Aspect Oriented Programing面向切面编程。利用AOP的技术我们可以轻松消除分散在各个模块逻辑代码中的重复代码，可以对我们指定的方法增强，代理等等

aop术语

连接点Joinpoint

程序执行的某个特定的位置，某个方法调用前，某个方法调用后，方法抛出异常后等等

切点pointcut

增强advice

目标Target

需要被增强的目标类

引入 introduction为某个类添加属性或者方法，或者继承某个类

织入weaving

代理proxy

切面aspect

springAop代理机制

jdk自带的动态代理

jdk的动态代理主要用到了Java.lang.reflect包下面的Proxy和InvocationHandler

代理类PlayGameProxy .java

public class PlayGameProxy implements InvocationHandler {
static Logger logger = Logger.getLogger(PlayGameProxy.class);
Object traget;

public PlayGameProxy(Object playGameInterface) {
this.traget = playGameInterface;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
logger.info("打开电脑噢");
Object object = method.invoke(traget, args);
logger.info("关闭电脑");
return object;
}

}

调用类

public class NormalProxyTest {
@Test
public void test() {
PlayGameInterface pg = new StartPlayGame();
PlayGameProxy pgProxy = new PlayGameProxy(pg);
// Proxy.newProxyInstance()最主要是这个方法
PlayGameInterface PlayGaemProxy = (PlayGameInterface) Proxy.newProxyInstance(pg.getClass().getClassLoader(), pg.getClass().getInterfaces(),
pgProxy);
PlayGaemProxy.palyGame();
PlayGaemProxy.palyGame2();
}
}

cglib的动态代理,因为jdk的代理技术必须要有接口类，如果某些类没有接口，就无法实现动态代理了，所以这时候cglib就出场了采用了字节码技术。主要用到了Enhancer类去增强

CglibProxy.java

@Slf4j
public class CglibProxy implements MethodInterceptor {
Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz) {
enhancer.setSuperclass(clazz);// 设置子类需要创建的类
enhancer.setCallback(this);
return enhancer.create();// 创建子类实例
}
public Object intercept(Object obj, Method arg1, Object[] args, MethodProxy proxy) throws Throwable {
log.info("【1】打开电脑噢");
Object result = proxy.invokeSuper(obj, args);
log.info("【3】关闭电脑");
return result;
}
}

测试类

@Test
public void test() {
CglibProxy cglibProxy = new CglibProxy();
StartPlayGame startPlayGame = (StartPlayGame) cglibProxy.getProxy(StartPlayGame.class);
startPlayGame.palyGame();
startPlayGame.palyGame2();
}

输出结果：

2015-06-30 15:02:43,785 INFO [main] (CglibProxy.java:27) - 【1】打开电脑噢

开始玩游戏了噢

2015-06-30 15:02:43,807 INFO [main] (CglibProxy.java:29) - 【3】关闭电脑

2015-06-30 15:02:43,807 INFO [main] (CglibProxy.java:27) - 【1】打开电脑噢

开始玩游戏了噢22222

2015-06-30 15:02:43,807 INFO [main] (CglibProxy.java:29) - 【3】关闭电脑

缺点：

如果我们只想给某个类（StartPlayGame）的某个方法（palyGame）加上代理，其他的方法不加代理。使用动态代理是做不到的，动态代理会给目标类的所有方法都加上增强。

如果我们代理一个类就要专门为这个类创建代理过程，编写相关代码，无法做到通用。

所以后面才引入了切点切面的概念！

Aop联盟

创建增强类Advice MethodBeforeAdvice(前置增强)、MethodInterceptor（拦截）、AfterReturningAdvice（后置增强）

其实实现效果就是相当于动态代理技术里面 invoke或者intercept方法，在调用真正方法之前，进行的操作。

通过代码配置增强

@Slf4j
public class PlayGameBeforAdvice implements MethodBeforeAdvice {
public void before(Method method, Object[] args, Object target) throws Throwable {
log.info("【1】方法执行之前");
}
}

public class PlayGameAfterAdvice implements AfterReturningAdvice {
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
log.info("【3】方法执行之后");
}
}
public class PlayGameInterceptor implements MethodInterceptor {
public Object invoke(MethodInvocation invocation) throws Throwable {
log.info("【1】环绕增强之前");
invocation.proceed();// 调用反射执行方法
log.info("【3】环绕增强之后");
return null;
}
}

测试

private void testByMethod() {
// 测试前置增强
PlayGameBeforAdvice pba = new PlayGameBeforAdvice();
excuteAdviceByParam(pba);
// 测试后置增强
PlayGameAfterAdvice paa = new PlayGameAfterAdvice();
excuteAdviceByParam(paa);
// 测试环绕增强
PlayGameInterceptor pgi = new PlayGameInterceptor();
excuteAdviceByParam(pgi);
}

public void excuteAdviceByParam(Advice advice) {
try {
PlayGame target = new PlayGameImp();
// spring提供的代理工厂
ProxyFactory proxy = new ProxyFactory();
// 设置代理的接口
proxy.setInterfaces(target.getClass().getInterfaces());
// 设置代理目标
proxy.setTarget(target);
// 为代理目标添加增强
proxy.addAdvice(advice);
// 强制以cglib形式代理 对于单例模式来说第一次创建比较慢，后来就好。
proxy.setOptimize(true);
// 生成代理类
PlayGame play = (PlayGame) proxy.getProxy();
play.playLOL();
} catch (Exception e) {
log.error("测试aop增强失败！：" + e.getLocalizedMessage());
}
}

通过spring配置增强

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <!-- 前置增强，后置增强，环绕增强 -->

<bean id="target" class="com.team.gaoguangjin.springinaction.springAop.PlayGameImp" />
<bean id="playGameAfterAdvice" class="com.team.gaoguangjin.springinaction.springAop.PlayGameAfterAdvice" />
<bean id="playGameBeforAdvice" class="com.team.gaoguangjin.springinaction.springAop.PlayGameBeforAdvice" />
<bean id="playGameInterceptor" class="com.team.gaoguangjin.springinaction.springAop.PlayGameInterceptor" />

<!-- xml配置aop的关系 -->
<bean id="play" class="org.springframework.aop.framework.ProxyFactoryBean"
p:proxyInterfaces="com.team.gaoguangjin.springinaction.springAop.PlayGame"
p:interceptorNames="playGameBeforAdvice" p:target-ref="target"
p:proxyTargetClass="true" p:singleton="true" />
</beans>

测试代码

private void testAopXml() {
try {
ApplicationContext ac = new ClassPathXmlApplicationContext("com/team/gaoguangjin/springinaction/springAop/beans.xml");
PlayGame play = (PlayGame) ac.getBean("play");
play.playLOL();
} catch (Exception e) {
log.error("测试xml aop增强失败！：" + e.getLocalizedMessage());
}
}

基于@Aspectj和schema配置的AOP

aspectj

基于aspect的代码配置aop

AspectDemo.java 切面类

@Aspect
@Slf4j
public class AspectDemo {
@Before("execution(* playLOL(..))")
public void beging() {
log.info("【1】 玩游戏之前需要【打开】电脑 通过方法方式");
}

@After("execution(* playLOL(..))")
public void end() {
log.info("【3】 不想玩游戏睡觉了需要【关闭】电脑 通过方法方式");
}

@Before("execution(* playCs(..))")
public void beging1() {
log.info("【1】 玩游戏之前需要【打开】电脑 通过xml方式");
}

@After("execution(* playCs(..))")
public void end2() {
log.info("【3】 不想玩游戏睡觉了需要【关闭】电脑 通过xml方式");
}

// 拦截所有带了注解的方法
@Before("@annotation(com.team.gaoguangjin.springinaction.annoation.JdkAnnoation)")
public void annationBegin() {
log.info("【1】 注解方法运行之前");
}

@After("@annotation(com.team.gaoguangjin.springinaction.annoation.JdkAnnoation)")
public void annationEnd() {
log.info("【3】 注解方法之后");
}
}

代码调用，当playLOL方法被调用时候，会触发@Before和@After

execution里面是条件

private void getFromMethod() {
PlayGame target = new PlayGameImp();
// 定义 AspectJProxyFactory 而不是ProxyFactory
AspectJProxyFactory aspectFactory = new AspectJProxyFactory();
// 先要setTarget 然后再添加aspect切面
aspectFactory.setTarget(target);
// 添加切面类
aspectFactory.addAspect(AspectDemo.class);
// 生成切面的代理对象
PlayGame proxy = aspectFactory.getProxy();
proxy.playLOL();
}

基于aspect的xml配置aop

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 
<!--【1】与【2】效果类似，用其中一个就可以了  -->
<!-- 【1】基于切面的驱动器 -->
<aop:aspectj-autoproxy />
<!--http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 【2】自动代理创建器，
<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"/>
-->
<bean id="playGame" class="com.team.gaoguangjin.springinaction.aspectAop.PlayGameImp" />
<bean id="asepectDemo" class="com.team.gaoguangjin.springinaction.aspectAop.AspectDemo" />
</beans>

调用测试，因为

<aop:aspectj-autoproxy />

会自动扫描注解需要代理的对象

private void geFromXml() {
try {
ApplicationContext ac = new ClassPathXmlApplicationContext("com/team/gaoguangjin/springinaction/aspectAop/beans.xml");
PlayGame play = (PlayGame) ac.getBean("playGame");
play.playCs();
} catch (Exception e) {
log.error("通过xml方式得到aspect注解的aop失败！" + e.getLocalizedMessage());
}
}

Schema

基于schemd的 aspect配置

增强类切面AdviceMethods .java

public class AdviceMethods {
public void preGreeting(String name) {
System.out.print("所有方法都会触发!--参数为：");
System.out.println(name);
}

// 后置增强对应方法
public void afterReturning(String retVal) {
System.out.println("----afterReturning()----");
System.out.println("returnValue:" + retVal);
System.out.println("----afterReturning()----");
}

// 环绕增强对应方法
public void aroundMethod(ProceedingJoinPoint pjp) {
System.out.println("----aroundMethod()----");
System.out.println("args[0]:" + pjp.getArgs()[0]);
System.out.println("----aroundMethod()----");
}

// 抛出异常增强
public void afterThrowingMethod(IllegalArgumentException iae) {
System.out.println("----afterThrowingMethod()----");
System.out.println("exception msg:" + iae.getMessage());
System.out.println("----afterThrowingMethod()----");
}

// final增强
public void afterMethod() {
System.out.println("----afterMethod()----");
}

// ------------绑定连接点参数----------//
public void bindParams(int num, String name) {
System.out.println("----bindParams()----");
System.out.println("name:" + name);
System.out.println("num:" + num);
System.out.println("----bindParams()----");
}
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> <bean id="adviceMethods" class="com.team.gaoguangjin.springinaction.schemaAspectAop.AdviceMethods" />
<aop:config proxy-target-class="true">
<!--可以配置多个 aop:aspect -->
<aop:aspect ref="adviceMethods">
<!-- args(name) 这个name属性为 public void preGreeting(String name)-->
<aop:pointcut expression="target(com.team.gaoguangjin.springinaction.schemaAspectAop.PlayGameImp) and args(name)" id="playGamePointcut"/>
<!--1PlayGameImp类的所有方法运行之前 都会触发这个条件
<aop:before method="preGreeting" pointcut="target(com.team.gaoguangjin.springinaction.schemaAspectAop.PlayGameImp) and args(name)" arg-names="name" />
-->
<!--2PlayGameImp类的所有方法运行之前 都会触发这个条件 1和2一样，只是用到了pointcut-->
<aop:before method="preGreeting" pointcut-ref="playGamePointcut"/>

<!--某个类的任何方法运行之后都会带返回参数的aop  -->
<aop:after-returning method="afterReturning"
pointcut="target(com.team.gaoguangjin.springinaction.schemaAspectAop.PlayGameImp)"
returning="retVal" />
<aop:around method="aroundMethod" pointcut="execution(* playLOL(..)) and within(com.team.gaoguangjin.springinaction.schemaAspectAop.PlayGameImp)"  />
</aop:aspect>
</aop:config>

<!-- 基于schemaAspectAop的配置切面-->
<bean id="playGameAfterAdvice" class="com.team.gaoguangjin.springinaction.schemaAspectAop.PlayGameAfterAdvice" />
<aop:config proxy-target-class="true">
<aop:advisor advice-ref="playGameAfterAdvice"  pointcut="execution(* com..*.playLOL(..))"/>
</aop:config>
</bean>

测试就和普通测试一样略。。。。