设计模式12--代理模式（Proxy）

最新推荐文章于 2024-04-21 16:56:53 发布
最新推荐文章于 2024-04-21 16:56:53 发布
阅读量546 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shixin747/article/details/18699161
版权

代理模式的本质：控制对象访问

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

1 虚代理：根据需要来创建开销很大的对象，改对象值有在需要的时候才会被真正创建。

package com;

public interface UserModelApi {

	public String getUserId();
	public void setUserId(String userId);
	public String getName();
	public void setName(String name);
	public String getDepId();
	public void setDepId(String depId);
	public String getSex();
	public void setSex(String sex);
	public String getId();
	public void setId(String id);
}
package com.impl;

import com.UserModelApi;

public class UserModel implements UserModelApi{
	
	private String userId;
	private String name;
	private String depId;
	private String sex;
	private String id;
	
	@Override
	public String getUserId() {
		return userId;
	}
	@Override
	public void setUserId(String userId) {
		this.userId = userId;
	}
	@Override
	public String getName() {
		return name;
	}
	@Override
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String getDepId() {
		return depId;
	}
	@Override
	public void setDepId(String depId) {
		this.depId = depId;
	}
	@Override
	public String getSex() {
		return sex;
	}
	@Override
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String getId() {
		return id;
	}
	@Override
	public void setId(String id) {
		this.id = id;
		
	}	
}

package com.impl;

import com.UserModelApi;

public class Proxy implements UserModelApi {

	private UserModel realSubject = null;
	private boolean loaded = false;

	public Proxy(UserModel realSubject) {
		this.realSubject = realSubject;
	}

	@Override
	public String getUserId() {
		return realSubject.getUserId();
	}

	@Override
	public String getName() {
		return realSubject.getName();
	}

	@Override
	public String getDepId() {
		return realSubject.getDepId();
	}

	@Override
	public String getSex() {
		if (!loaded) {
			reload();
			loaded = true;
		}
		return realSubject.getSex();
	}

	@Override
	public String getId() {
		if (!loaded) {
			reload();
			loaded = true;
		}
		return realSubject.getId();
	}

	@Override
	public void setDepId(String depId) {
		realSubject.setDepId(depId);
	}

	@Override
	public void setName(String name) {
		realSubject.setName(name);

	}

	@Override
	public void setSex(String sex) {
		realSubject.setSex(sex);

	}

	@Override
	public void setUserId(String userId) {
		realSubject.setUserId(userId);

	}

	@Override
	public void setId(String id) {
		realSubject.setId(id);
	}

	private void reload() {
		// 模拟数据库查询过程，字段很多时更有价值
		System.out.println("reload~~~~");
		this.setSex("男");
		this.setId("210782XXXXXXXX1234");
	}

	public void showSimpleInfo() {
		System.out.println("DepId = " + this.getDepId() + ",UserId = "
				+ this.getUserId() + ",name = " + this.getName());
	}

	public void showAllInfo() {
		System.out.println("DepId = " + this.getDepId() + ",UserId = "
				+ this.getUserId() + ",Name = " + this.getName() + ",Sex = "
				+ this.getSex() + ",Id = " + this.getId());
	}
}

package com;

import java.util.ArrayList;
import java.util.List;

import com.impl.Proxy;
import com.impl.UserModel;

public class UserManager {
	public List getUsersByDepId(String depId){
		List usersList = new ArrayList();
		//模拟数据库查询过程，只初始化depId，userId，name
		Proxy userModel1 = new Proxy(new UserModel());
		userModel1.setDepId("0103");
		userModel1.setUserId("0103001");
		userModel1.setName("SHIXIN747");
		usersList.add(userModel1);
		Proxy userModel2 = new Proxy(new UserModel());
		userModel2.setDepId("0103");
		userModel2.setUserId("0103002");
		userModel2.setName("AXUE630");
		usersList.add(userModel2);
		Proxy userModel3 = new Proxy(new UserModel());
		userModel3.setDepId("0103");
		userModel3.setUserId("0103003");
		userModel3.setName("YUANJIA258");
		usersList.add(userModel3);
		return usersList;	
	}
}

import java.util.List;

import com.UserManager;
import com.impl.Proxy;

