java代理模式

为什么需要代理模式

比如现在项目经理有一个需求：在项目现有所有类的方法前后打印日志。如何实现？

静态代理

 interface SmsService {
    void send(String message);
}
 class SmsServiceImpl implements SmsService {
    public void send(String message) {
        System.out.println("send message:" + message);
    }
}

class SmsServiceProxy  { 
     private  SmsService smsService;

    public SmsServiceProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    public void send(String message) {
        // beforeDo
        smsService.send("发送短信......");
        //afterDo
    }
}

静态代理是在编译的时候就将实现类和代理类编程了字节码class文件，然后加载到JVM中。

程序员要手动为每一个目标类编写对应的代理类。如果当前系统已经有成百上千个类，工作量太大了。所以，现在我们的努力方向是：如何少写或者不写代理类，却能完成代理功能

AOP就是动态代理的典型应用。

动态代理

关键是要创建代理类的对象，但是又不能直接去定义代理类，似乎和反射有关系，那么怎么拿到代理对象呢？

换个角度看对象的创建过程，上图中Class对象就是Class类的实例，它描述类的信息，反射中就可以通过它获得类的属性、方法等。所以能不嫩通过获得Class对象进而获得对应的代理实例呢？

关键使用java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类

 public class Person {

     public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

       Class  proxyClass =  Proxy.getProxyClass(SmsServiceImpl.class.getClassLoader(),SmsService.class);
       //获得构造函数
       Constructor constructor =  proxyClass.getConstructor(InvocationHandler.class);
         //获得代理对象
       SmsService smsService= (SmsService)constructor.newInstance(new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               System.out.println("before");
                Object result = method.invoke(new SmsServiceImpl(),args);
               System.out.println("after");
                return result;
           }
       });
       //调用对应的方法
         smsService.send("你好");
     }
 }

 

public class Person {
    public static void main(String[] args) throws Throwable {
        SmsServiceImpl target = new SmsServiceImpl();
        SmsService smsService = (SmsService) getProxy(target);
        smsService.send("send");

    }

    private static Object getProxy(final Object target) throws Exception {
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),/*类加载器*/
                target.getClass().getInterfaces(),/*让代理对象和目标对象实现相同接口*/
                new InvocationHandler(){/*代理对象的方法最终都会被JVM导向它的invoke方法*/
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println(method.getName() + "方法开始执行...");
                        Object result = method.invoke(target, args);
                        System.out.println(result);
                        System.out.println(method.getName() + "方法执行结束...");
                        return result;
                    }
                }
        );
        return proxy;
    }
}