java的jdk动态代理简单封装

首先什么是代理呢，代理就是你可以办一件事，而你不办，交给另一个人办。因为被代理人在办这件事前或事后，知道多做一些其他工作。至于静态代理和动态代理，只是实现方式不同。具体点这里
一般java的动态代理有两种方式，一种是jdk,一种是cglib。有人说cglib比jdk快，其实随着jdk7,jdk8对reflect的优化，jdk已经赶超了cglib。当然cglib可以代理任意方法是长处。下面是对jdk动态代理的简单封装。

public class ProxyHandler<T> implements InvocationHandler {
    private T target;
    private BeforeAfter beforeAfter;

    ProxyHandler(T target, BeforeAfter beforeAfter) {
        this.target = target;
        this.beforeAfter = beforeAfter;
    }

    @SuppressWarnings("unchecked")
    public T getProxy() {
        Class<T> cls = (Class<T>) target.getClass();
        // 查看目标类有没有实现接口
        if (cls.getInterfaces() != null) {
            return (T) Proxy.newProxyInstance(cls.getClassLoader(),
                    cls.getInterfaces(), this);
        }
        return target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        try {
            // 调用前的业务处理
            beforeAfter.before(target, method, args);
            // 执行被代理对象的方法
            obj = method.invoke(target, args);
            // 调用后的业务处理
            beforeAfter.after(target, method, args);
        } catch (Exception e) {
            // 自定义的异常方法
            beforeAfter.onException(e);
        }
        return obj;
    }

    public static class BeforeAfter {
        /***
         * 出现异常时处理
         *
         * @param ex
         */
        public void onException(Exception ex) {

        }

        /**
         * 调用方法前处理
         *
         * @param args
         */
        public void before(Object target, Method method, Object[] args) {

        }

        /**
         * 调用方法后处理
         *
         * @param args
         */
        public void after(Object target, Method method, Object[] args) {

        }
    }

}

这样调用这个，因为不想写接口用了callable接口。

 public static void main(String[] args) throws Exception {
        Callable<String> stringCallable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("haha");
                return "haha";
            }
        };

        ProxyHandler<Callable> callableProxyHandler = new ProxyHandler<>(stringCallable, new ProxyHandler.BeforeAfter() {
            @Override
            public void before(Object target, Method method, Object[] args) {
                System.out.println("before");
            }

            @Override
            public void after(Object target, Method method, Object[] args) {
                System.out.println("after");
            }
        });
        callableProxyHandler.getProxy().call();
    }

输出结果

before
haha
after

Process finished with exit code 0