public class Client {
	public static void main(String[] args) {
		UserManager userManager = new UserManager();
		List<Proxy> usersList = userManager.getUsersByDepId("0103");
		
		for(Proxy userproxy : usersList){
			userproxy.showSimpleInfo();
		}
		
		for(Proxy userproxy : usersList){
			userproxy.showAllInfo();
		}
	}
}

2 保护代理：控制对原始对象的访问，如果有需要，可以给不同的用户提供不同的访问权限，以控制他们对原始对象的访问。

package com;

public interface OrderApi {

	String getProductName();
	void setProductName(String productName,String user);//此处参数不得不加了个user
	int getOrderNum();
	void setOrderNum(int orderNum,String user);//此处参数不得不加了个user
	String getOrderUser();
	void setOrderUser(String orderUser,String user);//此处参数不得不加了个user
	
}
package com.impl;

import com.OrderApi;

public class Order implements OrderApi{
	
	private String productName;
	private int orderNum;
	private String orderUser;
	
	public Order(String productName, int orderNum, String orderUser) {
		super();
		this.productName = productName;
		this.orderNum = orderNum;
		this.orderUser = orderUser;
	}

	@Override
	public String getProductName() {
		return productName;
	}
	
	@Override
	public void setProductName(String productName,String user) {
		this.productName = productName;
	}
	
	@Override
	public int getOrderNum() {
		return orderNum;
	}
	
	@Override
	public void setOrderNum(int orderNum,String user) {
		this.orderNum = orderNum;
	}
	
	@Override
	public String getOrderUser() {
		return orderUser;
	}
	
	@Override
	public void setOrderUser(String orderUser,String user) {
		this.orderUser = orderUser;
	}
}
package com.impl;

import com.OrderApi;

public class OrderProxy implements OrderApi {

	private Order order = null;

	public OrderProxy(Order order) {
		this.order = order;
	}

	public int getOrderNum() {
		return order.getOrderNum();
	}

	@Override
	public String getOrderUser() {
		return order.getOrderUser();
	}

	@Override
	public String getProductName() {
		return order.getProductName();
	}

	@Override
	public void setOrderNum(int orderNum, String user) {
		if (user.equals(order.getOrderUser())) {
			order.setOrderNum(orderNum, user);
		} else {
			System.out.println("对不起,您无权限进行此操作");
		}

	}

	@Override
	public void setOrderUser(String orderUser, String user) {
		if (user.equals(order.getOrderUser())) {
			order.setOrderUser(orderUser, user);
		} else {
			System.out.println("对不起,您无权限进行此操作");
		}

	}

	@Override
	public void setProductName(String productName, String user) {
		if (user.equals(order.getOrderUser())) {
			order.setProductName(productName, user);
		} else {
			System.out.println("对不起,您无权限进行此操作");
		}
	}

	public String toString() {
		return "productName = " + this.getProductName() + ",orderUser = "
				+ this.getOrderUser() + ",orderNum = " + this.getOrderNum();
	}

}

import com.OrderApi;
import com.impl.Order;
import com.impl.OrderProxy;

public class Client {
	public static void main(String[] args) {
		OrderApi order = new OrderProxy(new Order("宝马",5,"SHIXIN747"));
		System.out.println(order);
		order.setOrderNum(10, "AXUE630");
		order.setOrderNum(10, "SHIXIN747");
		System.out.println(order);
	}
}

3 Java的动态代理

package com;

public interface OrderApi {

	String getProductName();
	void setProductName(String productName,String user);//此处参数不得不加了个user
	int getOrderNum();
	void setOrderNum(int orderNum,String user);//此处参数不得不加了个user
	String getOrderUser();
	void setOrderUser(String orderUser,String user);//此处参数不得不加了个user
	
}


package com.impl;

import com.OrderApi;

public class Order implements OrderApi{
	
	private String productName;
	private int orderNum;
	private String orderUser;
	
	public Order(String productName, int orderNum, String orderUser) {
		super();
		this.productName = productName;
		this.orderNum = orderNum;
		this.orderUser = orderUser;
	}

	@Override
	public String getProductName() {
		return productName;
	}
	
	@Override
	public void setProductName(String productName,String user) {
		this.productName = productName;
	}
	
