JDK动态代理和CGLIB动态代理编码

JDK动态代理【接口】：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 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);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

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

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

    public static void main(String[] args) {
        DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl());
        ((Hello)dynamicProxy.getProxy()).say();
    }
}

interface Hello {
    String say();
}

class HelloImpl implements Hello {
    @Override
    public String say() {
        System.out.println("say");
        return "say";
    }
}

CGLIB动态代理【类或接口】：

依赖：

        <!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

编码：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 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);  //Enhancer类，增强类
    }
    @Override
    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 after() {
        System.out.println("after");
    }

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

    public static void main(String[] args) {
        CGlibProxy.getInstance().getProxy(HelloImpl.class).say();
    }
}

Spring AOP：

增强类：

package smart;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 前置增强类，放入增强代码
 */
@Component
public class GreetingBeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("Before");
    }
}

package smart;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 后置增强类
 */
@Component
public class GreetingAfterAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("After");
    }
}

package smart;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * 环绕增强org.aopalliance.intercept.MethodInterceptor该接口不是Spring提供的，借用AOP联盟提供的
 */
@Component
public class GreetingAroundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        before();
        Object result = methodInvocation.proceed();
        after();
        return result;
    }

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

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

package smart;

import org.springframework.aop.ThrowsAdvice;

import java.lang.reflect.Method;

/**
 * 抛出增强
 */
@Component
public class GreetingThrowAdvice implements ThrowsAdvice {
    /**
     * 当被代理的方法内部抛出异常，会被该增强拦截
     * 按理ThrowsAdvice接口有afterThrowing方法，参数是方法，参数，目标对象，异常对象等信息，可以获取记录日志或插入数据库
     * 但点开接口看没有任何方法
     */
    public void afterThrowing(Method method, Object[] args, Object target, Exception e) {}
}

package smart;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
import org.springframework.stereotype.Component;

/**
 * 用这个增强类让被代理类动态实现Apology接口，XML配置如下：
 *     <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
 *         <property name="interfaces" value="smart.Apology"/> //需要动态实现的接口
 *         <property name="target" value="greetingImpl"/> //目标类
 *         <property name="interceptorNames" value="greetingIntroductionAdvice"/> //引入增强
 *         <property name="proxyTargetClass" value="true"/> //代理目标类，默认false代理接口，此时spring使用jdk动态代理，设置为true，spring用cglib动态代理
 *     </bean>
 */
@Component
public class GreetingIntroductionAdvice extends DelegatingIntroductionInterceptor implements Apology {
    public Object invoke(MethodInvocation mi) throws Throwable {
        return super.invoke(mi);
    }
    @Override
    public void saySorry(String name) {
        System.out.println("Sorry! " + name);
    }
}

编程式：

package smart;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.stereotype.Component;

/**
 * Spring AOP：前置增强（Before Advice）、后置增强（After Advice）、环绕增强（Around Advice）、抛出增强（Throws Advice）、引入增强（Introduction Advice）
 * AOP术语：对方法的增强叫Weaving（织入），对类的增强叫Introduction（引入）
 * 当某个类实现类A接口，并没有实现B接口，想要调用B接口的方法，即实现对类的功能增强，使用引入增强（参考《Spring Reference》），不用改写被代理类，在程序运行时动态实现接口
 *
 * 分编程式和声明式
 * 增强类同时实现MethodBeforeAdvice和AfterReturningAdvice接口，执行一次addAdvice即可
 *
 * 声明式配置代理：
 * <bean id="代理工厂bean名称" class="org.springframework.aop.framework.ProxyFactoryBean">
 *      <property name="interfaces" value="代理的接口全限定名"/>
 *      <property name="target" ref="接口实现类的bean名称"/>
 *      <property name="interceptorNames">
 *          <list>
 *              <value>拦截器名称（即增强类的bean名称）</value> （若只有一个增强类，可简化为<property name="interceptorNames" value="拦截器名称（即增强类的bean名称）"/>）
 *          </list>
 *      </property>
 * </bean>
 */
