浅谈java动态代理的两种实现方式（java动态代理）

一、写在前面

本人搬砖已经两年，但是对于java动态代理的东西一直是一知半解，正好最近复习了下java基础，对动态代理也有了更深的认识，所以在这里记录一下，免得以后时间久了会忘记。

二、为什么要用动态代理

说动态代理之前先来说一下静态代理。如果有如下的一个需求大家先想想该怎么实现。
项目中有很多个服务，用户服务、产品服务、订单服务、积分服务等等，有一天老板说让记录一下用户服务的响应时间，用代理模式来实现这个功能。

用户服务的接口是这样的（实际中业务逻辑不会这么简单，只是举个栗子）

      public interface UserService {
                 void request（）；      
            }
 实现类是这样的

        public class UserviceImpl implements UserService {
        @Override
        public void request() {
            System.out.println("用户服务你好");
        }
    }

随便一想，不到3秒，这太简单了，啪啪啪不到三分钟最low的方法就是下面的这种。

  public class UserServiceProxy implements UserService {
        private UserService userService;
    
        public UserServiceProxy(UserService userService) {
            this.userService = userService;
        }
    
        @Override
        public void request() {
            long startTime = System.currentTimeMillis();
            userService.request();
            System.out.println("用户中心服务花费时间为："+(System.currentTimeMillis()-startTime));
        }
    
        public static void main(String[] args) {
            UserService userService = new UserServiceImpl();
            UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
            userServiceProxy.request();
        }
    }

怎么样，是不是很简单，so easy，没有动之前的逻辑代码还新增了功能，完美实现了spring的aop。下班！
然而，事情没有想得那么简单！第二天，老板说把订单服务的响应时间也记录下吧，没问题不就是跟昨天差不多嘛，代码差不多，接下来又是搬砖时间。（接口和原来的实现类就不写出来了）

   public class OrderServiceProxy implements OrderService {
            private OrderService orderService;
        
            public OrderServiceProxy(OrderService orderService) {
                this.orderService = orderService;
            }
        
            @Override
            public void request() {
                long startTime = System.currentTimeMillis();
                userService.request();
                System.out.println("订单服务花费时间为："+(System.currentTimeMillis()-startTime));
            }
        
            public static void main(String[] args) {
                OrderService orderService = new OrderServiceImpl();
                OrderServiceProxy orderServiceProxy = new OrderServiceProxy(orderService);
                orderServiceProxy.request();
            }
        }

喝杯茶吧，歇息会儿，还没等屁股坐热，老板又发话了，所有的服务都要加上这个功能。完了，十几个服务，要再写十几个类，代码上千行，这可咋办。。。。。。

三、动态代理上场

动态代理，顾名思义就是动态地生成代理对象。在JDK1.3之后引入的一种机制，为指定的接口在系统运行期间动态地声称代理对象，从而帮助我们走出最初使用静态代理实现AOP的窘境。
动态代理的实现主要由一个类和一个接口组成，即java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler接口。
让我们再回到上面提出的问题，最然要为用户服务和订单服务提供代理对象，但是代理对象中药添加的逻辑是一样的。所以我们只需要实现一个InvocationHandler就可以了，这也算是AOP的一种体现。具体代码如下。

  public class RequestCostInvocationHandler implements InvocationHandler {
        private Object targer;
    
        public RequestCostInvocationHandler(Object targer) {
            this.targer = targer;
        }
    
        /**被代理对象的任何方法被执行时，都会先进入这个方法*/
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (method.getName().equals("request")){
                long startTime = System.currentTimeMillis();
                //执行目标的方法
                method.invoke(targer,args);
                System.out.println("服务所需的时间为："+(System.currentTimeMillis()-startTime));
            }
            return null;
        }
    
    
        public static void main(String[] args) {
            /**
             * 三个参数的解释：
             * classloader:声称代理类
             * 代理类应该实现的接口
             * 实现InvocationHandler的切面类
             */
            UserService userService = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(),
                    new Class[]{UserService.class},new RequestCostInvocationHandler(new UserServiceImpl()));
    
            OrderService orderService = (OrderService) Proxy.newProxyInstance(OrderService.class.getClassLoader(),
                    new Class[]{OrderService.class},new RequestCostInvocationHandler(new OrderServiceImpl()));
    
            userService.request();
    
            orderService.request();;
        }
    }

首先通过 newProxyInstance 方法获取代理类的实例, 之后就可以通过这个代理类的实例调用代理类的方法，对代理类的方法调用都会调用中间类 (实现了 invocationHandle 的类) 的 invoke 方法，在 invoke 方法中我们调用委托类的对应方法，然后加上自己的处理逻辑。

java 动态代理最大的特点就是动态生成的代理类和委托类实现同一个接口。java 动态代理其实内部是通过反射机制实现的，也就是已知的一个对象，在运行的时候动态调用它的方法，并且调用的时候还可以加一些自己的逻辑在里面。（附: Java 反射）

怎么样，这样是不是更简洁呢。只要需要添加的功能是一样的，我们就可以“切”进去。

当然了，动态代理也有不足之处，只有实现了某个接口的类才可以使用java动态代理机制。真是的业务中并不是遇到的所有的类都会提供一个接口，因此，对于没有实现接口的类就无法使用动态代理。java是万能的，前辈们早就解决了这个问题，具体请看下篇介绍：cglib动态代理。

附：Proxy.newProxyInstance 源码（供学有余力的同学参考）

Proxy.newProxyInstance 通过反射机制用来动态生成代理类对象, 为接口创建一个代理类，这个代理类实现这个接口。具体源码如下：

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        // 检查空指针
        Objects.requireNonNull(h);
        // 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
        final Class<?>[] intfs = interfaces.clone();
        // 获取系统的安全接口,不为空的话需要验证是否允许访问这种关系的代理访问
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 生成代理类 Class,通过类加载器和接口
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * 通过构造器来创建实例
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //获取所有的构造器
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            // 构造器不是public的话需要设置可以访问
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 返回创建的代理类Class的实例对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }