Java 设计模式系列(9) —— 代理模式

求和小熊猫

发布于 2021-01-07 10:10:59

2960

发布于 2021-01-07 10:10:59

文章被收录于专栏：∑小熊猫的博客

代理模式

代理模式的定义： 代理模式为其他对象提供一种代理以控制这个对象的访问、

代理模式的三个主要角色：

Subject 抽象主题角色：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类
ProxySubject 代理主题角色：该角色主要负责引用和控制真实主题，负责在需要的时候创建或删除真实主题对象
RealSubject 真实主题角色：该类是代理标识的真实对象，是业务逻辑的具体执行者

代理模式的种类

1. 远程代理 远程代理就是将工作委托给远程对象(不同的进程，不同的机械) 来完成。

2. 虚拟代理 当创建一个资源耗费比较多的资源时，可以首先创建代理对象，而将真实的的对象延时创建。

3. 保护代理 控制一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限

4. 缓存代理 使用存储来加速代理，即我们可以通过将一个操作的结果缓存起来，当其他的客户端进行完全相同的操作时，便可以直接从缓存中拿取数据

5. 同步代理 同步代理可以使几个用户使用一个对象而没有冲突

6. 智能引用代理 当一个对象被引用时，可以提供一些额外的操作。

代理模式的简单示例

Subject 角色

public interface Subject {
	
	//业务逻辑类
	public void businessLogic();

}

RealSubject 角色

public class RealSubject implements Subject {

	@Override
	public void businessLogic() {
		System.out.println("We are processing the business");

	}

}

ProxySubject 角色

public class ProxySubject implements Subject {
	
	private Subject subject = null;
	
	public void setProxy(Subject subject) {
		this.subject = subject;
	}
	
	//预处理
	private void preDealing() {
		System.out.println("Pretreament");
	}
	
	//后续处理
	private void followUpDealing() {
		System.out.println("FollowUpTreament");
	}

	@Override
	public void businessLogic(){
		this.preDealing();
		if(subject == null) {
			System.out.println("No subject Exception");
			return;
		}else {
			subject.businessLogic();
		}
		this.followUpDealing();

	}

}

代理模式的优点

优点：

职责清晰：真实主题角色只需完成业务逻辑的实现，无需关心其他非本职业务
高扩展性：真实主题的角色随需求的不同可能有很多种，但是由于真实主题和代理主题都实现了抽象主题接口或集成了真实主题与抽象主题的抽象类，因此代理主题可以在不做任何修改的情况下代理各种真实主题的角色
智能化：代理主题可以按照运行时的需求去代理真实主题

代理模式的扩展

1. 普通代理

普通代理要求客户端只能访问代理角色，而不能访问真实角色

要实现普通代理模式需要在代理主题和真实主题的代码上做文章,我们可以根据相应的条件自动设定所需要使用的真实代理对象，也就是说我们可以在代理主题对象的构造参数中设定所需要的真实代理对象。这样我们便可以只访问代理角色，而无需选的所需的真实代理对象

下面我们可以看一个示例

抽象主题角色

public interface Subject {
	public void doingProcedureA();
	
	public void doingProcedureB();
	
	public void doingProcedureC();

}

代理主题角色

public class ProxySubject implements Subject {
	
	private Subject proxy = null;
	
	public ProxySubject(int var1,String var2) throws Exception{
		if (var1 < 0) {
			throw new Exception("Invalid Exception");
		}else if (var1 == 1) {
			proxy = new RealSubject(this,var2);
		}
		
	}

	@Override
	public void doingProcedureA() {
		proxy.doingProcedureA();
	}

	@Override
	public void doingProcedureB() {
		proxy.doingProcedureB();
	}

	@Override
	public void doingProcedureC() {
		proxy.doingProcedureC();
	}

}

真实主题角色

public class RealSubject implements Subject{
	private String var;
	
