动态代理与静态代理

public class StaticProxy extends Object{

    Object object;

    public StaticProxy(Object object) {
        this.object = object;
    }

    @Override
    public int hashCode() {
        System.out.println("proxy decorate start...");
        int hashCode = object.hashCode();
        System.out.println("proxy decorate end...");
        return hashCode;
    }

    public static void main(String[] args) {
        Object proxy = new StaticProxy(new Object());
        System.out.println(proxy.hashCode());
    }
}

public class DynamicProxy {
    static class BAInvocationHandler implements InvocationHandler{

        private Object realObj;

        public BAInvocationHandler(Object realObj) {
            this.realObj = realObj;
        }

        public void doBefore() {
            System.out.println("before ...");
        }

        public void doAfter() {
            System.out.println("after ...");
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //proxy为代理对象，所以此处不能调用proxy的方法否则会栈溢出死锁
            //proxy是在newProxyInstance时生成并在调用时传进来的，因为invocationHandler与Proxy是聚合模式
            //所以在invocation中获取不到代理对象，只能通过这种方式传递进来
            doBefore();
            Object result = method.invoke(realObj, args);
            System.out.println("invoke result :"+result);
            doAfter();
            return result;
        }

    }
    static <T>T getInstance(Object realObj,Class<T>... clazz) {
        //第一个T泛型方法
        //clazz 该代理类实现的接口
        return (T)Proxy.newProxyInstance(clazz[0].getClassLoader(), clazz,new BAInvocationHandler(realObj));
    }
    public static void main(String[] args) {
        Object o = getInstance(new Object(),Serializable.class);
        o.hashCode();
        System.out.println(o instanceof Proxy);

    }
}

public class CGLIBDynamicProxy {
    static class Test{
        public final void finalMethod() {
            System.out.println("final");
        }
        public void method() {
            System.out.println("method");
        }
        public static void staticMethod(){
            System.out.println("staticMethod...");
        }
    }
    static class BAInterceptor implements MethodInterceptor{

        public void doBefore() {
            System.out.println("\nbefore ...");
        }

        public void doAfter() {
            System.out.println("after ...\n");
        }

        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            //proxy---代理类对象
            //method---代理后的方法
            //args---参数
            //methodProxy---方法的代理对象
            //不能直接使用 method.invoke，因为会再调用invoke导致死锁stackOverFlow
            doBefore();
            //使用父类方法，也就是原类方法获取返回值
            Object result = methodProxy.invokeSuper(proxy, args);
            System.out.println("invoke super result..."+result);
            doAfter();
            return result;
        }


    }
    static <T> T getInstance(Class<T> clazz) {
        //第一个T泛型方法
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(new BAInterceptor());
        return (T) enhancer.create();
    }
    public static void main(String[] args) {
        Test test = getInstance(Test.class);
        test.hashCode();
        test.finalMethod();
        test.method();
        test.staticMethod();
    }
}