设计模式之行为型设计模式

文章目录

• 委派模式（Delegate Pattern）
• • 委派模式模拟任务分配
  • 委派模式在JDK中的应用
  • 委派模式在Spring中的应用
  
  
• 模板方法（Template Method Pattern）
• • 模板方法模拟上班
  • 模板方法在 Spring 中的应用
  
  
• 策略模式（Strategy Pattern）
• • 策略模式实现购买商品使用不同的支付方式
  • 策略模式在JDK中的应用
  • 策略模式在Spring中的应用
  
  
• 责任链模式
• • 责任链模式实现登录校验
  • 责任链模式在Spring中的应用
  
  
• 迭代器模式

老板给项目经理下达一个任务，项目经理会根据情况分配不同的工作任务给每个员工，员工完成之后，项目经理再向老板汇报工作进度和任务。
如果要办一件事，不必自己处理，可以写一个授权委托书，授权他人代办事务。上面老板让项目经理完成一个任务，项目经理让下面的员工来办理。

应用场景：

1. 表现层和业务层解耦合
2. 协调多个服务之间的调用
3. 封装一层服务查找和调用

委派模式模拟任务分配

老板下达一个任务给项目经理，项目经理拆分不同任务给不同的员工，共同完成这个任务。

抽象出员工接口，并实现不同的员工。

public interface IEmployee {
void doing(String task);
}
public class EmployeeA implements IEmployee {
@Override
public void doing(String task) {
System.out.println("我是开发人员，开始做" + task + "工作");
}
}
public class EmployeeB implements IEmployee {
@Override
public void doing(String task) {
System.out.println("我是设计人员，开始做" + task + "工作");
}
}
public class Leader implements IEmployee {
private IEmployee employeeA = new EmployeeA();
private IEmployee employeeB = new EmployeeB();
// 项目经理就是拆分任务给不同的员工来完成
@Override
public void doing(String task) {
String[] taskSplit = task.split(",");
employeeA.doing(taskSplit[0]);
employeeA.doing(taskSplit[1]);
}
}


老板下达任务给项目经理。

public class Boss {
private Leader leader = new Leader();
public void command(String task){
leader.doing(task);
}
}
public class Test {
public static void main(String[] args) {
Boss boss = new Boss();
boss.command("开发,设计");
}
}


运行结果：

我是开发人员，开始做开发工作
我是开发人员，开始做设计工作


委派模式在JDK中的应用

JVM 在加载类时使用了双亲委派机制。
一个加载器在加载类时，先把这个类委托给父类加载器去执行，如果父类加载器执行成功返回，如果父类加载器无法加载，则子加载器会自己去执行加载。

委派模式在Spring中的应用

DispatcherServlet 使用了委派模式。

比如有三个业务类：MemberController、OrderController、ProductController。

所有请求都经过 DispatchServlet 进行转发。
DispatcherServlet 会根据请求 url 来获取相应的业务类后，再调用。

完成一个任务有固定的流程，抽象出固定流程的步骤，具体步骤让子类去具体实现完成。

模板方法模拟上班

公司的上班情况，简单描述一下：公司有开发、测试、HR、项目经理等人，下面使用模版方法模式，记录下所有人员的上班情况。

抽象出工作。

public abstract class Worker {
// 都是先进公司，然后工作，最后离开公司
public final void doing() {
enterCompany();
work();
exitCompany();
}
// 工作任务是不同的，让子类去实现
public abstract void work();
public void enterCompany() {
System.out.println("进入公司");
}
// 离开公司
public void exitCompany() {
System.out.println("离开公司");
}
}
public class HRWorker extends Worker{
@Override
public void work() {
System.out.println("看简历");
}
}
public class ITWorker extends Worker {
@Override
public void work() {
System.out.println("写代码");
}
}
public class Test {
public static void main(String[] args) {
Worker itWorker = new ITWorker();
itWorker.doing();
Worker hrWorker = new HRWorker();
hrWorker.doing();
}
}


运行结果：

进入公司
写代码
离开公司
进入公司
看简历
离开公司


模板方法在 Spring 中的应用

RestTemplate
JDBCTemplate

将不同算法封装成一个类，每个算法完成的是同类型的问题。

