Spring AOP 实现

Spring AOP 实现

@(spring)[AOP]

spring aop的发展过程

---

增强类型

---

spring 的aop底层是通过jdk动态代理和cglib动态代理技术为bean织入横切逻辑的。spring通过使用增强类定义横切逻辑。
Spring 提供了五种增强类型：
- 前置增强 ： org.springframework.aop.MethodBeforeAdvice 是Spring目前可用的前置增强
- 后置增强 ： org.springframework.aop.AfterReturningAdvice 目标方法后执行
- 环绕增强 ： org.aopalliance.intercept.MethodInterceptor 目标方法前后执行
- 异常抛出增强 ： org.springframework.aop.AfterReturningAdvice 抛出异常后执行
- 引介增强 ： org.springframework.aop.support.DelegatingIntroductionInterceptor 为目标类增加新的方法和属性

前置增强

---

1. 定义增强类
2. 使用spring 的 ProxyFactory 将增强类目标类放入工厂，然后工厂实现代理

前置增强类：

public class BeforeAop implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("this is before advice...");
    }
}

ProxyFactory完成代理：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml","classpath:spring-mvc.xml"})
public class AopTest {

    @Test
    public void beforeAdvice(){
        Waiter target = new NaviWaiter();
        // 前置增强
        BeforeAdvice beforeAdvice = new BeforeAop();
        // spring代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        // JDK代理
        proxyFactory.setInterfaces(target.getClass().getInterfaces());
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice(beforeAdvice);
        // 增强，设为true强制使用cglib代理（要引cglib库）
//        proxyFactory.setOptimize(true);

        Waiter waiter = (Waiter) proxyFactory.getProxy();
        waiter.greetTo("miss");
    }
}

schema方式实现

spring的xml中配置bean

<bean class="com.lemontree.spring.aoptalk.BeforeAop" id="beforeAop"/>
<bean class="com.lemontree.spring.service.NaviWaiter" id="target"/>
<bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"
    p:proxyInterfaces="com.lemontree.spring.service.Waiter"
    p:interceptorNames="beforeAop"
    p:target-ref="target"/>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml","classpath:spring-mvc.xml"})
public class AopTest {

    @Autowired
    private Waiter waiter;

    @Test
    public void schema(){
        waiter.greetTo("tt");
    }
}

---

环绕增强

顾名思义
代码和和前置增强直接看代码
环绕增强

public class ArroundAop implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object[] o = invocation.getArguments();
        String s = (String) o[0];
        System.out.println("this is around..."+s);
        Object result = invocation.proceed();
        System.out.println("this is  ....");
        return result;
    }
}

---

异常抛出增强

ThrowsAdvice 并没有定义方法，他只是一个标识接口，spring会通过反射机制进行判断，但是必须以下面的方法签名进行定义：

    void afterThrowing(Method method,Object[] args,Object target,Throwable);

方法名必须为afterThrowing，前三个参数可以选，要么都要要么都不要，最后一个是Throwable或它的子类

具体实现：

public class ThrowAop implements ThrowsAdvice {

    //定义增强逻辑
    public void afterThrowing(Method method,Object[] args,Object target,Exception ex)throws Throwable{
        System.out.println("方法名"+method.getName());
        System.out.println("异常名称"+ex.getMessage());
        System.out.println("回滚一波~~~~~");
    }

}

---

引介增强

引介增强比较特殊，他不是在目标方法中织入增强，而是为目标类创建新的方法和属性，所以增强的链接点是类级别的（上面的 增强是方法级别的）。

具体实现：
1. 定义一个接口：

public interface MoniterService {
    void wathchYou(boolean isWatch);
}

1. 定义引介增强

public class IntroductionAop extends DelegatingIntroductionInterceptor implements MoniterService{
    private ThreadLocal<Boolean> moniMap = new ThreadLocal<>();

    @Override
    public void wathchYou(boolean isWatch) {
        moniMap.set(isWatch);
    }

    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        if (moniMap.get()!=null && moniMap.get()){
            System.out.println("do it!");
        }
        return super.invoke(mi);
    }
}

1. 测试

    @Test
    public void introAop(){
        Waiter target = new NaviWaiter();
        // 引介增强
        IntroductionInterceptor introductionAop = new IntroductionAop();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setInterfaces(target.getClass().getInterfaces());
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice(introductionAop);

        Waiter waiter = (Waiter) proxyFactory.getProxy();
        waiter.greetTo("mss");
        System.out.println("-----------------------");
        MoniterService moniterService = (MoniterService) waiter;
        moniterService.wathchYou(true);
        waiter.greetTo("mss");
    }

---

创建切面

增强类存在一个问题：增强被织入目标类的所有方法中。所以就需要Spring AOP去定位连接点。
所以创建切面的目的：找到连接点 ，为对应的方法织入横切逻辑

---

静态方法匹配切面

StaticMethodMatcherPointcutAdvisor 代表一个静态方法匹配切面，通过StaticMethodMatcherPointcut 定义切点
切面的创建：
1. 创建切面
2. 将增强类放入到切面中
3. 工厂生成代理类

具体实现：
切面：

public class StaticMethod extends StaticMethodMatcherPointcutAdvisor {
    @Override
    public boolean matches(Method method, Class<?> targetClass) {
        return "greetTo".equals(method.getName());
    }
}

测试：

    @Test
    public void staticAdvisor()  {
        Waiter target = new NaviWaiter();
        // 前置增强
        BeforeAop beforeAop = new BeforeAop();
        // 静态普通方法名称匹配
        StaticMethod staticMethod = new StaticMethod();
        staticMethod.setAdvice(beforeAop);
        // 代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setInterfaces(target.getClass().getInterfaces());
        proxyFactory.setTarget(target);
        proxyFactory.addAdvisor(staticMethod);

        //生成代理类
        Waiter waiter = (Waiter) proxyFactory.getProxy();
        waiter.greetTo("可以");
        System.out.println("----------------");
        waiter.serveTo("不可以？");
    }

---

自动代理

先看看前面的schame

   <bean class="com.lemontree.spring.aoptalk.BeforeAop" id="beforeAop"/>
    <bean class="com.lemontree.spring.service.NaviWaiter" id="target"/>
    <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"
        p:proxyInterfaces="com.lemontree.spring.service.Waiter"
        p:interceptorNames="beforeAop"
        p:target-ref="target"/>

可以看出，每次生成一个代理类都需要用ProxyFactoryBean配置一遍，十分麻烦。
所以spring提供了新的创建类：
- BeanNameAutoProxyCreator
- DefaultAdvisorAutoProxyCreator
还有很多中，这里只讲两个
有了Creator方法就可以嘿嘿嘿了
新的schame配置：

    <bean class="com.lemontree.spring.aoptalk.BeforeAop" id="beforeAop"/>
    <bean class="com.lemontree.spring.service.NaviWaiter" id="waiter"/>
   <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
        p:interceptorNames="beforeAop"
        p:beanNames="*er"
        p:optimize="true"/>

---

迎来新时代

注解实现AOP

SpringInAction.4th.面向切面的Spring