【SSH系列】静态代理&&动态代理

从设计模式说起

代理模式是二十三中设计模式中的一种，代理模式就是指由一个代理主题来操作真实的主题，真实的主题执行具体的业务操作，而代理主题负责其她相关业务，简而言之，代理模式可以由以下三个部分组成：

a、抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
b、代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
c、真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
第一次接触代理模式的是在学习大话设计模式的时候，首先，小编带着小伙伴们一起回顾一下代理模式：
概念：
为其他对象提供一种代理以控制对这个对象的访问，代理是比较有用途的一种模式，而且变种较多,应用场合覆盖从小结构到整个系统的大结构，我们也许有代理服务器等概念，代理概念可以解释为：在出发点到目的地之间有一道中间层，意为代理。
uml图

  生活中的代理

  当客户端需要调用某个对象时，客户端实际上也不关心是否准确得到该对象，她只要一个能提供该功能的对象即可，此时我们就可返回该对象的代理。                                                                                                                                  看到此处，相信读者应该对Spring的AOP框架有点感觉了：当Spring容器中的被代理Bean实现了一个或多个接口时，Spring所创建的AOP代理就是这种动态代理。Spring AOP与此示例应用的区别在哪里呢？Spring AOP更灵活，当Sping定义InvocationHandler类的invoke()时，它并没有以硬编码方式决定调用哪些拦截器，而是通过配置文件来决定在invoke()方法中要调用哪些拦截器，这就实现了更彻底的解耦——当程序需要为目标对象扩展新功能时，根本无须改变Java代理，只需要在配置文件中增加更多的拦截器配置即可。   

         代理的分类

         a、静态代理

由程序员创建或工具生成代理类的源码，再编译代理类，所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。  

        b、 动态代理

        动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 
接着，小编分别讲解一下静态代理&&动态代理，加上相关的demo，希望可以帮助到有需要的小伙伴。
        静态代理
       具体用户管理实现类           

package com.bjpowernode.spring;public class UserManagerImpl implements UserManager {public void addUser(String username, String password) {//checkSecurity();System.out.println("---------UserManagerImpl.add()--------");}public void delUser(int userId) {//checkSecurity();System.out.println("---------UserManagerImpl.delUser()--------");}public String findUserById(int userId) {//checkSecurity();System.out.println("---------UserManagerImpl.findUserById()--------");return "张三";}public void modifyUser(int userId, String username, String password) {//checkSecurity();System.out.println("---------UserManagerImpl.modifyUser()--------");}//private void checkSecurity() {//System.out.println("-------checkSecurity-------");//}}

代理类--代理用户管理实现类       

package com.bjpowernode.spring;public class UserManagerImplProxy implements UserManager {private UserManager userManager;public UserManagerImplProxy(UserManager userManager) {this.userManager = userManager;}public void addUser(String username, String password) {checkSecurity();userManager.addUser(username, password);}public void delUser(int userId) {checkSecurity();userManager.delUser(userId);}public String findUserById(int userId) {checkSecurity();return userManager.findUserById(userId);}public void modifyUser(int userId, String username, String password) {checkSecurity();userManager.modifyUser(userId, username, password);}private void checkSecurity() {System.out.println("-------checkSecurity-------");}}

客户端调用

package com.bjpowernode.spring;public class Client {/** * @param args */public static void main(String[] args) {SecurityHandler hander = new SecurityHandler();UserManager useraManager = (UserManager)hander.createProxyInstance(new UserManagerImpl());useraManager.addUser("张三", "123");}}

ok，结合代码部分，具体说说静态代理，代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏。接着继续讲解动态代理。

动态代理

通过上面的demo，一个代理只能代理一个类型，而且是在编译器就已经确定被代理的对象。而动态代理实在运行的时候，通过反射机制来实现动态代理，并且能够代理各种类型的对象。在java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持，接着我们来编写具体的代码部分。
具体实现类，代码如下所示：

package com.bjpowernode.spring;public class UserManagerImpl implements UserManager {public void addUser(String username, String password) {//checkSecurity();System.out.println("---------UserManagerImpl.add()--------");}public void delUser(int userId) {//checkSecurity();System.out.println("---------UserManagerImpl.delUser()--------");}public String findUserById(int userId) {//checkSecurity();System.out.println("---------UserManagerImpl.findUserById()--------");return "张三";}public void modifyUser(int userId, String username, String password) {//checkSecurity();System.out.println("---------UserManagerImpl.modifyUser()--------");}}

动态创建代理对象的类

根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理 在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象 在Java中要想实现动态代理机制，需要//动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类       public class LogHandler implements InvocationHandler {        // 目标对象      private Object targetObject;      //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。                  public Object newProxyInstance(Object targetObject){          this.targetObject=targetObject;          //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例            //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器          //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口          //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法          //根据传入的目标返回一个代理对象          return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),                  targetObject.getClass().getInterfaces(),this);      }      @Override      //关联的这个实现类的方法被调用时将被执行      /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/      public Object invoke(Object proxy, Method method, Object[] args)              throws Throwable {          System.out.println("start-->>");          for(int i=0;i<args.length;i++){              System.out.println(args[i]);          }          Object ret=null;          try{              /*原对象方法调用前处理日志信息*/              System.out.println("satrt-->>");                            //调用目标方法              ret=method.invoke(targetObject, args);              /*原对象方法调用后处理日志信息*/              System.out.println("success-->>");          }catch(Exception e){              e.printStackTrace();              System.out.println("error-->>");              throw e;          }          return ret;      }    }  

客户端代码如下所示：

public class Client {        public static void main(String[] args){          LogHandler logHandler=new LogHandler();          UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());          //UserManager userManager=new UserManagerImpl();          userManager.addUser("1111", "张三");      }  }  

ok，动态代理的代码就展示到这里，讲解一下动态创建代理对象的类，被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

区别和联系

静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类，静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行的社会化才知道。

动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。 
    还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

小编寄语：该博文，小编主要简单的介绍了静态代理和动态代理，从设计模式中的代理模式开始说起，到静态代理和动态代理，静态代理是实实在在存在的，是我们自己用键盘打出来的，在编译期加入，提前就指定好了who来调用who，效率高；动态代理，一个类让事情变得更加简单，可以解决创建多个静态代理的麻烦，避免冗余的代码，无论是静态代理还是动态代理，都各有千秋，在项目中该如何使用，小伙伴可以自己掂量，SSH系列，未完待续......