	@Override
	public int getOrderNum() {
		return orderNum;
	}
	
	@Override
	public void setOrderNum(int orderNum,String user) {
		this.orderNum = orderNum;
	}
	
	@Override
	public String getOrderUser() {
		return orderUser;
	}
	
	@Override
	public void setOrderUser(String orderUser,String user) {
		this.orderUser = orderUser;
	}
	
	public String toString() {  
        return "productName = " + this.getProductName() + ",orderUser = "  
                + this.getOrderUser() + ",orderNum = " + this.getOrderNum();  
    }  

}

package com.impl;

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

import com.OrderApi;

public class DynamicProxy implements InvocationHandler {

	private Order order = null;

	public OrderApi getProxyInterface(Order order) {
		// 设置被代理的对象，好方便invoke里面的操作
		this.order = order;
		// 把真正的订单对象和动态代理关联起来
		OrderApi orderApi = (OrderApi) Proxy.newProxyInstance(order.getClass()
				.getClassLoader(), order.getClass().getInterfaces(), this);
		return orderApi;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		//如果是调用setter方法就需要检查权限
		if(method.getName().startsWith("set")){
			if(order.getOrderUser() != null && order.getOrderUser().equals(args[1])){
				return method.invoke(order, args);
			}else{
				System.out.println("对不起，" + args[1] + ",你无权修改本订单的数据");
			}
		}else{
			return method.invoke(order, args);
		}
		return null;
	}
}

import com.OrderApi;
import com.impl.DynamicProxy;
import com.impl.Order;

public class Client {
	public static void main(String[] args) {
		DynamicProxy DynamicProxy = new DynamicProxy();
		Order order = new Order("奔驰",20,"SHIXIN747");
		System.out.println(order);
		OrderApi orderApi = DynamicProxy.getProxyInterface(order);
		orderApi.setOrderNum(30, "AXUE630");
		orderApi.setOrderNum(30, "SHIXIN747");
		System.out.println(order);
	}
}












