Java设计模式（七）—代理模式、模板方法模式、命令模式

东风难破

于 2021-08-02 10:25:37 发布

阅读量301

点赞数

分类专栏： java 设计模式

本文链接：https://blog.csdn.net/qq_37965402/article/details/119215595

版权

java 同时被 2 个专栏收录

22 篇文章 2 订阅

订阅专栏

设计模式

10 篇文章 1 订阅

订阅专栏

本章目录标题

第15章代理模式
第16章模板方法模式
第17章命令模式

第15章代理模式

15.1 代理模式(Proxy)

基本介绍
（1）代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
（2）被代理的对象：远程对象、创建开销大的对象、需要安全控制的对象
（3）代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK 代理、接口代理)和 Cglib 代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴) 。
类图

15.2 静态代理

基本介绍
静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类
应用实例
具体要求
（1）定义一个接口:ITeacherDao
（2）目标对象 TeacherDAO 实现接口 ITeacherDAO
（3）使用静态代理方式,就需要在代理对象 TeacherDAOProxy 中也实现ITeacherDAO
（4）调用的时候通过调用代理对象的方法来调用目标对象.
特别提醒：代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法。
类图
代码实现
（1）接口：ITeacherDao

public interface ITeacherDao {
	void teach(); // 授课的方法
}

（2）具体实现类：

public class TeacherDao implements ITeacherDao {
	@Override
	public void teach() {
		System.out.println(" 老师授课中  。。。。。");
	}
}

（3）代理

//代理对象,静态代理
public class TeacherDaoProxy implements ITeacherDao{
	private ITeacherDao target; // 目标对象，通过接口来聚合
	//构造器
	public TeacherDaoProxy(ITeacherDao target) {
		this.target = target;
	}
	@Override
	public void teach() {
		System.out.println("开始代理  完成某些操作。。。。。 ");//方法
		target.teach();
		System.out.println("提交。。。。。");//方法
	}
}

（4）客户端

public class Client {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建目标对象(被代理对象)
		TeacherDao teacherDao = new TeacherDao();
		//创建代理对象, 同时将被代理对象传递给代理对象
		TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
		//通过代理对象，调用到被代理对象的方法	//即：执行的是代理对象的方法，代理对象再去调用目标对象的方法 
		teacherDaoProxy.teach();
	}
}

静态代理的优缺点
（1）优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
（2）缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类 ；一旦接口增加方法,目标对象与代理对象都要维护

15.3 动态代理

基本介绍
（1）代理对象不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
（2）代理对象的生成，是利用 JDK 的 API，动态的在内存中构建代理对象
（3）动态代理也叫做：JDK 代理、接口代理
动态代理在内存中构建代理对象的说明
（1）代理类所在包:java.lang.reflect.Proxy
（2）JDK 实现代理只需要使用 newProxyInstance 方法,但是该方法需要接收三个参数,完整的写法是:static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
应用案例
将前面的静态代理改进成动态代理模式(即：JDK 代理模式)
类图
代码实现
（1）接口

public interface ITeacherDao {
	void teach(); // 授课方法
	void sayHello(String name);
}

（2）接口实现类

public class TeacherDao implements ITeacherDao {
	@Override
	public void teach() {
		System.out.println(" 老师授课中.... ");
	}
	@Override
	public void sayHello(String name) {
		System.out.println("hello " + name);
	}
}

（3）代理工厂

public class ProxyFactory {
	//维护一个目标对象 , Object
	private Object target;
	//构造器 ， 对target 进行初始化
	public ProxyFactory(Object target) {
		this.target = target;
	} 
	//给目标对象 生成一个代理对象
	public Object getProxyInstance() {
		//说明
		/*
		 *  public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
                                          
            //1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
            //2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
            //3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入
		 */
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(), 
				new InvocationHandler() {		//重写了invocationHandler
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						System.out.println("JDK代理开始~~");
						//反射机制调用目标对象的方法
						Object returnVal = method.invoke(target, args);
						System.out.println("JDK代理提交");
						return returnVal;
					}
				}); 
	}
}

（4）客户端

public class Client {
	public static void main(String[] args) {
		//创建目标对象
		ITeacherDao target = new TeacherDao();
		
		//给目标对象，创建代理对象, 可以转成 ITeacherDao
		ITeacherDao proxyInstance = (ITeacherDao)new ProxyFactory(target).getProxyInstance();
	
		// proxyInstance=class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
		System.out.println("proxyInstance=" + proxyInstance.getClass());
		
		//通过代理对象，调用目标对象的方法
		//proxyInstance.teach();
		proxyInstance.sayHello(" tom ");
	}
}

