代理设计模式
给某一个对象提供代理对象，由代理对象控制具体对象的使用。
什么叫代理？
在生活中，代理无处不在，如各种代理商。
如：生产电脑的厂家不会直接把电脑卖给零售客户，而是通过代理来完成销售。客户也不用因为买电脑而跑去厂家。
这就是代理过程
代理类：
主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。
代理类本身并不真正实现服务，而是通过调用委托类的相关方法，来提供特定的服务。
代理类与委托类都实现了同一个接口。
代理中涉及的角色：
1，抽象主题角色：声明真实角色和代理对象的共同接口
2，真实角色：是我们最终要引用的对象
3，代理角色：代理对象内部加了一些自己的处理方法，最后还是要去调用真实角色的处理方法。
简单代理结构图：
为什么要使用代理？
1，授权机制不同，不用级别的用户对同一对象拥有不同的访问权限。如论坛中，注册用户和游客的权限差别。
2，不让客户端直接操作到某个对象，但又必须和那个对象有所互动。
如：
在网络中，在我们访问某个远端的服务器上的某个对象的时候，如果直接操作这个对象，网络速度原因可能比较慢，那我们就可以先用Proxy来代替那个对象。
如果我们在加载示一个很大的图片的时候，可以让其在后台加载，代理中显示等待信息。
下面看实例：
package proxy;
//公共接口,产生须要让其子类实现的方法
interface SellInterface
{
public void sell();
}
//真实角色，实现SellInterface
class SellFactory implements SellInterface
{
public void sell() {
System.out.println("真实角色在处理问题");
}
}
//代理类
class MyProxy implements SellInterface
{
SellFactory sf; //代理类须要调用真实角色的处理方法
public void sell()
{
/*
这样调用，可以让这个代理类在这里先处理一些问题，
比如判断什么的，如果不满足，就不用去调用具体实现方法了，这样可以提高效率。
在实际应用中，如我们在访问网站时，也是先访问的本地服务器，如果有自己所须要的，
在本地就可以完成访问，没必要每次都去总部访问资源，这样很占空间。
再比如：我们买正品戴尔电脑，不用去总部，在代理处就可以了。如果代理处满足不了，
在去总部。
*/
if(test()){ //满足条件
sf = new SellFactory();
sf.sell();
}
else
throw new RuntimeException();
}
protected boolean test()
{
return true;
}
}
//客户端
public class CommonProxy {
public static void main(String [] args)
{
//在代理处办事
SellInterface mp = new MyProxy();
mp.sell();
}
}
代理模式的--动态代理
JVM在执行时，运用反射机制动态创建一个类，如果这个类是代理类，那么这样的形式就是动态代理类。
动态代理和普通代理的区别?
普通代理类：在程序运行前，代理类的class文件已经存了
动态代理类：程序运行时 运用反射机制 动态创建而成
在上面的代理中，我们让代理类实现了接口SellInterface，这样使得代码，通用性很低。
在java中提供了其它方法，使得代理类通用性提高了。
通过类Proxy 和 接口InvocationHandler 来实现对代理模式的支持。
Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
代理创建过程
1，首先通过Proxy类的方法来创建代理对象，须要通过来主题角色建立
2，代理类须要实现InvocationHandler 接口
动态代理结构图
动态代理的建立：两种方法
由Proxy类 和 接口 InvocationHandler 来共同完成。
Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。
InvocationHandler 是代理实例的调用处理程序实现的接口.
如：建立List list = new ArrayList 集合的代理类
a , 通过获取构造方法来建立
// 1，获取动态代理类的Class
Class clazz = Proxy.getProxyClass(
List.class.getClassLoader(), // 目标类所实现的接口的类加载器
new Class[]{List.class} //目标类所实现的接口
);
// 2, 实现InvocationHandler接口，通过这个去调用目标类。
InvocationHandler ih = new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//可以加入功能
Object re = method.invoke(list, args); //调用所要代理的对象的方法
//可以加入功能
return re;
}
};
// 3，获取代理类的构造函数
Constructor constructor = clazz.getConstructor(InvocationHandler.class);
// 4，创建代理对象
List myproxy = (List)constructor.newInstance(ih);
b , 直接通过newProxyInstance 来建立
List myproxy2 = (List)Proxy.newProxyInstance(
List.class.getClassLoader(), // 目标类所实现的接口的类加载器
new Class[]{List.class}, //目标类所实现的接口
new InvocationHandler(){ // 实现接口，去调用目标类
public Object invoke(Object proxy, Method method,Object[] args) throws Throwable {
//可以加入功能
Object re = method.invoke(list, args); //调用所要代理的对象的方法
//可以加入功能
return re;
}
}
);
示例代码：
ackage proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Collection;
interface SellInterface
{
public void sell();
}
class SellFactory implements SellInterface
{
public void sell() {
System.out.println("真实角色在处理问题");
}
}
//代理类1,尽量面向对向，使代理类更通用。
class MyProxy implements InvocationHandler
{
static Object obj;
MyProxy(Object obj) // obj:传入须要代理的类
{
this.obj = obj;
}
//通过Proxy类的newProxyInstance方法来返回代理对象
public static Object factory(Object o)
{
Class clazz = o.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new MyProxy(o));
}
/*
* 实现InvocationHander接口的invoke
* proxy:代理实例
* method:对应于在代理实例上调用的接口方法的 Method 实例
* args [] :传入代理实例上方法的参数值的对象数组.
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("函数调用前被拦截了"+method);
// System.out.println(proxy.getClass().getName());
//代理调用真实角色处理方法
Object mo = method.invoke(obj, args);
System.out.println("函数调用后进行处理"+method);
return mo;
}
}
//客户端
public class DynamicProxy {
public static void main(String [] args) throws Exception
{
SellInterface mp = (SellInterface)MyProxy.factory(new SellFactory());
mp.sell();
// test();
}
public static void test() throws Exception
{
//获取代理类Proxy的字节码
System.out.println("-------------constructors list-------------");
Class clazzProxy = Proxy.getProxyClass(Object.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy.getName());
//获取代理类Proxy的构造方法
Constructor [] constructors = clazzProxy.getConstructors();
//获取Proxy的方法
System.out.println("-------------method list----------------");
Method [] methods = clazzProxy.getDeclaredMethods();
for(Method m : methods)
{
//以（）形式输出方法里的参数
StringBuilder sb = new StringBuilder();
sb.append(m.getName());
sb.append("(");
//列出方法的参数
Class [] clazzParam = m.getParameterTypes();
for(Class c : clazzParam)
{
sb.append(c.getName()+",");
}
if(clazzParam!=null && clazzParam.length!=0)
sb.deleteCharAt(sb.length()-1);
sb.append(")");
System.out.println(sb);
}
//创建代理对象的方法
System.out.println("--------------create instance -------------------");
//创建构造器
Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class);
//方法一：
class MyInvocationHandler implements InvocationHandler{
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法一");
// Object retVal = method.invoke(obj, args);
return null;
}
}
Object proxy1 = constructor.newInstance(new MyInvocationHandler());
System.out.println(proxy1);
//方法二
Object proxy2 = constructor.newInstance(new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法二");
// Object retVal = method.invoke(obj, args);
return null;
}
});
System.out.println(proxy2);
//方法三：
Object proxy3 = Proxy.newProxyInstance(
Object.class.getClassLoader(),
new Class[]{Collection.class},
new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始切面。。。"+method);
// Object retVal = method.invoke(obj, args); //动态调用真实角色处理方法
System.out.println("结束切面。。。"+method);
return null;
}
}
);
System.out.println(proxy3);
}
}
用代理实现AOP拦截机制的例子
可以拦截我们指定的函数,并在拦截前后根据需要进行处理.
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
看下面代码示例：
package proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Collection;
interface AopInterface
{
public void start(Object obj); //切面--调用前的处理
public void end(Object obj); //切面--调用后处理
}
class AopInterfaceImp implements AopInterface //对象切面的具体操作
{
public void start(Object obj) {
System.out.println("调用前被拦截了，做一些其它的事");
}
public void end(Object obj) {
System.out.println("调用后被拦截，去处理一些其它事");
}
}
//代理类
class MyProxy4 implements InvocationHandler
{
private AopInterface aop; //切入时调用
private Object obj;
private String methodName = null; //要拦截的方法名字
MyProxy4() {} // obj:传入须要代理的类
//通过Proxy类的newProxyInstance方法来返回代理对象
public Object factory(Object o)
{
this.obj = o;
Class clazz = o.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//在这里还应该做一些判断，如：aop没有初始化。
Object mo;
//如果该方法是要拦截的
if(methodName != null && method.toString().indexOf(methodName)!=-1) //这里为什么是用indexOf呢？
//因为method.toString() 返回的是
// public abstract void proxy.TestInterface.add() 形式。
{
aop.start(obj);
//代理调用真实角色处理方法
mo = method.invoke(obj, args);
aop.end(obj);
}
else
{
mo = method.invoke(obj, args);
}
return mo;
}
public AopInterface getAop()
{ return aop; }
public void setAop(AopInterface aop)
{ this.aop = aop; }
public String setMethodName(String methodName)
{
return this.methodName = methodName;
}
}
//用于测试的
interface TestInterface {
public void add();
public void dele();
}
class ImpTest implements TestInterface{
public void add() {
System.out.println("........... add()");
}
public void dele(){
System.out.println("............ acc()");
}
}
//客户端
public class DynamicProxy2 {
public static void main(String [] args) throws Exception
{
MyProxy4 mp = new MyProxy4(); //建立代理对象
mp.setAop(new AopInterfaceImp()); //给代理设置所要代理的类
mp.setMethodName("add"); //设置须要被拦截的方法名
//通过代理建立测试类对象 ，因为要让测试类在执行时，先去代理处
TestInterface ai = (TestInterface)mp.factory(new ImpTest());
ai.add(); //执行要拦截的add()方法
ai.dele(); //执行没有被拦截的dele()方法
}
}
扫一扫
2932
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
