【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系列，未完待续......