15.4 Cglib 代理（子类代理）

基本介绍
（1）静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是 Cglib 代理
（2）Cglib 代理是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib 代理归属到动态代理。
（3）Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的框架使用,例如 Spring AOP，实现方法拦截
（4）在 AOP 编程中如何选择代理模式：
– 目标对象需要实现接口，用 JDK 代理
– 目标对象不需要实现接口，用 Cglib 代理
（5）Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类
实现步骤
（1）引入cglib的jar文件

（2）在内存中动态构建子类，注意代理的类不能为 final，否则报错 java.lang.IllegalArgumentException:
（3）目标对象的方法如果为 final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.
Cglib 代理模式应用实例
将前面的案例用 Cglib 代理模式实现
类图
cglib是基于拦截器的，所以需要实现MethodInterceptor接口
代码实现
（1）被代理类：TeacherDao

public class TeacherDao {
	public String teach() {
		System.out.println(" 老师授课中  ， 我是cglib代理，不需要实现接口 ");
		return "hello";
	}
}

（2）代理工厂：ProxyFactory类
需要实现接口：MethodInterceptor

public class ProxyFactory implements MethodInterceptor {
	//维护一个目标对象
	private Object target;
	
	//构造器，传入一个被代理的对象
	public ProxyFactory(Object target) {
		this.target = target;
	}

	//返回一个代理对象:  是 target 对象的代理对象
	public Object getProxyInstance() {
		//1. 创建一个工具类
		Enhancer enhancer = new Enhancer();
		//2. 设置父类
		enhancer.setSuperclass(target.getClass());
		//3. 设置回调函数
		enhancer.setCallback(this);
		//4. 创建子类对象，即代理对象
		return enhancer.create();
	}
	
	//重写  intercept 方法，会调用目标对象的方法
	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		System.out.println("Cglib代理模式 ~~ 开始");
		Object returnVal = method.invoke(target, args);
		System.out.println("Cglib代理模式 ~~ 提交");
		return returnVal;
	}
}

（3）客户端

public class Client {
	public static void main(String[] args) {
		//创建目标对象
		TeacherDao target = new TeacherDao();
		//获取到代理对象，并且将目标对象传递给代理对象
		TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();

		//执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
		String res = proxyInstance.teach();
		System.out.println("res=" + res);
	}
}

15.5 代理模式的变体

防火墙代理
内网通过代理穿透防火墙，实现对公网的访问。
缓存代理
比如：当请求图片文件等资源时，先到缓存代理取，如果取到资源则 ok,如果取不到资源，再到公网或者数据库取，然后缓存。
远程代理
远程对象的本地代表，通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息。
同步代理：主要使用在多线程编程中，完成多线程间同步工作
同步代理：主要使用在多线程编程中，完成多线程间同步工作

第16章模板方法模式

16.1 应用场景：豆浆制作

编写制作豆浆的程序，说明如下
（1）制作豆浆的流程选材—>添加配料—>浸泡—>放到豆浆机打碎
（2）通过添加不同的配料，可以制作出不同口味的豆浆
（3）选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
请使用模板方法模式完成 (说明：因为模板方法模式，比较简单，很容易就想到这个方案，因此就直接使用，不再使用传统的方案来引出模板方法模式 )

16.2 模板方法

基本介绍
（1）模板方法模式（Template Method Pattern），又叫模板模式(Template Pattern)，在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
（2）简单说，模板方法模式 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤
（3）这种类型的设计模式属于行为型模式。
类图

对原理类图的说明-即(模板方法模式的角色及职责)
（1） AbstractClass 抽象类， **类中实现了模板方法(**template)，定义了算法的骨架，具体子类需要去实现其它的抽象方法 operationr2,3,4
（2）ConcreteClass 实现抽象方法 operationr2,3,4, 以完成算法中特点子类的步骤
注意事项和细节
（1）基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改
（2）实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。
（3）既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。
（4）不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大
（5）一般模板方法都加上 final 关键字，防止子类重写模板方法.
（6）模板方法模式使用场景：当要完成在某个过程，该过程要执行一系列步骤，这一系列的步骤基本相同，但其个别步骤在实现时可能不同，通常考虑用模板方法模式来处理

16.3 模板模式应用案例：豆浆制作

类图
代码实现
（1）抽象豆浆模板

