设计模式---代理模式

最新推荐文章于 2024-07-10 21:13:15 发布

又菜又爱玩٩( ö̆ ) و

最新推荐文章于 2024-07-10 21:13:15 发布

阅读量127

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/a972669015/article/details/96596300

版权

设计模式专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、什么是代理模式

Proxy模式又叫做代理模式，是构造型的设计模式之一，它可以为其他对象提供一种代理（Proxy）以控制对这个对象的访问。所谓代理，是指具有与代理元（被代理的对象）具有相同的接口的类，客户端必须通过代理与被代理的目标类交互，而代理一般在交互的过程中（交互前后），进行某些特别的处理。

二、代理模式的结构

三、代理模式的角色和职责

subject（抽象主题角色）

真实主题与代理主题的共同接口，这样就可以在任何使用具体目标对象的地方使用代理对象

RealSubject（真实主题角色）

定义了代理角色所代表的真实对象。真正实现目标接口要求的功能

Proxy（代理主题角色）

实现与目标对象一样的接口，这样就可以使用代理对象代替具体的目标对象

含有对真实主题角色的引用，可以在任何需要的时候调用具体的目标对象

代理角色通常在将客户端调用传递给真是主题对象之前或者之后执行某些操作，而不是单纯返回真实的对象。

可以控制对具体目标对象的访问，并可能负责创建和删除它

四、简单示例

例如，出版社出了一本书并出售，书店代替出版社卖书（可以有折扣或者代金券等优惠），客户通过书店买书

出版社和书店的共同接口：

public interface Subject {
	public void sellBook();
}

出版社卖书：

public class RealSubject implements Subject {

	public void sellBook() {
		System.out.println("卖书");
	}

}

书店卖书：

public class ProxySubject implements Subject{
	private RealSubject realSubject;

	public void sellBook() {
		disCount();
		if(realSubject == null) {
			realSubject = new RealSubject();
		}
		realSubject.sellBook();
		coupon();
	}
	
	public void disCount() {
		System.out.println("打折");
	}
	
	public void coupon() {
		System.out.println("赠送代金券");
	}
}

客户买书：

public class MainClass {
	public static void main(String[] args) {
		ProxySubject proxySubject = new ProxySubject();
		proxySubject.sellBook();
	}
}

由以上代码可以看出，客户端调用的实际是RealSubject的sellBook方法，用ProxySubject来代理RealSubject也能达到同样的效果，同时还封装了其他的方法（disCount,coupon）

但是，按照上述方法实现代理，那么真实角色必须是已经存在的，并将其作为代理对象的内部属性。但是实际应用时，一个真实对象必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；另外，如果事先不知道真实角色，也无法使用代理，所以，需要使用java动态代理来解决。

五、动态代理

Java动态代理类主要位于java.lang.reflect包下，涉及到以下两个类：

1.InvocationHandler

public interface InvocationHandler

InvocationHandler 是代理实例的调用处理程序 实现的接口。

每个代理实例都具有一个关联的Invocation Handler。当调用代理实例的方法时，将对方法调用进行编码并将其指派到它的Invocation Handler的 invoke 方法。

- invoke(Object proxy,Method method,Object[] args)

在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

参数：

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回：

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

抛出：

Throwable - 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型，代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。

2.Proxy（动态代理类）

Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

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

参数：

loader - 定义代理类的类加载器

interfaces - 代理类要实现的接口列表

h - 指派方法调用的调用处理程序

返回：

一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

抛出：

IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制

NullPointerException - 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null

所谓动态代理是这样一种class，是一种在运行时生成的class，在生成它时必须提供给一组interface给它，然后该class宣称它实现了这些interface,可以把该class当成这些interface中的任意一个来用，其实就是一个Proxy，他不会替你做任何实质性的工作，在生成实例时必须提供一个handler，由他接管实际工作。

动态代理实现：

public interface Subject {
	public void sellBook();
}

public class RealSubject implements Subject {

	public void sellBook() {
		System.out.println("卖书");
	}

}


public class RealSubject2 implements Subject {

	public void sellBook() {
		System.out.println("卖书");
	}

}

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


/**
 *该代理类的内部属性是Object,实际使用时通过set方法（构造方法）传递进来一个对象
 *此外，该类实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象将要
 *执行的方法，方法参数是obj,表示改方法从属于obj，我们可以在执行真实对象的方法前后加入额外方法
 */
public class MyHandler implements InvocationHandler {
    /**
     *维护对真实对象的引用
     */
	private Object obj;
	
    /**
     *也可以通过构造方法传值
     */
	public void setRealSubject(Object realSubject) {
		this.obj= realSubject;
	}

    /**
     *重写invoke
     */
	public Object invoke(Object proxy, Method method, Object[] args){
		Object result = null;
		disCount();
		try {
			result = method.invoke(realSubject, args);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		coupon();
		return result;
	}
	
	public void disCount() {
		System.out.println("打折");
	}
	
	public void coupon() {
		System.out.println("赠送代金券");
	}

}

import java.lang.reflect.Proxy;

public class Client{
	public static void main(String[] args) {
		RealSubject realSubject = new RealSubject();
		InvocationHandler myHandler = new MyHandler();
		myHandler.setRealSubject(realSubject);
		
                //下面代码一次性生成代理  Proxy.newProxyInstance
		Subject subject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(), realSubject.getClass().getInterfaces(), myHandler);

                //当执行到这里，不管调用subject哪个方法，都会进入到myHandler的invoke方法中
	        subject.sellBook();

                //查看subject的实际类型   $Proxy0
                System.out.println(subject.getClass());


                RealSubject2 realSubject2 = new RealSubject2();
		myHandler.setRealSubject(realSubject2);
		
                //下面代码一次性生成代理  Proxy.newProxyInstance
		subject = (Subject)Proxy.newProxyInstance(RealSubject2.class.getClassLoader(), realSubject2.getClass().getInterfaces(), myHandler);

                //当执行到这里，不管调用subject哪个方法，都会进入到myHandler的invoke方法中
	        subject.sellBook();

                //查看subject的实际类型   $Proxy0
                System.out.println(subject.getClass());
	}
}