文章目录

• 一、静态代理
• • 存在价值
  • demo
• 二、动态代理
• • 优点
  • 与静态代理差异
  • demo
• 三、cglib动态代理

一、静态代理

存在价值

1. 节省成本比较高的实际对象的创建开销，按需延迟加载，创建代理是并不真正创建实际对象，而只是保存实际对象的地址，在需要时再加载或者创建。
2. 执行权限检查，代理检查权限后，在调用实际对象
3. 屏蔽网络差异和复杂性，代理在本地，而实际对象在其他服务器上，调用本地代理，本地代理请求其他服务器

demo

public class SimpleStaticProxyDemo {
    static interface IService{//共同接口
        public void sayHello();
    }
    static class RealService implements IService{//实际对象
        @Override
        public void sayHello() {
            System.out.println ("hello");
        }
    }

    static class TraceProxy implements IService{//代理
        private IService realService;//定义成员变量
        public TraceProxy(IService realService){//将成员变量指向实际对象，并在构造方法中初始化
            this.realService = realService;
        }

        @Override
        public void sayHello() {
            System.out.println ("entering sayHello");
            this.realService.sayHello ();
            System.out.println ("leaving sayHello");
        }
    }

    public static void main(String[] args) {
        RealService realService = new RealService ();
        TraceProxy traceProxy = new TraceProxy ( realService );
        traceProxy.sayHello ();
    }
}

//输出结果
entering sayHello
hello
leaving sayHello

二、动态代理

优点

与静态代理差异

demo

package thread_practice.fanshe;

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

public class GeneralProxyDemo {
    static interface IServiceA {
        public void sayHello();
    }

    static class ServiceAImpl implements IServiceA {
        @Override
        public void sayHello() {
            System.out.println ( "hello" );
        }
    }

    static interface IServiceB {
        public void fly();
    }

    static class ServiceBImpl implements IServiceB {
        @Override
        public void fly() {
            System.out.println ( "flying" );
        }
    }

    static class SimpleInvocationHandle implements InvocationHandler {
        private Object realObj;

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

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
            System.out.println ( "entering" + realObj.getClass ()
                    .getSimpleName () + ":" + method.getName () );
            Object result = method.invoke ( realObj, args );
            System.out.println ( "leaving" + realObj.getClass ()
                    .getSimpleName () + ":" + method.getName () );
            return result;
        }
    }

    private static <T> T getProxy(Class<T> intf, T realObj) {
        return (T) Proxy.newProxyInstance ( intf.getClassLoader (),
                new Class<?>[]{
                        intf
                }, new SimpleInvocationHandle ( realObj ) );
    }

    public static void main(String[] args) {
        IServiceA a = new ServiceAImpl ();
        IServiceA aProxy = getProxy ( IServiceA.class, a );
        aProxy.sayHello ();
        ServiceBImpl b = new ServiceBImpl ();
        IServiceB bProxy = getProxy ( IServiceB.class, b );
        bProxy.fly ();
    }

}

//输出结果
enteringServiceAImpl:sayHello
hello
leavingServiceAImpl:sayHello
enteringServiceBImpl:fly
flying
leavingServiceBImpl:fly

三、cglib动态代理

CGLIB详解(最详细)