聊聊aop和动态代理

AOP，Aspect Oriented Programming，面向切面编程。

名字很晦涩难懂，实际是面向特定方法进行编程，可以无侵入的为指定方法添加一些功能。

动态代理是AOP最主流的实现方法，下面着重讲一下。

AOP

前提：项目引入aop的依赖

应用场景：

记录操作日志
权限控制
事务管理
...

@Component
@Aspect
public class XxxAspect {
    @Around("...") //切入点表达式，指定哪些方法需要增强
    public Object xxxx(ProceedingJoinPoint proceedingJoinPoint) {
        // 指定方法运行前执行内容
        // TODO：code
        Object object =proceedingJoinPoint.proceed(); //调用原始方法运行
        // 指定方法运行后执行内容
        // TODO: code
        return object;
    }
}

AOP的核心概念：

连接点（JoinPoint）：可以被AOP控制的方法
通知（Advice）：AOP增强的重复逻辑（共性功能）
切入点（PointCut）：？
切面（Aspect）：
目标对象（Target）：

动态代理

所谓动态代理，即在程序运行期间，创建目标对象的代理对象，并对目标对象中的方法进行功能性增强的一种技术。

基于动态代理，我们就可以在不修改方法源代码的情况下，增强被代理对象方法的功能（和上文说的AOP的用法一摸一样）。

// 
public interface ProxyMethod {
    public abstract void test();
}

// 被代理对象
public class Test implements ProxyMethod {
    @Override
    public void test(){

    }
}

// 
public class ProxyUtil {
    public static ProxyMethod createProxy(Test test){
        // 创建代理对象
        ProxyMethod proxyMethod = (ProxyMethod) Proxy.newProxyInstance(
            ProxyUtil.class.getClassLoader(), // 指定类加载器
            new Class[]{ProxyMethod.class,}, // 要代理对象的哪些方法（接口）
            new InvocationHandler(){
                public Object invoke(Object proxy,Method method,Object[] args){
                    // 执行目标对象方法前实现的功能
                    // TODO:code
                    return method.invoke(test,args); //调用目标对象的方法
                }
            }
        )
    }
}

public class Main{
    public static void main(){
        Test test =new Test();
        // 创建代理对象
        ProxyMethod proxy =ProxyUtil.createProxy(test);
        // 通过代理对象实现相应方法
        proxy.method();
    }
}