Java的三种代理模式

Java的三种代理模式#

参考：http://www.cnblogs.com/cenyu/p/6289209.html

一 为什么使用代理

　　我们在写一个功能函数时，经常需要在其中写入与功能不是直接相关但很有必要的代码，如日志记录，信息发送，安全和事务支持等，这些枝节性代码虽然是必要的，但它会带来以下麻烦

1. 枝节性代码游离在功能性代码之外，它不是函数的目的，这是对OO是一种破坏；
2. 枝节性代码会造成功能性代码对其它类的依赖，加深类之间的耦合，可重用性降低；
3. 从法理上说，枝节性代码应该监视着功能性代码，然后采取行动，而不是功能性代码 通知枝节性代码采取行动，这好比吟游诗人应该是主动记录骑士的功绩而不是骑士主动要求诗人记录自己的功绩。

1.1 常见的代理:

1. 远程代理(Remote Proxy)：对一个位于不同的地址空间对象提供一个局域代表对象；
2. 虚拟代理(Virtual Proxy)：根据需要将一个资源消耗很大或者比较复杂的对象，延迟加载，在真正需要的时候才创建；
3. 保护代理(Protect or Access Proxy)：控制对一个对象的访问权限；
4. 智能引用(Smart Reference Proxy)：提供相比目标对象额外的服务和功能。

1.2 代理定义：

　　代理(Proxy)是一种设计模式,定义：为其他对象提供一个代理以控制对某个对象的访问，即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增加额外的功能操作,即扩展目标对象的功能。
　　这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需要修改,可以通过代理的方式来扩展该方法。

二 Java常用的三种代理

2.1 静态代理

　　静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
　　关键：在编译期确定代理对象，在程序运行前代理类的.class文件就已经存在了。
　　比如：在代理对象中直接用new实例化被代理对象，或者将被代理对象传入代理对象的构造方法。

　　例子：
　　模拟保存动作，定义一个保存动作的接口:IUserDao.java，然后目标对象UserDao.java实现这个接口的方法，此时如果使用静态代理方式，就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口，调用的时候通过调用代理对象的方法来调用目标对象。

接口:IUserDao.java

    public interface IUserDao {
        void save();
    }

目标对象类:UserDao.java

    public class UserDao implements IUserDao {
        public void save() {
            System.out.println("----已经保存数据!----");
        }
    }

代理对象:UserDaoProxy.java

    public class UserDaoProxy implements IUserDao{
        //接收保存目标对象
        private IUserDao target;
        public UserDaoProxy(IUserDao target){
            this.target=target;
        }

        public void save() {
            System.out.println("开始事务...");
            target.save();//执行目标对象的方法
            System.out.println("提交事务...");
        }
    }

测试类:App.java

    public class App {
        public static void main(String[] args) {
            //目标对象
            UserDao target = new UserDao();
    
            //代理对象,把目标对象传给代理对象,建立代理关系
            UserDaoProxy proxy = new UserDaoProxy(target);
    
            proxy.save();//执行的是代理的方法
        }
    }

静态代理总结:

优点：
　　可以做到在不修改目标对象的功能前提下,对目标功能扩展。
缺点:
　　代理类和委托类实现相同的接口，同时要实现相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2.2 动态代理

动态代理有以下特点:

1. 在运行期，通过反射机制创建一个实现了一组给定接口的新类；
2. 在运行时生成的class，必须提供一组interface给它，然后该class就宣称它实现了这些 interface。该class的实例可以当作这些interface中的任何一个来用。但是这个Dynamic Proxy其实就是一个Proxy， 它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
3. 动态代理也叫做:JDK代理,接口代理
4. 接口中声明的所有方法都被转移到调用处理器（handler）一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。

JDK中生成代理对象的API
　　代理类所在包:java.lang.reflect.Proxy
　　JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

    static Object newProxyInstance(ClassLoader loader, Class [] interfaces, InvocationHandler handler)

