Java-设计模式（二）------代理设计模式(Proxy)解析

一、代理模式是什么

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。

二、代理模式的三种实现方式

举个例子

有一个需求： 有一个目标对象 叫菜农（菜农会种植蔬菜），而对于用户而言，需要购买菜农种植的蔬菜。
现实生活中我们不会直接到菜农手中购买，而是找到一个中间代理对象–菜贩（菜贩会向菜农收购蔬菜然后贩卖给用户）。

2.1.静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

创建一个接口

package proxy.demo1;
/**
 * 代理设计模式 
 * 静态代理
 * 接口
 */
public interface IFarmers {
	
	public void grow();//种植蔬菜
}

创建目标对象

package proxy.demo1;
/**
 * 代理设计模式 
 * 静态代理
 * 目标对象实现类
 */
public class Farmers implements IFarmers{

	@Override
	public void grow() {
		 System.out.println("农民负责种植蔬菜！");
	}

}

创建代理对象

package proxy.demo1;
/**
 * 代理设计模式 
 * 静态代理
 * 代理对象的实现类
 */
public class FarmersProxy implements IFarmers{

	// 接收目标对象，以便调用grow方法
	private IFarmers farmer ;
	
	public FarmersProxy(IFarmers farmer){
		this.farmer = farmer;
	}
	
	@Override
	public void grow() {
		System.out.println("菜贩向菜农收购蔬菜！");
		farmer.grow();
		System.out.println("菜贩出售蔬菜！");
	}

}

创建测试类

package proxy.demo1;
/**
 * 代理设计模式 
 * 静态代理
 * 测试类
 */
public class Test {

	public static void main(String[] args) {
		//目标对象
		IFarmers farmer = new Farmers();
		//代理对象
		FarmersProxy proxy = new FarmersProxy(farmer);
		//执行扩展后的方法
		proxy.grow();
	}	
}

输出结果

菜贩向菜农收购蔬菜！
农民负责种植蔬菜！
菜贩出售蔬菜！

用法：创建一个代理对象FarmersProxy，实现IFarmers接口中方法。并且实现的方法需要包含目标对象Farmers的方法。

结果：通过代理对象在不改动目标对象Farmers方法代码的情况下扩展了grow（）方法的功能。

注意：假使代理对象FarmersProxy中只是简单地对grow方法做了另一种实现而没有包含目标对象Farmers的方法，也就不能算作代理模式了。所以这里的包含是关键

缺点：这种实现方式很直观也很简单，但其缺点是代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。

改进：如果能在运行时动态地写出代理对象，不但减少了一大批代理类的代码，也少了不断维护的烦恼，不过运行时的效率必定受到影响。这种方式就是接下来的动态代理。

2.2.动态代理

JDK中生成代理对象的API

代理类所在包:java.lang.reflect.Proxy

JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

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

ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型

InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入（一般直接使用匿名内部类）

创建一个接口

package proxy.demo1;
/**
 * 代理设计模式 
 * 动态代理
 * 接口
 */
public interface IFarmers {
	
	public void grow();//种植蔬菜
}

创建目标对象

package proxy.demo1;
/**
 * 代理设计模式 
 * 动态代理
 * 目标对象实现类
 */
public class Farmers implements IFarmers{

	@Override
	public void grow() {
		 System.out.println("农民负责种植蔬菜！");
	}

}

创建代理工厂类

package proxy.demo2;

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

/**
 * 代理设计模式 
 * 动态代理
 * 代理工厂类（动态生成一个代理对象），不需要实现接口
 */
public class ProxyFactory {

	//创建一个目标对象
    private Object target;
    
    public ProxyFactory(Object target){
        this.target=target;
    }
	
    //给目标对象生成代理对象
    public Object getProxyInstance(){
    	
    	Object object = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				//扩展的方法1
				System.out.println("菜贩向菜农收购蔬菜！");
				//执行目标对象方法
				Object obj = method.invoke(target, args);
				//扩展的方法2
				System.out.println("菜贩出售蔬菜！");
				return obj;
			}
		}); 
    	return object;
    }
}

测试类

package proxy.demo2;

/**
 * 代理设计模式 
 * 动态代理
 * 测试类
 */
public class Test {

	public static void main(String[] args) {
		//目标对象
		IFarmers farmer = new Farmers();
		// 通过代理工厂给目标对象，创建代理对象
		IFarmers proxy = (IFarmers)new ProxyFactory(farmer).getProxyInstance();
		//执行扩展后的方法
		proxy.grow();
	}
	
}

用法：创建一个代理工厂ProxyFactory，使用Proxy类静态方法newProxyInstance，动态创建代理对象调用需要扩展的方法即可。

结果：通过动态代理对象在不改动目标对象Farmers方法代码的情况下扩展了grow（）方法的功能。

特点：

1.代理对象,不需要实现接口，但是目标对象一定要实现接口,否则不能用动态代理
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理

缺点：代理对象不需要实现接口,但是目标对象一定要实现接口。

改进：使用Cglib代理：目标对象只是一个单独的对象,并没有实现任何的接口

2.3.Cglib代理

Cglib代理：上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理。

Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类，就可以使用Cglib实现。

Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和synaop，为他们提供方法的interception(拦截)。

Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类，不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理实现方法:

1）需要引入cglib的jar文件

依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.1</version>
</dependency>

因为Spring的核心包中已经包括了Cglib功能,所以也可以直接引入spring-core-3.2.5.jar即可。

2）引入功能包后,就可以在内存中动态构建子类。

3.代理的类不能为final，否则报错。

4.目标对象的方法如果为final/static，那么就不会被拦截,即不会执行目标对象额外的业务方法。

创建目标对象（不能实现任何接口）

package proxy.demo3;
/**
 * 代理设计模式 
 * Cglib代理
 * 目标对象（不实现任何接口）
 */
public class Farmers {

	public void grow() {
		 System.out.println("农民负责种植蔬菜！");
	}
}

创建一个Cglib子类代理工厂

package proxy.demo3;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
/**
 * 代理设计模式 
 * Cglib代理
 * Cglib子类代理工厂
 */
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 {
		//扩展的方法1
		System.out.println("菜贩向菜农收购蔬菜！");
		//执行目标对象的方法
		Object returnValue = method.invoke(target, args);
		//扩展的方法2
		System.out.println("菜贩出售蔬菜！");
		return returnValue;
	}
}

创建测试类

package proxy.demo3;
/**
 * 代理设计模式 
 * Cglib代理
 * 测试类
 */
public class Test {

	public static void main(String[] args) {
		//目标对象
		Farmers farmer = new Farmers();
		// 通过代理工厂 创建代理对象
		Farmers proxy = (Farmers)new ProxyFactory(farmer).getProxyInstance();
		//执行代理对象的方法
		proxy.grow();
	}
}

输出结果：

菜贩向菜农收购蔬菜！
农民负责种植蔬菜！
菜贩出售蔬菜！

三、总结

三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例。

在Spring的AOP编程中：

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

如果目标对象没有实现接口，用Cglib代理

如果你觉得本篇文章对你有所帮助的话，麻烦请点击头像右边的关注按钮，谢谢！

技术在交流中进步，知识在分享中传播