Proxy代理设计模式

代理设计模式

代理设计模式，在我看来和委托设计模式差不多，代理设计模式是指客户端并不直接调用实际对象，而是通过调用代理，来间接的调用实际的对象。

比如：你有官司，请一个律师给你打官司，就是你的律师给你代理打官司，代理设计模式就是类似于这种行为的抽象。

其中代理设计模式，分为静态代理设计模式和动态代理设计模式:

一.静态代理设计模式JAVA代码实现如下(静态代理不是静态方法调用，而是一种普通的调用方式)：

1.定义一个Student的接口


public interface Student {
	void study();
}

2.一个代理对象实现这个接口:

public class ProxyStudent implements Student{ 
	//利用接口进行实例化
	private Student student;
	public ProxyStudent(Student student){
		this.student=student;
	}
	//调用子类的study方法
	public void study() {
		student.study();
	}
}

3.定义一个实例对象去实现这个接口:

//测试RealStudent设计模式
public class RealStudent implements Student{
    private String study="study";
	public void study() {
		System.out.println(study);
	}
}

4.写一个测试类去测试代理模式例子:

import org.junit.Test;
/**
*类描述:测试代理设计模式
*@author: 张宇
*@date: 日期: 2018年7月23日 时间: 下午9:08:32
*@version 1.0
 */
public class TestStudent {
	@Test
	public void fun(){
		ProxyStudent student=new ProxyStudent(new RealStudent());
		student.study();
	}
}

测试结果: study

二.动态代理设计模式JAVA代码实现如下：

1.写一个接口和静态代理一样：

package DynamicProxyPattern;
//接口
public interface Student {
	void study();
}

2.写一个实现接口的实体类:

package DynamicProxyPattern;
//测试RealStudent设计模式
public class RealStudent implements Student{
    private String study="study";
	@Override
	public void study() {
		// TODO Auto-generated method stub
		System.out.println(study);
	}
}

3.写一个动态代理的类，获取对象，利用反射机制:

package DynamicProxyPattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler{
	private Object object;
	public DynamicProxy(Object object){
		this.object=object;
	}
	//获取对象
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		Object student=method.invoke(object, args);
		return student;
	}
}

4.测试动态代理:

package DynamicProxyPattern;
import java.lang.reflect.Proxy;
import org.junit.Test;
/**
*类描述:测试动态代理，利用反射技术进行测试
*@author: 张宇
*@date: 日期: 2018年7月23日 时间: 下午9:34:00
*@version 1.0
 */
public class TestDynamicProxy {
	@Test
	public void fun(){
		//定义他的实例化对象
		Student realSubject=new RealStudent();
		//获取它的代理对象
		DynamicProxy proxy=new DynamicProxy(realSubject);
		//获取类的加载器对象
		ClassLoader classLoader=realSubject.getClass().getClassLoader();
		//通过反射获取类的对象
		Student student=(Student)Proxy.newProxyInstance(classLoader, new Class[]{Student.class}, proxy);
		//对象调用方法
		student.study();
	}
}

测试结果: study

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。

Proxy代理设计模式

猜你喜欢