设计模式——代理模式

已于 2023-07-08 11:32:49 修改
阅读量310 收藏
点赞数
分类专栏： 设计模式 文章标签： 代理模式
于 2023-07-07 14:42:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43975645/article/details/131596535
版权

代理模式（静态代理）

  1. 普通代理模式的核心就是，被代理对象和代理对象（共属一个接口），被代理对象要执行的操作由代理对象完成（此时被代理者需要手动new出来，再传递给代理者）。
  2. 普通代理模式还可以拓展，即调用时只见代理者而不见被代理者（更符合逻辑），被代理者的new由代理者完成。

普通代理 + 拓展

在这里插入图片描述

真实对象GamePlayer

public class GamePlayer implements IGamePlayer {
	private String name = "";
	// 通过构造函数传递名称
	public GamePlayer(String _name){
		this.name = _name;
	}

	public GamePlayer(IGamePlayer _gamePlayer,String _name){
		if (_gamePlayer == null) throw new RuntimeException("不能创建真实角色");
		else this.name = _name;
	}

	@Override
	public void login(String user, String password) {
		System.out.println("登录名为：" + user + "的用户" + this.name + "登录成功！");
	}

	@Override
	public void killBoss() {
		System.out.println(this.name + "打机械牛");
	}

	@Override
	public void upgrade() {
		System.out.println(this.name + "升了一级");
	}
}

代理对象

/**
 * 代练者
 */
public class GamePlayerProxy implements IGamePlayer {
	private IGamePlayer gamePlayer = null;

//    public GamePlayerProxy(IGamePlayer _gamePlayer){
//        this.gamePlayer = _gamePlayer;
//    }