shixin747
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-结构型模式-代理模式
06-12
代理模式是一种在面向对象设计中广泛应用的结构型设计模式，它提供了一种对目标对象进行间接访问的方式，使得客户端可以通过代理对象与真实对象进行交互，而无需直接接触真实对象。这样做的好处包括增加灵活性、控制...
java常用设计模式-代理模式
08-26
代理模式（Proxy Pattern）是一种常用的设计模式，提供了间接访问目标对象的一种方式，即通过代理对象访问目标对象。这样做的好处是，可以在不改变原有目标对象的基础上，对目标对象增加额外的扩展功能。 代理模式...
13代理模式
洛兰相遇
12-31 211
代理模式 笔记 ①定义： 为其他对象提供一种代理以控制对这个对象的访问。 ②代码： //抽象的父类 public abstract class Subject{ public abstract void Request(); } //真实类 public class RealSubject extends Subject{ //覆盖父类的抽象方法 @Override
设计模式 —— 代理模式（Proxy Pattern）
IT小小鸟～～
06-02 853
代理模式（Proxy Pattern）概念： 定义：代理模式 为另一个对象提供一个替身或占位符以控制这个对象的访问。 代理模式很好理解，在生活中也很常见。举个简单的例子，我们自己能做很多事情（动作），比如写作业，出去玩等。当我们和父母在家的时候，同学叫我们出去玩，父母先收到消息，然后忽略掉出去玩的信息。如果同学叫我们去写作业，父母接收到后在传达给我们。此时父母就是我们的代理，并且对我们 资源 进
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
《设计模式系列》- 代理模式
敖丙
07-05 9781
阿里云一面，代理模式问了半小时
设计模式学习（八）：Proxy代理模式
m0_49499183的博客
01-17 1314
Proxy是“代理人”的意思，它指的是代替别人进行工作的人。当不一定需要本人亲自进行工作时，就可以寻找代理人去完成工作。但代理人毕竟只是代理人，能代替本人做的事情终究是有限的。因此，当代理人遇到无法自己解决的事情时就会去找本人解决该问题。在面向对象编程中，“本人”和“代理人”都是对象。如果，就将其交给“代理人”对象负责。用一句话概况：只在必要时生成实例。
java设计模式---代理模式详解
zhenghuishengq的博客
09-10 1693
代理模式超级详解
设计模式- 代理模式（Proxy Pattern）结构|原理|优缺点|场景|示例
最新发布
piaomiao_的博客
04-21 1237
代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象（被代理对象）提供一个代理对象，并由代理对象控制对被代理对象的访问。代理模式通过引入代理对象来间接访问目标对象，从而实现对目标对象的增强、控制访问权限、远程访问等功能。代理模式的关键在于代理类与目标类具有相同的接口，客户端可以透明地使用代理对象代替目标对象。
设计模式第4讲——代理模式（Proxy）
让~学习~成为一种习惯（橡 皮 人の技术博客）
05-31 6625
代理模式属于结构型设计模式。一、什么是代理模式二、分类 三、特点 四、应用场景4.1 生活场景4.2 Java场景 五、代码实现5.0 代码结构5.1 静态代理5.2 JDK动态代理5.3 Cglib代理 六、总结
Java设计模式---单例 工厂 代理模式
m0_69005620的博客
01-23 1733
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要解决：一个全局使用的类频繁地创建与销毁所造成的资源浪费问题。何时使用：当您想控制实例数目，节省系统资源的时候。如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。关键代码：构造函数是私有的。简单工厂模式（Simple Factory Pattern）意图：提供一个用于创建对象的接口，让子类决定实例化哪一个类。结构：由一个工厂类负责创建不同类的产品对象。// 简单工厂角色} else {// 抽象产品角色。
ABAP设计模式之---“代理模式 (Proxy Pattern)”
SAP领域技术博客
12-10 1138
1. 目的 为其他对象提供一种代理，以控制对这个对象的访问。 2. 使用场景 代理模式气死就是在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。 例如： 远程代理：也即为一个对象在不同地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。 虚拟代理：根据需要创建开销很大的对象。可以通过虚拟代理来存放实例化需要很长时间的真实对象。 安全代理： 用来控制真实对象的访问权限。 智能索引：在调用真实对象时，代理处理一些额外的工作。 3. 类图 4. 代码实现 *
读《大话设计模式》－代理模式(proxy)
02-03
代理模式(proxy)为其他对象提供一个代理以控制对这个对象的访问。结构图//Subject类，定义了RealSubjext和Proxy的公共接口，这样就在任何使用RealSubject的地方可以使用ProxyclassSubject{public:virtualvoidRequest...
动态代理设计模式-源码
04-10
动态代理设计模式是一种在运行时创建对象代理的技术，它允许我们为现有的对象提供额外的功能，而无需修改原对象的代码。这种模式的核心是接口和代理类，通过接口，代理类可以与原对象进行通信，同时在代理类中添加...
设计模式之代理模式proxy.zip
12-29
代理模式是一种常用的设计模式，它在软件开发中扮演着重要的角色。代理模式允许我们为一个对象创建一个代理，这个代理对象在客户端和目标对象之间起到中介的作用，可以增强或控制对目标对象的访问。代理模式的主要...
设计模式14--命令模式（Command）
石新同学
05-21 611
命令模式的本质：封装请求
设计模式4--模板方法模式（Template Method）
石新同学
11-28 600
package com; public class LoginModel { private String loginId; private String pwd; public String getLoginId() { return loginId; } public void setLoginId(String loginId) { this.login
设计模式2--工厂方法模式（Factory Method）
石新同学
11-27 584
package com; public interface Api { void opreation(String s); }   package com.impl; import com.Api; public class ImplA implements Api { @Override public void opreation(String s) { S
设计模式4.1--回调技术实现模板方法模式
石新同学
12-25 580
package com; /* * 模板操作类 */ public class LoginTemplate { //骨架 public boolean login(LoginModel inputUser,LoginCallback callback){ LoginModel dbuser = callback.findLoginUser(inputUser.getLog
动态代理设计模式解析：实现与应用
"动态代理设计模式详解.pdf" 动态代理设计模式是一种编程技巧，它允许在运行时创建代理对象，该对象可以代表或“代理”其他对象执行某些操作。代理模式的核心思想是为原始对象提供一个代理，以便在调用真实对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值