老板：小张，这里有个需求需要你来完成。
张工：张工已就位，什么需求我康康
老板：
我们的客户信息都是先统计在Excel表格中，但是客服小姐姐有时候会不小心把客户信息填错，这些数据在经过我们的系统我不希望数据都成功录入，并且那些错误的信息要能够提示出来好进行修改！这才银杏！！
客服：老板~ 那么多数据我怎么能做到百分百正确率啊，眼睛都要看花呐~
15分钟后
张工默默的忍受这一切，抱怨客服工作不认真，抱怨老板........终于张工在沉默中爆发了!
张工：保证完成任务!
张工心里想着不对劲啊，为什么会有这么简单的功能，连客户信息都不做校验！难道出BUG了！！？张工将代码从仓库拉取到本地...看着前辈的代码，挺简洁的呀！就是看不到做信息校验逻辑代码的影子...于是直接在导入数据的Service中写上了客户各种信息校验的代码，完成！
代码如下：（示例代码）
- User
package com.zwf.responsibilitychain.po;
/**
* 客户类
* @author zwf_xiaozhang
*/
public class User {
/**
* 电话号码
*/
private String tel;
/**
* 姓名
*/
private int age;
/**
* 错误信息
*/
private String errorInfo;
/**
* 状态：1 0
* 1：信息全部校验通过 0：有一个信息校验未通过
*/
private int state;
public User(String tel, int age) {
this.tel = tel;
this.age = age;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getErrorInfo() {
return errorInfo;
}
public void setErrorInfo(String errorInfo) {
this.errorInfo = errorInfo;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
@Override
public String toString() {
return "User{" +
"tel='" + tel + '\'' +
", age=" + age +
", errorInfo='" + errorInfo + '\'' +
", state=" + state +
'}';
}
}- Service
package com.zwf.responsibilitychain;
import com.zwf.responsibilitychain.po.User;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Test1 {
public static void main(String[] args) {
//模拟数据（前端获取）
User u = new User("123451673674",112);
String tel = u.getTel();
int age = u.getAge();
//报错错误信息集合
List<String> errorInfo = new ArrayList<>();
//校验年龄
if(age<0 || age > 100){
u.setState(1);
errorInfo.add("年龄有问题！");
}
//校验电话号码
if(tel.length() != 11){
u.setState(1);
errorInfo.add("电话格式有问题");
}
//拼接错误信息并赋值
u.setErrorInfo(errorInfo.stream().collect(Collectors.joining(",")));
System.out.println(u);
}
}随着业务的复杂度递增，张工继续写着相似的许多代码，虽然只是copy。然后张工逐渐发现了代码的问题！耦合度太高，代码复用率太低...在其他模块都有着相似的校验，有一些校验逻辑非常复杂，甚至出现了if else嵌套有三层，过几天就忘了，要拓展逻辑业务还得重新理解这些嵌套的if else，然后再将新的逻辑添加进去，修改起来及其复杂！！！张工留下了后悔的眼泪...
设计模式：要你康康我你不看，活该！
学习设计模式中ing...
于是张工重构了代码，如下：
UML图：
将校验这个功能抽象出来成一个抽象类，子类继承然后实现具体的校验逻辑，比如TelHandler就做电话的校验处理。nextHandler作为一个连接点连接到下一个校验子类，就这样可以形成一条责任链。我们可以根据自己的业务需求来组合我们的责任链，这里就可以配合简单工厂模式，我们的子类其实和策略模式的策略大同小异，也可以写成单例的。为什么写成单例？看以下分析：
调用流程图：
如果在多线程情况下，每个线程来访问service,我们需要不断的new具体的处理器，然后进行组合，其实new出了许多重复的子类然后组合，那为什么不优化成单例的呢？减少程序运行中的内存开销。
最终的UML图如下：
代码如下：
- User
package com.zwf.responsibilitychain.po;
/**
* 客户类
* @author zwf_xiaozhang
*/
public class User {
/**
* 电话号码
*/
private String tel;
/**
* 姓名
*/
private int age;
/**
* 错误信息
*/
private String errorInfo;
/**
* 状态：1 0
* 1：信息全部校验通过 0：有一个信息校验未通过
*/
private int state;
public User(String tel, int age) {
this.tel = tel;
this.age = age;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getErrorInfo() {
return errorInfo;
}
public void setErrorInfo(String errorInfo) {
this.errorInfo = errorInfo;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
@Override
public String toString() {
return "User{" +
"tel='" + tel + '\'' +
", age=" + age +
", errorInfo='" + errorInfo + '\'' +
", state=" + state +
'}';
}
}- AgeHandler extends UserInfoHandler
package com.zwf.responsibilitychain.handler;
import com.zwf.responsibilitychain.po.User;
import com.zwf.responsibilitychain.UserInfoHandler;
import org.springframework.stereotype.Component;
/**
* 年龄校验处理器
* @author zwf_xiaozhang
* 说明：单例对象，饿汉模式加载，单列对象注册到工厂的容器当中
*/
public class AgeHandler extends UserInfoHandler {
/**
* 单例对象
*/
private static final AgeHandler ageHandler = new AgeHandler();
/**
* 校验用户年龄
* 这里仅做案例，简单实现
* @param user
*/
@Override
public void checkInfo(User user) {
int age = user.getAge();
if(age<0 || age > 100){
errorInfos.add("年龄有问题");
user.setState(1);
}else if(nextHandler != null){
nextHandler.checkInfo(user);
}
}
/**
* 构造私有化 调用构造方法的时候注册
*/
private AgeHandler() {
register();
}
/**
* 对外开发的获取单例对象的方法
* @return
*/
public static AgeHandler getInstance(){
return ageHandler;
}
}- TelHandler extends UserInfoHandler
package com.zwf.responsibilitychain.handler;
import com.zwf.responsibilitychain.po.User;
import com.zwf.responsibilitychain.UserInfoHandler;
import org.springframework.stereotype.Component;
/**
* 电话校验处理器
* @author zwf_xiaozhang
* 说明：单例对象，饿汉模式加载，单列对象注册到工厂的容器当中
*/
public class TelHandler extends UserInfoHandler {
/**
* 单例对象
*/
private static final TelHandler telHandler = new TelHandler();
/**
* 校验用户电话号码
* 这里仅做案例，简单实现
* @param user
*/
@Override
public void checkInfo(User user) {
String tel = user.getTel();
if(tel.length() != 11){
errorInfos.add("电话号码格式错误");
user.setState(1);
}else if(nextHandler != null){
nextHandler.checkInfo(user);
}
}
/**
* 构造私有化 调用构造方法的时候注册
*/
private TelHandler() {
register();
}
/**
* 对外开发的获取单例对象的方法
* @return
*/
public static TelHandler getInstance(){
return telHandler;
}
}- UserInfoHandler
package com.zwf.responsibilitychain;
import com.zwf.responsibilitychain.po.User;
import java.util.ArrayList;
import java.util.List;
/**
* 用户信息处理接口
* @author zwf_xiaozhang
*/
public abstract class UserInfoHandler {
/**
* 错误信息容器，值初始化一次。
*/
protected static final List<String> errorInfos = new ArrayList<>();
/**
* 指向下一个处理器
*/
protected UserInfoHandler nextHandler;
public void setNextHandler(UserInfoHandler nextHandler){
this.nextHandler = nextHandler;
}
/**
* 校验用户信息
* @param user
*/
public abstract void checkInfo(User user);
/**
* 注册方法
*/
public void register(){
UserInfoChainFactory.registerHandler(getClass().getSimpleName(),this);
}
}- UserInfoChainFactory
package com.zwf.responsibilitychain;
import java.util.*;
/**
* 责任链工厂
* @author zwf_xiaozhang
*/
public class UserInfoChainFactory {
/**
* 处理器容器
*/
private static final Map<String,UserInfoHandler> handlerMap = new HashMap<>();
/**
* 根据名称获取单个处理器
* @param name
* @return
*/
public static UserInfoHandler getHandler(String name){
return handlerMap.get(name);
}
/**
* 类注册方法
* @param handlerName
* @param handler
*/
public static void registerHandler(String handlerName, UserInfoHandler handler){
handlerMap.put(handlerName.toUpperCase(Locale.ROOT),handler);
}
/**
* 根据前端给的参数进行责任链的拼接
* @param names 处理器的名称
* @return
*/
public static UserInfoHandler getUserInfoChain(List<String> names){
//获取到第一个处理器
UserInfoHandler handler = handlerMap.get(names.remove(0));
//设置零时处理器引用
UserInfoHandler tempHandler = null;
//拼接处理器形成责任链
for(int i = 0; i < names.size(); i++){
if(i == 0){
handler.nextHandler = handlerMap.get(names.get(i));
}else{
tempHandler.nextHandler = handlerMap.get(names.get(i));
}
tempHandler = handlerMap.get(names.get(i));
}
return handler;
}
}- Test -- 单线程情景
package com.zwf.responsibilitychain;
import com.zwf.responsibilitychain.handler.AgeHandler;
import com.zwf.responsibilitychain.handler.TelHandler;
import com.zwf.responsibilitychain.po.User;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
//初始化处理器
AgeHandler.getInstance();
TelHandler.getInstance();
//模拟数据，一般从前端直接获取到的需要校验的用户
User u =new User("1245678901",12);
List<String> names = new ArrayList<>();
names.add("ageHandler");
names.add("telHandler");
//将处理器名称全部转大写，在注册的时候其实也都转了大写，防止单词大小写写错导致获取不到处理器
names = names.stream().map(String::toUpperCase).collect(Collectors.toList());
//获取责任链
UserInfoHandler handler = UserInfoChainFactory.getUserInfoChain(names);
//开始检验
handler.checkInfo(u);
//设置错误信息
u.setErrorInfo(UserInfoHandler.errorInfos.stream().collect(Collectors.joining(",")));
//清除集合
UserInfoHandler.errorInfos.clear();
System.out.println(u);
}
}
}
补充：
当AgeHandler、TelHandler两个类被加载时就会初始化然后注册到工厂的容器中。为了方便测试我直接写在main方法中运行，不是启动这个工程，所以这些类不会加载，需要我进行初始化。如果时Spring工程，配合@Compent注解将处理器进行注入就行。
工厂接收字符串集合的逻辑是：
由前端传过来的字符串集合定义需要进行哪些校验然后由工厂生产对应的责任链。这样设计的目的，实现该方法在后台的高复用率，因为业务场景中会出现不同类型的客户，就需要不同的责任链，如果每个责任链写一个接口或者Service,没必要了，直接由前端定义好需要校验的信息，然后工厂生产责任链即可。
公共集合errorInfos的作用：
将收集到的错误信息用","拼接设置到该对象的errorInfo属性，返回给前端作为提示！
为什么要clear()集合？
因为这个集合是被 static final修饰的，在程序运行中只有一个集合！是所有责任链节点共有的！每一个责任链处理完要将其clear()还原，不然下一个责任链使用时会出现bug。
为什么写成共有的集合 static final ？
防止高并发场景造成内存溢出！如果集合不是共有的，每次调用都需要创建一个集合，需要很大的内存开销。
- Test--多线程场景
package com.zwf.responsibilitychain;
import com.zwf.responsibilitychain.handler.AgeHandler;
import com.zwf.responsibilitychain.handler.TelHandler;
import com.zwf.responsibilitychain.po.User;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
//初始化
AgeHandler.getInstance();
TelHandler.getInstance();
//模拟多线程情景
for (int i = 0; i < 1000; i++){
new Thread(()->{
//模拟数据，一般从前端直接获取到的需要校验的用户
User u =new User("1245678901",12);
List<String> names = new ArrayList<>();
names.add("ageHandler");
names.add("telHandler");
names = names.stream().map(String::toUpperCase).collect(Collectors.toList());
//获取责任链
UserInfoHandler handler = UserInfoChainFactory.getUserInfoChain(names);
synchronized (Test.class){
//开始检验
handler.checkInfo(u);
//设置错误信息
u.setErrorInfo(UserInfoHandler.errorInfos.stream().collect(Collectors.joining(",")));
//清除集合
UserInfoHandler.errorInfos.clear();
System.out.println(u);
}
}).start();
}
}
}
大家也知道，上锁会导致效率低的问题，如果一个线程就要处理大量用户数据，那么效率更低！
浅分析一下：
10个线程，每个线程要校验3w用户数据，这3w数据的每一条数据循环使用这个集合。其他线程要等前面线程校验完了才能使用到这个集合进行校验处理，如果3w要校验6s,10个线程就说一分钟！！！
我有想到一个优化方案：ThreadLocal,将这个集合绑定到我们的线程上！下期更新！
张工：呼~ 只能优化到这了，我要先去跟线程池大哥混，然后找他帮忙做这个优化
设计模式：现在知道我有多香了吧，我一共有23款！你自己慢慢品吧...
上线后...
客服：比之前好用了，没用脏数据了，但是处理起来比以前慢了~
老板：小张，抽空去优化一下！！！生产队的驴都不敢这么歇！
张工：没问题...
张工看到了成堆的需求，看到了没有注释的代码，看到了摸鱼的产品，看到了...
冷静的泡了一杯咖啡，坐在角落里的工位，然后默默的打开了招聘网...
故事纯属虚构请勿当真...
重要的是设计模式的学习...
9106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