	// 改动：不创建被代理对象，而直接创建代理对象，屏蔽了真实角色的变更对高层模型的影响
	public GamePlayerProxy(String name){
		try {
			gamePlayer = new GamePlayer(this,name);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void login(String user, String password) {
		this.gamePlayer.login(user, password);
	}
	@Override
	public void killBoss() {
		this.gamePlayer.killBoss();
	}
	@Override
	public void upgrade() {
		this.gamePlayer.killBoss();
	}
}

入口类

public class ProxyMain {
	public static void main(String[] args) {
		manual();   // 用户本人自己操作
		proxy();    // 代练操作
	}

	// 代练操作
	public static void proxy(){
//        GamePlayer player = new GamePlayer("Devilvan");
//        GamePlayerProxy player = new GamePlayerProxy(player);
		// 改动：不创建被代理对象，而直接创建代理对象，屏蔽了真实角色的变更对高层模型的影响
		GamePlayerProxy playerProxy = new GamePlayerProxy("Devilvan");
		playerProxy.login("Devilvan","123456");
		playerProxy.killBoss();
		playerProxy.upgrade();
	}

	// 用户本人自己操作
	public static void manual(){
		GamePlayerProxy player = new GamePlayerProxy("Devilvan");
		player.login("Devilvan","123456");
		player.killBoss();
		player.upgrade();
	}
}

结果

在这里插入图片描述

代理模式（强制代理）

  1. 必须通过真实角色获取代理角色才可以访问
  2. 例如：A找B办事，但是B让A去找代理人C，即A必须找到B指定的C才行。不经过B或不找C而去找其他代理D也是不行的

强制代理

接口

/**
 * 玩家接口
 */
public interface IGamePlayer2 {
	// 登录游戏
	public void login(String user,String password);
	// 打怪
	public void killBoss();
	// 升级
	public void upgrade();
	// 每个对象都可以获取自己指定的代理对象
	public IGamePlayer2 getProxy();
}

真实角色

public class GamePlayer2 implements IGamePlayer2 {
	private String name = "";
	// 我指定的代理对象
	private IGamePlayer2 proxy = null;

	public GamePlayer2(String name){
		this.name = name;
	}


	// 获取代理对象
	public IGamePlayer2 getProxy(){
		this.proxy = new GamePlayerProxy2(this);
		return this.proxy;
	}

	private boolean isProxy(){
		return this.proxy != null;
	}

	@Override
	public void login(String user, String password) {
		if (isProxy()){
			System.out.println("登录名为：" + user + "的用户" + this.name + "登录成功！");
		} else {
			System.out.println("请使用指定的代理服务器");
		}
	}

	@Override
	public void killBoss() {
		if (isProxy()){
			System.out.println(this.name + "打机械牛");
		} else {
			System.out.println("请使用指定的代理服务器");
		}
	}

	@Override
	public void upgrade() {
		if (isProxy()){
			System.out.println(this.name + "升了一级");
		} else {
			System.out.println("请使用指定的代理服务器");
		}
	}
}

代理对象

public class GamePlayerProxy2 implements IGamePlayer2 {
	private IGamePlayer2 gamePlayer = null;

	public GamePlayerProxy2(IGamePlayer2 _gamePlayer){
		this.gamePlayer = _gamePlayer;
	}

	@Override
	public IGamePlayer2 getProxy() {
		return this;
	}

	@Override
	public void login(String user, String password) {
		this.gamePlayer.login(user, password);
	}
	@Override
	public void killBoss() {
		this.gamePlayer.killBoss();
	}

	@Override
	public void upgrade() {
		this.gamePlayer.upgrade();
	}
}

入口类

public class Proxy2Main {
	public static void main(String[] args) {
		visitReal();
		visitProxy();
		forceProxy();
	}

	// 强制代理
	// 结果：成功
	public static void forceProxy(){
		IGamePlayer2 evad = new GamePlayer2("Evad").getProxy();
		evad.login("Evad","loop");
		evad.killBoss();
		evad.upgrade();
	}

	// 直接访问代理类
	// 结果：被拦截
	public static void visitProxy(){
		GamePlayerProxy2 lisi = new GamePlayerProxy2(new GamePlayer2("Lisi"));
		lisi.login("lisi","123124");
		lisi.killBoss();
		lisi.upgrade();
	}

	// 直接访问真实角色
	// 结果：被拦截
	public static void visitReal(){
		GamePlayer2 zs = new GamePlayer2("张三");
		zs.login("张三","233939");
		zs.killBoss();
		zs.upgrade();
	}
}

结果

在这里插入图片描述

代理模式（代理的个性）

  1. 代理类除了实现与真实对象相同的接口外，还能实现其他的业务（接口），满足更多的需求

代理的个性

代理类个性接口

// 代理的个性
public interface IProxy {
	// 计算费用
	public void count();
}

代理类

public class GamePlayerProxy2 implements IGamePlayer2, IProxy {
	private IGamePlayer2 gamePlayer = null;

	public GamePlayerProxy2(IGamePlayer2 _gamePlayer){
		this.gamePlayer = _gamePlayer;
	}

	@Override
	public IGamePlayer2 getProxy() {
		return this;
	}

	@Override
	public void login(String user, String password) {
		this.gamePlayer.login(user, password);
	}
	@Override
	public void killBoss() {
		this.gamePlayer.killBoss();
	}

	@Override
	public void upgrade() {
		this.gamePlayer.upgrade();
		// 代理的个性，升级需要收费
		this.count();
	}

	@Override
	public void count() {
		System.out.println("升一级+5元");
	}
}

代理模式（动态代理）

  1. 动态代理在实现阶段不用关心代理对象是谁，而在运行阶段才指定代理的是哪个对象
  2. 动态代理需要实现InvocationHandler接口，作用相当于代理类

动态代理

代理类

/**
 * 动态代理，必须实现InvocationHandler接口
 */
public class GamePlayInvocationHandler implements InvocationHandler {
	// 被代理者
	Class<?> clz = null;
	// 被代理的实例
	Object obj = null;

	public GamePlayInvocationHandler(Object _obj){
		this.obj = _obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result = method.invoke(obj, args);
		// （AOP实现通知）如果是登录方法，则发送信息
		if (method.getName().equalsIgnoreCase("login")){
			System.out.println("有人在使用我的账号！");
		}
		return result;
	}
}

入口类

public class InvocationHandlerMain {
	public static void main(String[] args) {
		GamePlayer player = new GamePlayer("Van DarkHomle");
		GamePlayInvocationHandler handler = new GamePlayInvocationHandler(player);
		ClassLoader cl = player.getClass().getClassLoader();
		IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(cl, new Class[]{IGamePlayer.class}, handler);
		proxy.login("Van DarkHomle","What you see");
		proxy.killBoss();
		proxy.upgrade();
	}
}

结果

在这里插入图片描述

代理模式（动态代理通用模型）

  1. 核心部分为自定义的Handler、Proxy和通知
  2. 其中proxy还可以根据业务需要进行定制

动态代理通用模型

在这里插入图片描述

Handler

public class MyInvocationHandler implements InvocationHandler {
	private Object target = null;
	public MyInvocationHandler(Object _obj){
		this.target = _obj;
	}

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

Proxy及其子类

public class DynamicProxy<T> {
	public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {
		// 寻找JoinPoint连接点，AOP框架使用元数据定义
		(new BeforeAdvice()).exec();
		return (T) Proxy.newProxyInstance(loader, interfaces, h);
	}
}

public class SubjectDynamicProxy extends DynamicProxy{
	public static <T> T newProxyInstance(Subject subject){
		ClassLoader classLoader = subject.getClass().getClassLoader();
		Class<?>[] interfaces = subject.getClass().getInterfaces();
		InvocationHandler handler = new MyInvocationHandler(subject);
		return newProxyInstance(classLoader,interfaces,handler);
	}
}

业务类（抽象主题）及其实现类

/**
 * 抽象主题
 */
public interface Subject {
	// 业务操作
	public void doSomething(String str);
}

public class RealSubject implements Subject {
	@Override
	public void doSomething(String str) {
		System.out.println("do something ---------> " + str);
	}
}

AOP通知类及其实现类

public interface IAdvice {
	// 通知只有一个方法，执行
	public void exec();
}

public class BeforeAdvice implements IAdvice {
	@Override
	public void exec() {
		System.out.println("这里是前置通知");
	}
}

入口类

public class GeneralDynamicProxyMain {
	public static void main(String[] args) {
		Subject subject = new RealSubject();
		InvocationHandler handler = new MyInvocationHandler(subject);
		// 定义主题的代理
		Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), handler);
		// 代理行为
		proxy.doSomething("Finish..");
		System.out.println("------------具体业务的动态代理------------");
		Subject proxy2 = SubjectDynamicProxy.<Subject>newProxyInstance(subject);
		proxy2.doSomething("Finish2...");
	}
}

结果

在这里插入图片描述

加把劲骑士RideOn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java设计模式——代理模式
u014627852的博客
06-27 637
代理模式(Proxy)基本介绍 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象 代理模式有不同的形式,主要有三种静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴)。 代理模式示意图 静态代理 静态代理在使用时,需要定义接口
C++设计模式——代理模式(Proxy Pattern)
leonardohaig的博客
09-20 1558
C++设计模式——代理模式(Proxy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——代理模式(Proxy Pattern)目录定义代码示例总结优缺点对比参考资料 定义 The proxy design pattern allows you to provide an interface to other objects by creating a wrapper class as the proxy. The wrapper class, which is the pr
设计模式实现——代理模式
10-03
**设计模式实现——代理模式** 在软件工程中，设计模式是一种通用可重用的解决方案，它描述了在特定上下文中经常出现的问题以及该问题的解决方案。代理模式是设计模式的一种，它提供了一种对目标对象的间接访问方式...
Java设计模式——代理设计模式（静态代理和动态代理）
04-15
在Java编程中，设计模式是一种解决常见问题的模板或最佳实践，它可以帮助开发者编写更加灵活、可维护和可扩展的代码。代理设计模式是其中的一种，它的主要作用是在...在实际开发中，应根据项目需求选择合适的代理模式。
设计模式——刘伟
03-15
6. **代理模式**：为其他对象提供一种代理以控制对该对象的访问。代理可以在目标对象前增加额外的功能，如缓存、日志记录、事务控制等。 7. **建造者模式**：将一个复杂对象的构建与其表示分离，使得同样的构建过程...
浅析Java设计模式【3】——代理.pdf
07-27
### 浅析Java设计模式【3】——代理 #### 一、代理模式概述 代理模式是一种行为型设计模式，主要用于在客户端与目标对象之间起到一个中介的作用，通过代理对象来控制对目标对象的访问。代理模式的核心在于它可以...
动态代理设计模式-源码
04-10
动态代理设计模式是一种在运行时创建对象代理的技术，它允许我们为现有的对象提供额外的功能，而无需修改原对象的代码。这种模式的核心是接口和代理类，通过接口，代理类可以与原对象进行通信，同时在代理类中添加...
详解ES6中的代理模式——Proxy
11-27
代理模式（英语：Proxy Pattern）是程序设计中的一种设计模式。 所谓的代理者是指一个类别可以作为其它东西的接口。代理者可以作任何东西的接口：网络连接、内存中的大对象、文件或其它昂贵或无法复制的资源。 著名...
基于Java的设计模式-代理模式demo的实现（高分课设）
最新发布
05-29
基于Java的设计模式——代理模式demo的实现（高分课设）个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用...
Python设计模式之代理模式实例详解
12-25
设计模式——代理模式 代理模式(Proxy Pattern):为其他对象提供一种代理以控制对这个对象的访问 实现:戴励 替 卓贾易 送礼物给 娇娇 模型: #公共接口类 class InterFace: def request(self): pass #真实类 cla
设计模式——装饰模式
03-31
装饰模式是一种设计模式...通过阅读和理解《设计模式：可复用面向对象软件的基础》等经典书籍，以及像博客“设计模式——装饰模式”这样的在线资源，我们可以深入掌握并灵活运用装饰模式，提高代码的可维护性和扩展性。
Java与模式——源码
01-15
《Java与模式——源码》这个主题涉及到的是Java编程语言中的设计模式应用，以及如何通过源代码来理解和学习这些模式。设计模式是软件工程中的一种最佳实践，它们是解决常见问题的经验总结，使得代码更易读、易维护、...
设计模式之美——教你写出高质量代码
04-10
"设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式，从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助，也是职场发展中的必备技能，无论你使用哪种开发语言。 设计...
设计模式.docx
03-08
本文将深入探讨设计模式的基本概念，并详细介绍三种主要的设计模式分类——创建型模式、结构型模式以及行为型模式。 ### 创建型模式 创建型模式主要用于对象的创建过程，旨在通过不同的方式控制对象的创建过程，...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
"设计模式——可复用面向对象软件的基础
2001年6月25日，冯铁发表了《设计模式——可复用面向对象软件的基础》，详细介绍了四种设计模式。这四种设计模式分别是创建型模式、结构型模式、行为型模式和并发模式。每种设计模式都有其固定的模式名、问题、解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

加把劲骑士RideOn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值