public class GreetingAdviceTest {
    public static void main(String[] args) {
        /**
         * 编程式配置代理
         */
        ProxyFactory proxyFactory = new ProxyFactory(); //创建代理工厂，使用ProxyFactoryBean也可以，一回事
        proxyFactory.setTarget(new GreetingImpl()); //注入目标类对象
        proxyFactory.addAdvice(new GreetingBeforeAdvice()); //添加前置增强
        proxyFactory.addAdvice(new GreetingAfterAdvice()); //添加后置增强
//        proxyFactory.addAdvice(new GreetingAroundAdvice()); //添加环绕增强，将前置增强与后置增强功能结合起来
        Greeting greeting = (Greeting)proxyFactory.getProxy(); //从代理工厂中获取代理
        greeting.sayHello("Jack"); //调用代理的方法
    }
}
interface Greeting {
    void sayHello(String name);
}
@Component
class GreetingImpl implements Greeting {
    @Override
    public void sayHello(String name) {
        System.out.println("hello, " + name);
    }
}

interface Apology {
    void saySorry(String name);
}

//Apology接口默认实现类
class ApologyImpl implements Apology {
    @Override
    public void saySorry(String name) {
        System.out.println("Sorry!" + name);
    }
}

声明式：

XML配置：
    <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="smart.Greeting"/>
        <property name="target" value="greetingImpl"/>
        <property name="interceptorNames">
            <list>
                <value>greetingBeforeAdvice</value>
                <value>greetingAfterAdvice</value>
            </list>
        </property>
    </bean>

package smart;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class GreetingAdviceTestForXML {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring_aop.xml");
        Greeting greeting = (Greeting) context.getBean("greetingProxy");
        greeting.sayHello("JACK");
        //若使用引入增强，动态实现了Apology接口，将bean强转为Apology类型调用其方法即可
    }
}

切面：

动态代理拦截了类中所有方法，需要在代码中对所拦截的方法名加以判断，不太优雅的做法。

Spring AOP也拦截了类中所有方法，可通过切面Advisor（增强类Advice+拦截匹配条件（Pointcut，切点，基于表达式的拦截条件）），将切面配置到ProxyFactory中生成代理。

    <!-- 配置切面：增强+切点 -->
    <!-- Spring AOP提供的其它切面类：
        DefaultPointcutAdvisor:默认切面，可扩展它来自定义切面
        NameMatchMethodPointcutAdvisor:根据方法名称进行匹配的切面
        StaticMethodMatcherPointcutAdvisor:用于匹配静态方法的切面
     -->
    <bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="greetingAroundAdvice"/> <!-- 增强 -->
        <property name="pattern" value="smart.GreetingImpl.good.*"/> <!-- 切点，正则表达式（对满足切点匹配条件的方法进行拦截），匹配类中所有方法名以字符串good开头的方法，.*表示匹配所有字符 -->
    </bean>
    <!-- 配置代理，注入切面 -->
    <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" value="greetingImpl"/> <!-- 目标类 -->
        <property name="interceptorNames" value="greetingAdvisor"/> <!-- 这里不再配置增强，而改成切面，切面中封装了增强和切点 -->
        <property name="proxyTargetClass" value="true"/> <!-- 代理目标类 -->
    </bean>

上面的方式随着项目扩大，代理配置会越来越多，改用Spring AOP提供的自动代理（扫描bean名称）：

    <!-- 配置自动代理，不能定义代理接口即interfaces属性，因为不知道这些bean实现了多少接口，所以只能代理类 -->
    <!-- optimize属性默认false，为true对代理生成策略进行优化：类有接口就用JDK动态代理代理接口，没有接口就用cglib动态代理代理类
        而proxyTargetClass属性为true强制代理类，不考虑代理接口的方式
        cglib可以代理任何类，但cglib创建代理速度慢，创建代理后运行速度快，jdk相反
        运行时采用cglib创建代理拖慢系统性能，建议系统初始化时用cglib创建代理放入spring的applicationContext中备用
        BeanNameAutoProxyCreator只能匹配目标类，不能匹配指定方法，要想匹配方法，需要使用切面与切点
        Spring AOP基于切面的自动代理生成器：DefaultAdvisorAutoProxyCreator
    -->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames" value="*Impl"/> <!-- 只为后缀是Impl的bean生成代理 -->
        <property name="interceptorNames" value=""/> <!-- 增强 -->
        <property name="optimize" value="true"/> <!-- 是否对代理生成策略进行优化 -->
    </bean>