　　注意该方法是在Proxy类中的静态方法,且接收的三个参数依次为:

• ClassLoader loader:指定当前目标对象使用的类加载器，用null表示默认类加载器
• Class [] interfaces:需要实现的接口数组
• InvocationHandler handler:调用处理器,执行目标对象的方法时,会触发调用处理器的方法,从而把当前执行目标对象的方法作为参数传入

java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

    // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数是代理类实例，第二个参数是被调用的方法对象,第三个参数是方法参数的数组形式
    // 第三个方法是调用参数。
    Object invoke(Object proxy, Method method, Object[] args)

代码示例:

package model;

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

interface IUserDao {
	void save();
}

class UserDao implements IUserDao {
	public void save() {
		System.out.println("----已经保存数据!----");
	}
}

class ProxyFactory {
	private Object target;

	public ProxyFactory(Object target) {
		this.target = target;
	}

	// 给目标对象生成代理对象，其class文件是由 JVM 在运行时动态生成
	public Object getProxyInstance() {
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println("开始");
						// 执行目标对象方法，方法参数是target，表示该方法从属于target
						Object returnValue = method.invoke(target, args);
						System.out.println("提交");
						return returnValue;
					}
				});
	}
}

public class Client {
	public static void main(String[] args) {
		// 目标对象
		IUserDao target = new UserDao();
		System.out.println(target.getClass());
		// 代理对象
		IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
		System.out.println(proxy.getClass());
		proxy.save();
	}
}

输出：

class model.UserDao
class model.$Proxy0
开始
----已经保存数据!----
提交

总结:
　　代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

2.3 Cglib代理

　　上面的静态代理和动态代理模式都是要求目标对象实现一个接口或者多个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用构建目标对象子类的方式实现代理,这种方法就叫做:Cglib代理。
　　Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

• Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口。它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
• Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的子类
• 代理的类不能为final,否则报错；目标对象的方法如果为final/static,那么就不会被拦截。

代码示例:
目标对象类:UserDao.java

    /**
     * 目标对象,没有实现任何接口
     */
    public class UserDao {

        public void save() {
            System.out.println("----已经保存数据!----");
        }
    }

Cglib代理工厂:ProxyFactory.java

    /**
     * Cglib子类代理工厂
    * 对UserDao在内存中动态构建一个子类对象
    */
    public class ProxyFactory implements MethodInterceptor{
         //维护目标对象
        private Object target;

        public ProxyFactory(Object target) {
            this.target = target;
        }

       //给目标对象创建一个代理对象
        public Object getProxyInstance(){
            //1.工具类
            Enhancer en = new Enhancer();
           //2.设置父类
            en.setSuperclass(target.getClass());
            //3.设置回调函数
            en.setCallback(this);
            //4.创建子类(代理对象)
            return en.create();
        }

        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("开始事务...");
            //执行目标对象的方法
            Object returnValue = method.invoke(target, args);
            System.out.println("提交事务...");
            return returnValue;
        }
    }

测试类:

    /**
     * 测试类
     */
    public class App {

        @Test
        public void test(){
            //目标对象
            UserDao target = new UserDao();

            //代理对象
            UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

            //执行代理对象的方法
            proxy.save();
        }
    }

三 简单扩展

3.1 AOP（AspectOrientedProgramming）

　　将日志记录，性能统计，安全控制，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码---解耦。

3.2 在Spring的AOP编程中:

如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理

3.3 代理模式与装饰者模式的区别

　　UML类图基本没区别，都是实现同一个接口，一个类包装另一个类。 两者的定义：

• 装饰器模式：能动态的新增或组合对象的行为
  在不改变接口的前提下，动态扩展对象的功能
• 代理模式：为其他对象提供一种代理以控制对这个对象的访问
  在不改变接口的前提下，控制对象的访问

　　装饰模式是“新增行为”，而代理模式是“控制访问”。关键就是我们如何判断是“新增行为”还是“控制访问”。