详解Java实现设计模式之责任链模式

一、模拟业务需求

假设我们现在需要在我们的系统中导入一批关于学生信息的excel的数据，其主要的信息有：学号、姓名、年龄、性别等等，在导入系统的时候，我们肯定不能直接的保存到数据库，我们肯定是先要对这个excel的数据进行校验，看是否符合系统的要求，只有都符合了系统的要求了，我们把这些数据保存到数据库中去。假如我们的学生对应的实体类如下：

@data
public class student {
	/**
	 * 学生编号
	 */
	private string stno;
	/**
	 * 学生姓名
	 */
	private string stname;
	/**
	 * 学生年龄
	 */
	private integer age;
	/**
	 * 性别
	 */
	private string gender;

}

那么假设我们现在的需求是：在我们的studentserviceimpl业务实现类里面已经接收到了一个list studentlist集合的数据，这个集合的数据就是刚刚从excel里导进来的学生的数据信息，但是集合里面的每个student对象的属性都没有进行过校验，现要求你对这些属性进行校验完全通过后再把这些学生的信息保存到数据库中去。

二、小步小跑的迭代开发

好，一开始，业务那边的小姑娘小美说这些学生的数据没有什么重要的，只要校验这个学生的姓名不能为空就行且不超过20个字就行了，这个对于你来说就是个小意思，于是你可能在业务代码中先对集合进行遍历然后写下这样的判断：

//判断学生的姓名是否符合条件
if(objects.nonnull(stu.getstname()) && stu.getstname().length() < 20) {
	//todo ...对符合的数据进行下一步的处理
}

过了不久，小美害羞的看着你，对你说：这个年龄也要做判断，必填且不能小于0，不能大于60，改好了请你吃饭。你看着她甜美的笑容，果断的对好说：简单。于是你又加上了这样的代码：

//判断学生的姓名是否符合条件
if(objects.nonnull(stu.getstname()) && stu.getstname().length() < 20) {

	if(objects.nonnull(stu.getstage()) && stu.getstage() > 0 && stu.getstage() < 60) {
		//todo ...对符合的数据进行下一步的处理
	}
}

又过了几天，你又看到小美跑过来，你满怀期待的觉得她是通知你今天下班了一起共进晚餐。但是她却支支吾吾的想说又说不出，这里你心想，完蛋了，会不会共进晚餐的机会泡汤了。这时她说：这个学生的性别也要做校验，且只能是“男”或“女”，加上之前的都要校验通过了才能在到系统里面。听到这里，你不由得松了一口气，共进晚餐的机会还有。于是你说：没问题。于是你又在原先的代码里面进行了迭代：

//判断学生的姓名是否符合条件
if(objects.nonnull(stu.getstname()) && stu.getstname().length() < 20) {

	if(objects.nonnull(stu.getstage()) && stu.getstage() > 0 && stu.getstage() < 60) {

		if(object.notnull(stu.getgender()) && ("男".equest(stu.getgender()) || "女".equest(stu.getgender()))) {
			//todo ...对符合的数据进行下一步的处理

		}
	}
}

你很快的改完了，但是在检查的时候，看着这个代码，总感觉有总说不出来的问题，但是又好像没有什么问题。实然，你想到以后小美肯定还会经常来找你，如果再继续的这样if的写下去，以后越来越难维护了，以后和小美吃饭的时间都没有了。想到这，你不由得直冒冷汗。于是你闭关半天，终于把这个潜在的阻止你和小美吃饭的的拦路虎给解决了。

三、系统对数据的校验要求

• stname（学生姓名）：不能为空，不能超过20个字符。
• age（学生年龄）：只能为整数，且小于60。
• gender（学生性别）：只能是"男"或"女"。
• stno（学生编号）：要求唯一，不能为空，不能超过20个字符，且在数据库中不能已经存在。

四、新建一个抽象类

在这个抽象类中，包含有有一个它自身属性，和一个set方法，此外还要有一个抽象方法，给不同的子类来实现不同的逻辑，详细说明如下：

