AOP之二三事

AOP（Aspect-Oriented Programming），面向且面的编程，与OOP仅一字只差，但他是OOP编程的一个补充。通俗来讲，就像是刀切面，应用程序视为一团面，用刀横向切面，所以接下来需要说如何实现刀。

1、写代码

    写一个简单的接口

public interface Hello {
    void say(String msg);
}

   接口的实现类

public class HelloImpl implements Hello {
    public void say(String msg) {
        System.out.println("Hello !"+msg);
    }
}

现在需要在方法say之前和之后，添加补充说明的方法。自然，我们想到了代理，下面给出三种代理实习

2、静态代理类

public class HelloProxy implements Hello {
    private HelloImpl helloImpl;

    public HelloProxy(){
        helloImpl = new HelloImpl();
    }

    public void say(String msg) {
        before();
        helloImpl.say(msg);
        after();
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

静态代理类有一个缺点，就是针对每一个接口的实现方法，都需要有一个对应的静态代理类，会增加很多冗余的代码，而且看起来也不优雅。

3、JDK动态代理类

public class DynamicProxy implements InvocationHandler {
    private Object target;

    public DynamicProxy(Object target){
        this.target =target;
    }

    public <T> T getProxy(){
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        before();
        Object result = method.invoke(target,args);
        after();
        return result;
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

JDK动态代理仍然有缺陷，就是动态代理只能代理接口，而不能代理没有接口的类。

4、cglib动态代理

public class CGLibProxy implements MethodInterceptor {
    private static CGLibProxy instance = new CGLibProxy();
    private CGLibProxy(){}

    public static CGLibProxy getInstance(){
        return instance;
    }

    public <T> T getProxy(Class<T> cls){
        return (T) Enhancer.create(cls,this);
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o, objects);
        after();
        return result;
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
}

说了这么多，和AOP有毛关系？不然，因为AOP就是建立在动态代理这根毛上~~

5、AOP的Advice

   Advice绝大部分中文被译为“通知”，也有被称为“增强”，不论哪一种，就把它当作需要在方法添加的补充。自己实现一个补充的说明类：

public class HelloBeforeAndAfterAdvice implements MethodBeforeAdvice, AfterReturningAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("Before");
    }
    @Override
    public void afterReturning(Object result, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("After");
    }
}

类中包含了方法执行前的说明before()，方法执行后的说明after()。

对于环绕有

public class HelloAroundAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        before();
        Object result = invocation.proceed();
        after();
        return result;
    }

    private void before() {
        System.out.println("Before");
    }
    private void after() {
        System.out.println("After");
    }
}

对于这些补充类的管理，自然就交给了Spring（这家伙不就是干这事的！）

6、Spring AOP的配置

写好了补充类，要咋个才能起作用呢？而且，上面的这些类，还没有指明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:context="http://www.springframework.org/schema/context"
       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">

    <!-- 扫描指定包（将 @Component 注解的类自动定义为 Spring Bean） -->
    <context:component-scan base-package="aop.demo"/>

    <!-- 配置一个代理 -->
    <bean id="helloProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="aop.Hello"/> <!-- 需要代理的接口 -->
        <property name="target" ref="helloImpl"/>       <!-- 接口实现类 -->
        <property name="interceptorNames">                 <!-- 拦截器名称（也就是增强类名称，Spring Bean 的 id） -->
            <list>
                <value>helloAroundAdvice</value>
            </list>
        </property>
    </bean>

</beans>

是不是很简单？当然，Spring AOP提供了更为丰富的代理实现方式，但归根结底，本质都是一样的。