代理模式

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

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

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();		
    	}
    
    }

Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。

它的内容包括：

大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：

想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询

同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】即可免费领取。

阅读全文

Java 设计模式入门

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

代理模式

代理模式的种类

代理模式的简单示例

代理模式的优点

代理模式的扩展

1. 普通代理

2. 强制代理

3. 动态代理