策略模式实现购买商品使用不同的支付方式

策略模式在JDK中的应用

比较器是一个典型的策略模式，定义一个比较器接口，对象要排序可以实现自己的比较器实现类。

public interface Comparator {
int compare(T o1, T o2);
}


策略模式在Spring中的应用

各个部门协同合作完成一个任务，每个部门都有各自的职责，一个部门完成后，变回转交给下一个部门，直到所有部门都处理了，这个任务才完成。
将请求与处理解耦。
处理者只需要关注自己感兴趣的请求进行处理，对于不感兴趣的请求，直接转发给下一个节点对象。

责任链模式实现登录校验

1、校验用户名或密码是否为空。
2、校验用户名是否存在。
3、校验是否有权限。

@Data
public class Member {
private String loginName;
private String loginPass;
private String roleName;
public Member(String loginName, String loginPass) {
this.loginName = loginName;
this.loginPass = loginPass;
}
}


传统编码，在同一个方法里一个一个进行判断。

public class MemberService {
public void login(String loginName, String loginPass) {
if (StringUtils.isEmpty(loginName) || StringUtils.isEmpty(loginPass)) {
System.out.println("用户名或密码不为空，校验失败");
return;
}
System.out.println("用户名、密码校验成功");
if (!"James".equals(loginName)) {
System.out.println("用户不存在");
return;
}
Member member = new Member();
member.setRoleName("管理员");
if (!"管理员".equals(member.getRoleName())) {
System.out.println("您不是管理员，没有权限");
return;
}
System.out.println("登录成功");
}
public static void main(String[] args) {
MemberService memberService = new MemberService();
memberService.login("Ja1mes", "null");
}
}


使用责任链和建造者结合模式，将每个步骤处理连起来。
抽象出处理类。

public abstract class Handler {
// 指向下一个处理类
protected Handler chain;
// 设置下一个处理类
public void next(Handler handler) {
this.chain = handler;
}
// 具体处理逻辑
public abstract void doHandler(Member member);
// 构建一条链式处理逻辑
public static class Builder {
// 第一个处理类
private Handler head;
// 最后一个处理类
private Handler tail;
// 从头开始添加处理类
public Builder addHandler(Handler handler) {
if (this.head == null) {
// 只有一个处理类,所以不需要设置下一个处理类
this.head = this.tail = handler;
return this;
}
// 设置下一个处理类
this.tail.next(handler);
// 尾部设置为下一个处理类的引用
this.tail = handler;
return this;
}
// 返回的是第一个处理类
public Handler builder() {
return this.head;
}
}
}


具体实现三个处理类，来进行分别校验

public class ValidateHandler extends Handler {
@Override
public void doHandler(Member member) {
if (StringUtils.isEmpty(member.getLoginName()) || StringUtils.isEmpty(member.getLoginPass())) {
System.out.println("用户名或密码不为空，校验失败");
return;
}
System.out.println("用户名、密码校验成功");
chain.doHandler(member);
}
}
public class LoginHandler extends Handler {
@Override
public void doHandler(Member member) {
if (!"James".equals(member.getLoginName())){
System.out.println("用户名不存在");
return;
}
System.out.println("登录成功");
member.setRoleName("管理员");
chain.doHandler(member);
}
}
public class AuthHandler extends Handler {
@Override
public void doHandler(Member member) {
if (!"管理员".equals(member.getRoleName())) {
System.out.println("您不是管理员，没有权限");
return;
}
System.out.println("您是管理员，允许操作");
}
}


public class MemberService {
public void login(String loginName, String loginPass) {
// 构建一条链式处理
Handler.Builder builder = new Handler.Builder()
.addHandler(new ValidateHandler())
.addHandler(new LoginHandler())
.addHandler(new AuthHandler());
// 从第一个处理类执行到最后一个处理类
builder.builder().doHandler(new Member("James11", "1234"));
}
public static void main(String[] args) {
MemberService memberService = new MemberService();
memberService.login("Ja1mes", "1234");
}
}


责任链模式在Spring中的应用

过滤器，拦截器。
过滤器，可以配置多个过滤器来干不同的事情，然后一个一个执行。
FilterChain。