//抽象类，表示豆浆
public abstract class SoyaMilk {
	//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
	final void make() {
		select(); 
		addCondiments();
		soak();
		beat();
	}
	//选材料
	void select() {
		System.out.println("第一步：选择好的新鲜黄豆  ");
	}
	//添加不同的配料， 抽象方法, 子类具体实现
	abstract void addCondiments();
	//浸泡
	void soak() {
		System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
	}
	void beat() {
		System.out.println("第四步：黄豆和配料放到豆浆机去打碎  ");
	}
}

（2）实现类：红豆豆浆

public class RedBeanSoyaMilk extends SoyaMilk {
	@Override
	void addCondiments() {
		System.out.println(" 加入上好的红豆 ");
	}
}

（3）客户端

public class Client {

	public static void main(String[] args) {
		//制作红豆豆浆
		System.out.println("----制作红豆豆浆----");
		SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
		redBeanSoyaMilk.make();
		
		System.out.println("----制作花生豆浆----");
		SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
		peanutSoyaMilk.make();
	}
}

16.4 模板模式的钩子方法

在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。
还是用上面做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造
代码实现
（1）添加了钩子方法的模板方法


//抽象类，表示豆浆
public abstract class SoyaMilk {
	//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
	final void make() {
		select(); 
		if(customerWantCondiments()) {//利用钩子方法判断是否需要加入作料
			addCondiments();
		}
		soak();
		beat();
	}
	//选材料
	void select() {
		System.out.println("第一步：选择好的新鲜黄豆  ");
	}
	//添加不同的配料， 抽象方法, 子类具体实现
	abstract void addCondiments();
	//浸泡
	void soak() {
		System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
	}
	void beat() {
		System.out.println("第四步：黄豆和配料放到豆浆机去打碎  ");
	}
	//钩子方法，决定是否需要添加配料
	boolean customerWantCondiments() {
		return true;
	}
}

（2）纯豆浆

public class PureSoyaMilk extends SoyaMilk{
	@Override
	void addCondiments() {
		//空实现
	}
	
	@Override
	boolean customerWantCondiments() {
		return false;
	}
}

（3）客户端
public class Client {
public static void main(String[] args) {
System.out.println("----制作纯豆浆----");
SoyaMilk pureSoyaMilk = new PureSoyaMilk();
pureSoyaMilk.make();
}
}

16.5 模板模式在Spring 框架应用的源码分析

Spring IOC 容器初始化时运用到的模板方法模式
代码分析+角色分析+说明类图

第17章命令模式

17.1 应用场景：智能家居

在这里插入图片描述
（1）一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装 app 就可以控制对这些家电工作。
2) 这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个 App，分别控制，我们希望只要一个 app就可以控制全部智能家电。
3) 要实现一个 app 控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 app 调用，这时就可以考虑使用命令模式。
4) 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来.
5) 在我们的例子中，动作的请求者是手机 app，动作的执行者是每个厂商的一个家电产品

17.2 命令模式

基本介绍
（1）命令模式（Command Pattern）：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，
我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计
（2）命名模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。
（3）在命名模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命名)，同时命令模式也支持可撤销的操作。
（4）通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军（命令发布者）、士兵（命令的具体执行者）、命令(连接将军和士兵)。
Invoker 是调用者（将军），Receiver 是被调用者（士兵），MyCommand 是命令，实现了 Command 接口，持有接收对象
类图

对原理类图的说明-即(命名模式的角色及职责)
（1）Invoker 是调用者角色
（2）Command: 是命令角色，需要执行的所有命令都在这里，可以是接口或抽象类
（3）Receiver: 接受者角色，知道如何实施和执行一个请求相关的操作
（4）ConcreteCommand: 将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现 execute

17.3 命令模式应用案例：智能家居

效果图
类图：以电灯为例
代码实现
（1）命令接口

//创建命令接口
public interface Command {
	//执行动作(操作)
	public void execute();
	//撤销动作(操作)
	public void undo();
}

（2）LightOnCommand，实现电灯开：实现Command接口

public class LightOnCommand implements Command {
	//聚合LightReceiver
	LightReceiver light;
	
	//构造器
	public LightOnCommand(LightReceiver light) {
		super();
		this.light = light;
	}
	
	@Override
	public void execute() {
		// TODO Auto-generated method stub
		//调用接收者的方法
		light.on();
	}

	@Override
	public void undo() {
		// TODO Auto-generated method stub
		//调用接收者的方法
		light.off();
	}
}

辅助类：LightReceive类，以实现LightOnCommand

public class LightReceiver {
	public void on() {
		System.out.println(" 电灯打开了.. ");
	}
	public void off() {
		System.out.println(" 电灯关闭了.. ");
	}
}

（3）LightOffCommand类，实现电灯关