进一步，Spring AOP基于切面的自动代理生成器：DefaultAdvisorAutoProxyCreator：

    <!-- 配置切面：增强+切点 -->
    <bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="pattern" value="smart.GreetingImpl.good.*"/>
        <property name="advice" ref="greetingAroundAdvice"/>
    </bean>
    <!-- 这里无需再配置代理，代理由DefaultAdvisorAutoProxyCreator自动生成，它扫描所有切面类并为其自动生成代理 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
        <property name="optimize" value="true"/>
    </bean>

以上的方式依然存在大量切面配置，若要拦截指定注解的方法，必须扩展DefaultPointcutAdvisor类自定义切面类，在配置文件中进行切面配置，繁琐，这种切面+代理的配置方式保留，但引入Spring+Aspectj的优秀方案，常用：

Spring集成的AspectJ与直接使用AspectJ不同，不用定义AspectJ类（它扩展了Java语法的一种新语言，需要特点编译器），而只需要使用AspectJ切点表达式（比正则表达式更友好）：

注解的方式：

配置：

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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">

    <!-- spring 2.5+提供的bean扫描特性，扫描指定包 -->
    <context:component-scan base-package="smart"/>
    <!-- proxy-target-class属性默认false只能使用JDK动态代理代理接口，为true使用CGLib动态代理代理目标类 -->
    <!-- 不在需要大量配置切面和代理了 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

编程：

package smart;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;

/**
 * Spring+AspectJ基于注解，通过AspectJ execution表达式拦截方法实现环绕增强
 * @Aspect注解表名该类是Aspect切面类（Advisor）无需实现接口，定义任意名称方法即可，Around注解+execution表达式（AspectJ切点表达式）
 * 方法参数ProceedingJoinPoint对象在AOP中叫做JoinPoint连接点，可以通过它获取如方法名、参数等方法的任何信息
 * 在xml配置：
 *
 */
@Aspect
@Component
public class GreetingAspect {
    /**
     * 切点表达式，execution()表示拦截方法，括号中定义需要匹配的规则
     * 第一个*表示方法的返回值是任意的
     * 第二个*表示匹配该类中所有的方法，改为指定方法名称可以匹配指定方法
     * (..)表示方法的参数是任意的
     * @param pjp
     * @return
     * @throws Throwable
     */
    /**
     * 除了@Around外，其它增强注解：@Before前置增强，@After后置增强，@Around环绕增强，@AfterThrowing抛出增强
     * DeclareParents引入增强，AfterReturning返回后增强，可立即为Finally增强，相当于finally语句，在方法结束后执行，比After执行时机晚
     *
     * 若目标方法有指定注解如自定义一个注解@Log，使用AspectJ @annotation表达式拦截方法：
     * 切点表达式改为@Around("@annotation(Log)")即可，括号里是要拦截的注解全限定名
     *
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around("execution(* smart.GreetingImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        before();
        Object result = pjp.proceed();
        after();
        return result;
    }

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

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

    /**
     * 在Aspect类中定义需要引入增强的接口，也就是运行时需要动态实现的接口，在接口是标注@DeclareParents注解，属性：
     * value目标类
     * defaultImpl引入的接口的默认实现类，默认实现会在运行时自动增强到目标类中
     */
    @DeclareParents(value = "smart.GreetingImpl", defaultImpl = ApologyImpl.class)
    private Apology apology;
}

JDK1.4没有注解，使用基于配置的Spring+AspectJ，基于配置的方式定义切面类：

    <aop:config>
        <aop:aspect ref="aspect类的的bean名称">
            <aop:around method="around" pointcut="execution(* smart.GreetingImpl.*(..))"/>
        </aop:aspect>
    </aop:config>

AOP思维导图：

各类增强类型对应的解决方案：

Spring AOP整体架构UML类图：