浅谈Java动态代理的实现

long startTime = System.currentTimeMillis();
logger.info("query mysql start：" + new Date(startTime).toLocaleString());
// 具体的query代码
...

long endTime = System.currentTimeMillis();
logger.info(String.format("query mysql end: %s, consumed time: %dms", new Date(endTime).toLocaleString(), (endTime-startTime)));

long startTime = System.currentTimeMillis();
logger.info("query mysql start：" + new Date(startTime).toLocaleString());
// 使用try-finally
JSONObject[] data = null;
try {
    data = mysql.query();
    return data;
} catch (Exception exception) {
    throw exception;
} finally {
    long endTime = System.currentTimeMillis();
    logger.info(String.format("query mysql end: %s, consumed time: %dms", new Date(endTime).toLocaleString(), (endTime - startTime)));
}

public interface Animal {
   void eat();
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("I like eating bone");
    }
}

public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("I like eating fish");
    }
}

public class DogProxy implements Animal {
    private Dog dog;

    public DogProxy(Dog dog) {
        this.dog = dog;
    }

    @Override
    public void eat() {
        System.out.print("I'm a "+dog.getClass().getSimpleName() +". ");
        dog.eat();
    }
}

public class CatProxy implements Animal {
    private Cat cat;

    public CatProxy(Cat cat) {
        this.cat = cat;
    }

    @Override
    public void eat() {
        System.out.print("I'm a " + cat.getClass().getSimpleName()+". ");
        cat.eat();
    }
}

public class AnimalInvokeHandler implements InvocationHandler {
    private Animal animal;

    public AnimalInvokeHandler(Animal animal) {
        this.animal = animal;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy class: " + proxy.getClass().getName());
        System.out.printf("proxy instanceof  Animal: %b \n", proxy instanceof Animal);
        System.out.printf("---- Call method: %s, class: %s ----\n", method.getName(), animal.getClass().getSimpleName());
        // 通过反射，调用委托类的方法
        Object result = method.invoke(animal, args);
        return result;
    }
}

public static void main(String[] args) {
    // 通过Proxy.newProxyInstance创建代理类
    // 将代理类转为抽象主题，可以动态的创建实现了该主题的代理类
    // 必须从实现类去获取需要代理的接口
    // 指定中介类，通过中介类实现代理
    Animal proxy = (Animal) Proxy.newProxyInstance(Main.class.getClassLoader(), Dog.class.getInterfaces(), new AnimalInvokeHandler(new Dog()));
    proxy.eat();
}

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.11</version>
</dependency>

public class BankSystem {
    // 转账
    public boolean transferAccount(double amount, String address) {
        System.out.printf("Send %f dollars to account %s", amount, address);
        // 转账成功
        return true;
    }

    // 查询账户余额
    public String queryBalance(){
        System.out.printf("Query account balance success");
        return "Account balance: 2400 dollars";
    }
}

public class TransferInterceptor implements MethodInterceptor {
    /**
    *
    * @param o，表示要增强的对象，其实就是代理中的委托类
    * @param method，被拦截的方法，其实就是委托类中被代理的方法
    * @param objects，被拦截方法的入参，如果是基本数据类型需要传入包装类型
    * @param methodProxy，对method的代理，通过invokeSuper()，实现对method的调用
    * @return java.lang.Object
    * @author sunrise
    * @date 2021/5/23 10:43 上午
    **/
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before(objects);
        Object result = methodProxy.invokeSuper(o, objects);
        return result;
    }

    private void before(Object[] args){
        System.out.printf("Please check: you will send %.2f dollar to account %s.\n", args[0], args[1]);
    }
}

public class QueryBalanceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 调用预发插叙方法
        Object result = proxy.invokeSuper(obj, args);
        after();
        return result;
    }

    private void after() {
        System.out.printf("Please pay attention to WeChat official account.\n");
    }
}

public class BankFilter implements CallbackFilter {
    @Override
    public int accept(Method method) {
        if ("transferAccount".equals(method.getName())) {
            // 使用拦截器列表中的第1个拦截器
            return 0;
        }
        // 使用拦截器列表中的第2个拦截器
        return 1;
    }
}

public static void main(String[] args) {
    // 新建拦截器
    TransferInterceptor transferInterceptor = new TransferInterceptor();
    QueryBalanceInterceptor queryBalanceInterceptor = new QueryBalanceInterceptor();

    // 创建工具类
    Enhancer enhancer = new Enhancer();
    // 设置委托类，在cglib中，这是cglib需要继承的超类
    enhancer.setSuperclass(BankSystem.class);
    // 设置多个拦截器
    enhancer.setCallbacks(new Callback[]{transferInterceptor, queryBalanceInterceptor});
    // 实现拦截器和方法的映射，即为不同的方法配置不同的拦截器
    enhancer.setCallbackFilter(new BankFilter());

    // 创建代理类
    BankSystem proxy = (BankSystem) enhancer.create();

    // 执行转账，调用TransferInterceptor
    boolean ok = proxy.transferAccount(1024.28, "lucy");
    System.out.println("transfer money success: " + ok);
    // 查询余额，调用QueryBalanceInterceptor
    proxy.queryBalance();
}

this.h.invoke(this, method, args);