AOP基础 - 动态代理

1). 创建一个接口：Counter.java

public interface Counter {
    public int add(int a, int b);
    public int sub(int a, int b);
}

2). 创建这个接口的实现类：CounterImp.java

public class CounterImp implements Counter {
    
    public int add(int a, int b){
        //加法核心代码
        return a + b;
    }

    public int sub(int a, int b){
        //减法核心代码
        return a - b;
    }
}

3). 创建一个代理类：CounterProxy.java

public class CounterProxy {

    //要代理的对象
    private CounterProxy target;
    
    //构造器，用于给 target 赋值
    public CounterProxy(Counter target){
        this.target = target;
    }
    
    //获取代理
    public Counter getProxy(){
        Counter proxy = null;
        
        //代理对象由哪一个类加载器负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型，即其中有哪些方法
        Class [] interfaces = new Class[]{Counter.class};
        //当调用代理对象其中的方法时，该执行的代码
        InvocationHandler h = new InvocationHandler(){
            /**
             * proxy: 正在返回的那个代理对象，一般情况下，在 invoke 方法中都不使用该对象，会无限循环
             * method: 正在被调用的方法
             * args: 调用方法时，传入的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwble{
                String methodName = method.getName();
                //日志
                System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
                //执行方法
                Object result = method.invoke(target, args);
                //日志
                System.out.println("The method " + methodName + " ends with " + result);
                return result;
            }
        }
        
        proxy = (Counter) Proxy.newProxyInstance(loader, interfaces, h);
        return proxy;
    }

}

4). 创建一个测试类：Main.java

public class Main{
    public static void main(String[] args){
        
        Counter target = new CounterImp();
        Counter proxy = new CounterProxy(target).getProxy();
        
        int result = proxy.add(1, 2);
        System.out.println("-->" + result);
        
        result = proxy.sub(2, 1);
        System.out.println("-->" + result);
        
    }
}

5). 运行结果：

The method add begins with [1, 2]
The method add ends with 3
-->3
The method sub begins with [2, 1]
The method sub ends with 1
-->1

Spring AOP

1. 通知

Spring 的 AOP 包括六种通知类型：前置通知，后置通知，返回通知，异常通知i，环绕通知，以及引用通知（不常用）。

• 前置通知：在方法执行前
• 后置通知：在方法执行后，不管有没有异常
• 返回通知：在方法正常结束后
• 异常通知：在方法抛出异常时
• 环绕通知：类似动态代理全过程，可以自定义切面位置

2.配置方式

1). 注解方式：略

2). 基于 Spring 配置文件：applicationContext.xml
i. 创建一个 日志切面：LogginAspect.java

public class LoggingAspect{
    
    //前置通知
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = jointPoint.getSinature().getName();
        Object [] args = jointPoint.getArgs();
        
        System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
    }
    
    //返回通知
    public void afterReturning(JoinPoint joinPoint, Object result){
        String methodName = jointPoint.getSinature().getName();
        System.out.println("The method " + methodName + " ends with " + result);
    }
    
}

ii. 配置 applicationContext.xml

<!-- 配置 bean -->
<bean id="counter"
    class="package.CounterImp"></bean>
    
<!-- 配置切面的 bean -->
<bean id="loggingAspect"
    class="package.LoggingAspect"></bean>
    
<!-- 配置 AOP -->
<aop:config>
    <!-- 配置切点表达式 -->
    <aop:pointcut expression="execution(* package.*(..))"
        id="pointcut" />
    <!-- 配置切面及通知，order 属性为切面的优先级，数字越小，优先级越高 -->
    <aop:aspect ref="loggingAspect" order="2">
        <aop:before method="beforeMethod" pointcut-ref="pointcut" />
        <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result" />
    </aop:aspect>
</aop:config>

iii. 创建一个测试类：Main.java

public class Main{
    public static void main(String[] args){
        
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Counter counter = (Counter) ctx.getBean("counter");
        
        System.out.pritln(counter.getClass().getName());
        
        int result = counter.add(1, 2);
        System.out.println("-->" + result);
        
        result = counter.sub(2, 1);
        System.out.println("-->" + result);
        
    }
}

iiii.运行结果

$Proxy3

The method add begins with [1, 2]
The method add ends with 3
-->3
The method sub begins with [2, 1]
The method sub ends with 1
-->1