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提供了更为丰富的代理实现方式，但归根结底，本质都是一样的。