Java动态代理应用

动态代理的常用场景之一是在调用接口的前后，分别加入逻辑，以达到AOP的效果。

package com.meiran.proxy;

import org.junit.Test;

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

/**
 * 动态代理的应用
 */
public class ProxyUsageTest {

    @Test
    public void test() {
        //创建调用类的类加载器
        ClassLoader classLoader = ProxyUsageTest.class.getClassLoader();
        //创建接口
        Class[] waiter = {Waiter.class};
        //创建实现类
        Waiter waiter1 = new GirlWaiter();
        //创建invocationHandler
        InvocationHandler invocationHandler = new MyInvocationHandler(waiter1);
        //创建动态代理对象
        Waiter proxy = (Waiter) Proxy.newProxyInstance(classLoader, waiter, invocationHandler);
        proxy.serve();
        String result = proxy.testString("250");
        System.out.println(result);
        int i = proxy.testInt(2);
        System.out.println(i);
    }

    class MyInvocationHandler implements InvocationHandler {
        private Waiter waiter;

        MyInvocationHandler(Waiter waiter) {
            this.waiter = waiter;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("增强了一次");
            Object result = method.invoke(waiter, args);
            System.out.println("增强了两次");
            return result;
        }
    }
}

调用结果：

增强了一次
女服务员服务
增强了两次
增强了一次
增强了两次
女服务员testString:250
增强了一次
增强了两次
2

说明此种方式调用，可以达到在自己new接口的实现类的基础上，前、后增加处理逻辑，以达到AOP的效果。