public class LightOffCommand implements Command {
	// 聚合LightReceiver
	LightReceiver light;
	// 构造器
	public LightOffCommand(LightReceiver light) {
		super();
		this.light = light;
	}
	@Override
	public void execute() {
		// 调用接收者的方法
		light.off();
	}
	@Override
	public void undo() {
		// 调用接收者的方法
		light.on();
	}
}

（4）空命令类

/**
 * 没有任何命令，即空执行: 用于初始化每个按钮, 当调用空命令时，对象什么都不做
 * 其实，这样是一种设计模式, 可以省掉对空判断
 */
public class NoCommand implements Command {
	@Override
	public void execute() {
	}
	@Override
	public void undo() {
	}
}

（5）遥控器类：RemoteController

public class RemoteController {
	// 开 按钮的命令数组
	Command[] onCommands;
	Command[] offCommands;
	// 执行撤销的命令
	Command undoCommand;

	// 构造器，完成对按钮初始化
	public RemoteController() {
		onCommands = new Command[5];
		offCommands = new Command[5];
		for (int i = 0; i < 5; i++) {	//依据遥控器而定，此处为五组开关
			onCommands[i] = new NoCommand();	//初始化为没有命令
			offCommands[i] = new NoCommand();
		}
	}
	
	// 给我们的按钮设置你需要的命令
	public void setCommand(int no, Command onCommand, Command offCommand) {
		onCommands[no] = onCommand;
		offCommands[no] = offCommand;
	}
	
	// 按下开按钮
	public void onButtonWasPushed(int no) { // no 0
		// 找到你按下的开的按钮， 并调用对应方法
		onCommands[no].execute();
		// 记录这次的操作，用于撤销
		undoCommand = onCommands[no];
	}

	// 按下开按钮
	public void offButtonWasPushed(int no) { // no 0
		// 找到你按下的关的按钮， 并调用对应方法
		offCommands[no].execute();
		// 记录这次的操作，用于撤销
		undoCommand = offCommands[no];
	}
	
	// 按下撤销按钮
	public void undoButtonWasPushed() {
		undoCommand.undo();
		//此处的undo应该是具体实现类LightOnCommand或者LightOffCommand按钮中的undo()方法
	}
}

（6）客户端

public class Client {
	public static void main(String[] args) {
		//使用命令设计模式，完成通过遥控器，对电灯的操作
		
		//创建电灯的对象(接受者)
		LightReceiver lightReceiver = new LightReceiver();
		
		//创建电灯相关的开关命令
		LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
		LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);
		
		//需要一个遥控器
		RemoteController remoteController = new RemoteController();
		
		//给我们的遥控器设置命令, 比如 no = 0 是电灯的开和关的操作
		remoteController.setCommand(0, lightOnCommand, lightOffCommand);
		
		System.out.println("--------按下灯的开按钮-----------");
		remoteController.onButtonWasPushed(0);
		System.out.println("--------按下灯的关按钮-----------");
		remoteController.offButtonWasPushed(0);
		System.out.println("--------按下撤销按钮-----------");
		remoteController.undoButtonWasPushed();
	}
}

17.4 命令模式在 Spring 框架 JdbcTemplate 应用的源码分析

在这里插入图片描述
（1）StatementCallback 接口 ,类似命令接口(Command)
（2）class QueryStatementCallback implements StatementCallback, SqlProvider , 匿名内部类，实现了命令接口，同时也充当命令接收者
（3）命令调用者是 JdbcTemplate , 其中 execute(StatementCallback action) 方法中，调用 action.doInStatement 方法. 不同的实现 StatementCallback 接口的对象，对应不同的 doInStatemnt 实现逻辑
（4）另外实现 StatementCallback 命令接口的子类还有 QueryStatementCallback、

17.5 命令模式的注意事项和细节

（1）将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的 execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。
（2）容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令
（3）容易实现对请求的撤销和重做
（4）命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在在使用的时候要注意
（5）空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。
（6）命令模式经典的应用场景：界面的一个按钮都是一条命令、模拟 CMD（DOS 命令）订单的撤销/恢复、触发-反馈机制

东风难破

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java设计模式（七）—代理模式、模板方法模式、命令模式

本章目录标题第15章代理模式15.1 代理模式(Proxy)15.2 静态代理15.3 动态代理15.4 Cglib 代理（子类代理）第15章代理模式15.1 代理模式(Proxy)基本介绍（1）代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象。这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。（2）被代理的对象：远程对象、创建开销大的对象、需要安全控制的对象（3）代理模式有不同的形式, 主要有三种静态代理、动态代
复制链接

扫一扫