	public RealSubject(Subject proxy,String var) throws Exception {
		if (proxy == null) {
			throw new Exception("The Proxy is null");
		}else {
			this.var = var;
		}
	}

	@Override
	public void doingProcedureA() {
		System.out.println("The RealSubject is doing Procedure A");
	}

	@Override
	public void doingProcedureB() {
		System.out.println("The RealSubject is doing Procedure B");
	}

	@Override
	public void doingProcedureC() {
		System.out.println("The RealSubject is doing Procedure C");		
	}

}

2. 强制代理

一般性的情况下，都是代理角色找到对应的真实角色，但是强制代理是真实角色指定代理角色，即要对真实角色进行操控，不需要使用真实角色指定的代理类。

要想实现强制代理就需要在真实角色中创建属于自己的代理角色，并且返回该代理角色。

抽象主题角色

public interface Subject {
	public void doingProcedureA();	
	public void doingProcedureB();
}

代理主题角色

public class ProxySubject implements Subject {
	private Subject proxy = null;
	
	public ProxySubject(Subject sub) throws Exception {
		if (this == sub) {
			throw new Exception("Subject is not RealSunject");
		}else {
			proxy = sub;
		}
	}

	@Override
	public void doingProcedureA() {
		proxy.doingProcedureA();
	}

	@Override
	public void doingProcedureB() {
		proxy.doingProcedureB();
	}

}

真实主题角色

public class RealSubject implements Subject {
	
	public Subject getProxy() {
		Subject proxy = null;
		try {
			proxy = new ProxySubject(this);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return proxy;
	}

	@Override
	public void doingProcedureA() {
		System.out.println("The RealSubject is doing Procedure A");		
	}

	@Override
	public void doingProcedureB() {
		System.out.println("The RealSubject is doing Procedure A");		
	}

}

3. 动态代理

动态代理就是在实现阶段不用关心谁代理，而在运行阶段才指定代理哪一个对象。相对来说，自己写代理类的方式就是静态代理。

要实现代理，我们首先要创建一个类，并且让该类实现 InvocationHandler 接口，然后用 Proxy.newProxyInstance(loader, interfaces, h); 返回相关一个代理对象，h 便是实现了 InvocationHandler 接口的类。

接下来我们可以看一个简单的动态代理的例子

抽象主题角色

public interface Subject {
	public void doingProcedureA() ;
	public String doingProcedureB();
}

真实主题角色

public class RealSubject implements Subject {

	@Override
	public void doingProcedureA() {
		System.out.println("The RealSubject is doing Procedure A");

	}

	@Override
	public String doingProcedureB() {
		System.out.println("The RealSubject is doing Procedure B");
		return "The Result of Procedure B";
	}

}

动态代理的处理器

public class DynamicProxyHandller implements InvocationHandler {
	
	private Object obj;
	
	public DynamicProxyHandller(Object obj) {
		this.obj = obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {	
		
		Object result = method.invoke(this.obj, args);
		return result;
	}
}

抽象动态代理对象

public class DynamicProxy {
	public static <T> T newProxy(ClassLoader loader,Class[] interfaces,InvocationHandler h) {
		return (T)Proxy.newProxyInstance(loader, interfaces, h);
	}
	
}

主题动态代理对象

public class SubjectDynamicProxy extends DynamicProxy{
	
	public static Subject newProxy(Subject subject) {
		ClassLoader loader = subject.getClass().getClassLoader();
		Class[] interfaces = subject.getClass().getInterfaces();
		InvocationHandler h = new DynamicProxyHandller(subject);
		return (Subject)newProxy(loader, interfaces, h);
	}
}

客户端调用演示

public class Client {
	public static void main(String[] args) {
		RealSubject real = new RealSubject();
		Subject proxy = SubjectDynamicProxy.newProxy(real);
		proxy.doingProcedureA();
		proxy.doingProcedureB();		
	}

}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021/01/06 ，如有侵权请联系 cloudcommunity@tencent.com 删除

网络安全