//抽象的父类
public abstract class abscheckstudent {
	//包含有自身的一个属性，其作业主要是下一个对数据的处理者
	protected abscheckstudent abscheckstudent;
	//设定下一个处理者
	public void setabscheckstudent(abscheckstudent abscheckstudent) {
		this.abscheckstudent = abscheckstudent;
	}
	//此方法是业务层调用的方法，即业务调用此方法，把学生的集合做参数传进来即可。
	public void handlecheck(list<student> studentlist) {
		if (objects.nonnull(studentlist) && !studentlist.isempty()) {
			list<student> checkisok = checkstudent(studentlist);
			//判断下一个处理者是不是null，即还有没有下一个处理者，且判断数据是否为空
			if (objects.nonnull(abscheckstudent) && objects.nonnull(checkisok) && !checkisok.isempty()) {
				//调用下一个处理者的业务处理方法
				abscheckstudent.handlecheck(checkisok);
			}
		}
	}
	//此方法是由不同的子类来进行不同的处理实现
	public abstract list<student> checkstudent(list<student> studentlist);
}

五、子类的实现

首先实现的是学生姓名的校验的子类

public class stnamecheck extends abscheckstudent{

	@override
	public list<student> checkstudent(list<student> studentlist) {
		//获取学生名称不符合条件的学生对象
		list<student> stnameisnotok = studentlist.stream().filter(stu -> {
			string stname = stu.getstname();
			return objects.isnull(stname) || "".equals(stname);
		}).collect(collectors.tolist());
		system.out.println("名字校验不通过的数据有："+ stnameisnotok.tostring());
		//在原有的集合中移除不符合学生姓名的对象集合
		studentlist.removeall(stnameisnotok);
		system.out.println("名字校验通过的数据：" + studentlist.tostring());
		//返回通过学生姓名校验的学生的集合
		return studentlist;
    }
}

然后再实现的是学生年龄的校验子类

public class stagecheck extends abscheckstudent{
	@override
	public list<student> checkstudent(list<student> studentlist) {
		//获取学生年龄不符合条件的学生对象
		list<student> stageisnotok = studentlist.stream().filter(stu -> {
			integer stage = stu.getage();
			return objects.isnull(stage) || stage <= 0 || stage >= 60;
		}).collect(collectors.tolist());
		system.out.println("年龄校验不通过的数据有：" + stageisnotok.tostring());
		//在原有的集合中移除不符合学生年龄的对象集合
		studentlist.removeall(stageisnotok);
		system.out.println("年龄校验通过的数据：" + studentlist.tostring());
		//返回通过学生姓名校验的学生的集合
		return studentlist;
    }
}

最后实现的是学生性别的校验的子类

public class stgendercheck extends abscheckstudent{
	@override
	public list<student> checkstudent(list<student> studentlist) {
		//获取学生年龄不符合条件的学生对象
		list<student> stgenderisnotok = studentlist.stream().filter(stu -> {
			string gender = stu.getgender();
			return objects.isnull(gender) || !("男".equals(gender) || "女".equals(gender));
		}).collect(collectors.tolist());
		system.out.println("性别校验没有通过的数据：" + stgenderisnotok.tostring());
		//在原有的集合中移除不符合学生年龄的对象集合
		studentlist.removeall(stgenderisnotok);
		system.out.println("性别校验通过的数据：" + studentlist.tostring());
		//返回通过学生姓名校验的学生的集合
		return studentlist;
    }
}

六、构建责任链和调用

好了，现在，校验姓名的子类、校验年龄的子类、校验性别的子类都已经实现了。不同职责的子类校验有了，现在我们需要构建一条责任链。即，先通过了姓名校验的数据才能进行下一步的年龄校验，通过了年龄校验的数据才能到性别校验，性别校验通过了，就可以保存数据到数据库了。现在我们构建如下的责任链：

public class chain {
	public static abscheckstudent getstudentcheck() {
		//校验姓名
		abscheckstudent stnamecheck = new stnamecheck();
		//校验年龄
		abscheckstudent stagecheck = new stagecheck();
		//校验性别
		abscheckstudent stgendercheck = new stgendercheck();

		//设置好责任链的顺序，把校验年龄的子类当作stnamecheck中的下一个处理者
		stnamecheck.setabscheckstudent(stagecheck);
		//把校验性别的子类当作stagecheck中的下一个处理者
		stagecheck.setabscheckstudent(stgendercheck);
	}

	public static void main(string[] args) {
		abscheckstudent studentcheck = getstudentcheck();
		list<student> studentlist = getstudents();
		studentcheck.handlecheck(studentlist);
	}

	public static list<student> getstudents() {
		list<student> result = new arraylist<>();
		student s1 = new student();
		s1.setage(12);
		s1.setgender("男");
		s1.setstname("张三");
		s1.setstno("");

		student s2 = new student();
		s2.setage(12);
		s2.setgender("男1");
		s2.setstname("张三");
		s2.setstno("123");

		student s3 = new student();
		s3.setage(12);
		s3.setgender("男");
		s3.setstname("张三");
		s3.setstno("123");

		result.add(s1);
		result.add(s2);
		result.add(s3);
		return result;
    }
}

最后的运行结果如下：

你看，这样的话，我们只要有有最后校验性别的逻辑里面，对于通过性别校验的数据保存到数据库里面就行了。

七、可维护性

当你闭关出来后，小美又过来找你了，说学生编号要求唯一，不能为空，不能超过20个字符，且在数据库中不能已经存在。只有当编号的校验通过了就可以放心的保存到数据库了。
这时候，你就可以这样进行扩展了，先创建一个子类来继承abscheckstudent

public class stgendercheck extends abscheckstudent{
	@override
	public list<student> checkstudent(list<student> studentlist) {
		//获取学生年龄不符合条件的学生对象
		list<student> stnoisnotok = studentlist.stream().filter(stu -> {
			string stno = stu.getstno();
			return objects.isnull(stno) || "".equals(stno) || stno.length() > 20;
		}).collect(collectors.tolist());
		//todo 做数据库中的惟一性的校验等
		system.out.println("编号校验不通过的数据有：" + stnoisnotok.tostring());
		//在原有的集合中移除不符合学生编号的对象集合
		studentlist.removeall(stnoisnotok);
		system.out.println("通过了全部的校验的数据有：" + studentlist);
		//todo 全部通过校验了，保存数据到数据库 save(studentlist);
		return null;
    }
}

然后我们再在那个责任链上加上这个新的处理节点：

public class chain {
	public static abscheckstudent getstudentcheck() {
		//校验姓名
		abscheckstudent stnamecheck = new stnamecheck();
		//校验年龄
		abscheckstudent stagecheck = new stagecheck();
		//校验性别
		abscheckstudent stgendercheck = new stgendercheck();

		//设置好责任链的顺序，把校验年龄的子类当作stnamecheck中的下一个处理者
		stnamecheck.setabscheckstudent(stagecheck);
		//把校验性别的子类当作stagecheck中的下一个处理者
		stagecheck.setabscheckstudent(stgendercheck);

		abscheckstudent stnocheck = new stnocheck();
		//把学生的编号校验放到性别校验的后面
		stgendercheck.setabscheckstudent(stnocheck);
	}

	// ......
}

运行结果如下：

八、总结

8.1、责任链模式

• 可以控制请求的处理的顺序
• 单一职责原则，可以对发起操作和执行操作的类进行解耦
• 开闭原则，可不用修改原有的业务代码，新增其他的处理类
• 不能保证每个处理者者可以执行
• 效率不是很好，调用时如果不注意会出现各种各样的问题

8.2、责任链模式适用的场景

• 当必须按顺序执行多个处理者时，可以考虑使用责任链模式
• 如果处理者的顺序及其必须在运行时改变时，可以考虑使用责任链模式

以上就是详解java实现设计模式之责任链模式的详细内容，更多关于java 设计模式 责任链模式的资料请关注其它相关文章！