精华内容
下载资源
问答
  • 数据提交前做各种处理 二、代码 1.MsgProcessor.java 1 public class MsgProcessor { 2 3 private List<Filter> filters = new ArrayList<Filter>(); 4 private String msg; 5 ...

    一、目标

    数据提交前做各种处理

     

    二、代码

    1.MsgProcessor.java

     1 public class MsgProcessor {
     2     
     3     private List<Filter> filters = new ArrayList<Filter>();
     4     private String msg;
     5     
     6     public String getMsg() {
     7         return msg;
     8     }
     9 
    10     public void setMsg(String msg) {
    11         this.msg = msg;
    12     }
    13 
    14     public String process() {
    15         
    16         filters.add(new SensitiveFilter());
    17         filters.add(new HTMLFilter());
    18         
    19         String r = msg;
    20         for(Filter f : filters){
    21             r = f.doFilter(r);
    22         }
    23         return r;
    24     }
    25 }

     

    2.Filter.java

    1 public interface Filter {
    2     public String doFilter(String str);
    3 }

     

    3.HTMLFilter.java

    1 public class HTMLFilter implements Filter {
    2 
    3     @Override
    4     public String doFilter(String str) {
    5         return str.replace('<', '[').replace(">", "]");
    6     }
    7 
    8 }

     

    4.SensitiveFilter.java

    public class SensitiveFilter implements Filter {
    
        @Override
        public String doFilter(String str) {
            return str.replace("敏感", "幸福");
        }
    
    }

     

    5.Test.java

    public class Test {
    
        @org.junit.Test
        public void testFilter(){
            
            String msg = "<html>敏感字眼</html>"; 
            MsgProcessor processor = new MsgProcessor();
            processor.setMsg(msg);
            String result = processor.process();
            System.out.println(result);
            
        }
    
    }

     

    三、运行结果

    转载于:https://www.cnblogs.com/shamgod/p/4590764.html

    展开全文
  • java责任链模式

    千次阅读 2018-07-02 16:29:09
    责任链模式:当数据要进行多次处理时,可以使用此模式。一般过滤器和拦截器都用到了此种模式。

    责任链模式是一种设计模式。在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

    当数据要进行多次处理时,为了方便动态扩展,可以使用此模式。过滤器和拦截器都用到了此种模式。

    1.只需要处理数据后,返回简单的处理结果

    首先创建一个接口:

    public interface DataFilter {
    	public void doFilter(DataRequest dataRequest, DataReponse dataReponse);
    }


    public class DataReponse {
    	
    	private int dataType;
    	
    	private String data;
    
    	public int getDataType() {
    		return dataType;
    	}
    
    	public void setDataType(int dataType) {
    		this.dataType = dataType;
    	}
    
    	public String getData() {
    		return data;
    	}
    
    	public void setData(String data) {
    		this.data = data;
    	}
    
    }
    public class DataRequest {
    	
    	private int dataType;
    	
    	private String oldData;
    	
    	private String handleData;
    
    	public int getDataType() {
    		return dataType;
    	}
    
    	public void setDataType(int dataType) {
    		this.dataType = dataType;
    	}
    
    	public String getOldData() {
    		return oldData;
    	}
    
    	public void setOldData(String oldData) {
    		this.oldData = oldData;
    	}
    
    	public String getHandleData() {
    		return handleData;
    	}
    
    	public void setHandleData(String handleData) {
    		this.handleData = handleData;
    	}
    
    } 

    然后创建Handle 来处理数据:

    public class NBDataFilter implements DataFilter {
    
    	@Override
    	public void doFilter(DataRequest dataRequest, DataReponse  dataReponse) {
    		System.out.println("dataRequest:nb进来了");
    		System.out.println("dataReponse:nb进来了");
    	}
    
    }
    public class OneDataFilter implements DataFilter {
    
    	@Override
    	public void doFilter(DataRequest dataRequest,DataReponse dataReponse) {
    		System.out.println("dataRequest:nb进来了");
    		System.out.println("dataReponse:nb进来了");
    	}
    
    }

    public class UppFilter implements DataFilter{
    
    	@Override
    	public void doFilter(DataRequest dataRequest,DataReponse dataReponse) {
    		System.out.println("dataRequest:udp进来了");
    		System.out.println("dataReponse:udp进来了");
    	}
    }

    创建chain 来调用handle

    public class DataChain implements DataFilter {
    
    	private  List<DataFilter> dataFilters;
    	
    	@Override
    	public void doFilter(DataRequest dataRequest, DataReponse dataReponse) {
    	    for(int i=0;i<dataFilters.size();i++) {
    	    	dataFilters.get(i).doFilter(dataRequest, dataReponse);
    	    }
    		
    	}
    
    	public List<DataFilter> getDataFilter() {
    		return dataFilters;
    	}
    
    	public void setDataFilter(List<DataFilter> dataFilter) {
    		this.dataFilters = dataFilter;
    	}
    	
    }

    测试类:

    public class DataHandle {
    	
    	public static void main(String[] args) {
    		DataChain dataChain = new DataChain();
    		List<DataFilter> dataFilters = new ArrayList<>();
    		dataFilters.add(new NBDataFilter());
    		dataFilters.add(new UppFilter());
    		dataFilters.add(new OneDataFilter());
    		dataChain.setDataFilter(dataFilters);
    		dataChain.doFilter(new DataRequest(), new DataReponse());
    	}
    
    }

    测试结果如下:

    dataRequest:nb进来了
    dataReponse:nb进来了
    dataRequest:udp进来了
    dataReponse:udp进来了
    dataRequest:nb进来了

    dataReponse:nb进来了


    2.由前到后的顺序处理数据,由后到前返回数据结果

    创建接口:

    public interface DataFilter {
    
    	public void doFilter(DataRequest dataRequest, DataReponse dataReponse,DataChain dataFilter);
    
    	
    
    }

    创建Handle 来处理数据:

    public class NBDataFilter implements DataFilter {
    
    	@Override
    	public void doFilter(DataRequest dataRequest, DataReponse dataReponse,DataChain dataFilter) {
    		System.out.println("dataRequest:nb进来了");
    		dataFilter.doFilter(dataRequest, dataReponse, dataFilter);
    		System.out.println("dataReponse:nb进来了");
    	}
    
    }
    public class OneDataFilter implements DataFilter {
    
    	@Override
    	public void doFilter(DataRequest dataRequest,DataReponse dataReponse, DataChain dataChain) {
    	    System.out.println("dataRequest:one进来了");
    		dataChain.doFilter(dataRequest, dataReponse, dataChain);
    		System.out.println("dataReponse:one进来了");
    	}
    
    }
    

    public class UppFilter implements DataFilter{
    
    	@Override
    	public void doFilter(DataRequest dataRequest,DataReponse dataReponse, DataChain dataChain) {
    		System.out.println("dataRequest:udp进来了");
    		dataChain.doFilter(dataRequest, dataReponse, dataChain);
    		System.out.println("dataReponse:udp进来了");
    	}
    
    }

    创建chain来管理handle

    public class DataChain implements DataFilter {
    
    	private  List<DataFilter> dataFilters;
    	
    	private ThreadLocal<Integer> indexThreadLocal = new ThreadLocal<Integer>() {
    		public Integer initialValue() {
    			System.out.println(Thread.currentThread().getName()+"被初始化了");
    			return 0;
    		}
    	};
    
    	
    	@Override
    	public void doFilter(DataRequest dataRequest, DataReponse dataReponse,DataChain dataChain) {
    		System.out.println(Thread.currentThread().getName()+"  "+indexThreadLocal.hashCode());
    		int index = indexThreadLocal.get();
    		if(index == dataFilters.size()) {
    			indexThreadLocal.set(0);
    			return ;
    		}
    		DataFilter filter = dataFilters.get(index);
    		indexThreadLocal.set(++index);
    		filter.doFilter(dataRequest, dataReponse, dataChain);
    		
    	}
    
    	public List<DataFilter> getDataFilter() {
    		return dataFilters;
    	}
    
    	public void setDataFilter(List<DataFilter> dataFilter) {
    		this.dataFilters = dataFilter;
    	}
    	
    	
    	
    
    }

    测试类:

    public class DataHandle {
    	
    	public static void main(String[] args) {
    		DataChain dataChain = new DataChain();
    		List<DataFilter> dataFilters = new ArrayList<>();
    		dataFilters.add(new NBDataFilter());
    		dataFilters.add(new UppFilter());
    		dataFilters.add(new OneDataFilter());
    		dataChain.setDataFilter(dataFilters);
    		DataRequest dataRequest = new DataRequest();
    		dataRequest.setDataType(ConncetTypeNumber.CONNECTTYPE_HUAIWEI );
    		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
    		for( int i=0;i<2;i++){
    		newFixedThreadPool.execute(new Runnable() {
    			@Override
    			public void run() {
    			
    				dataChain.doFilter(dataRequest, new DataReponse(),dataChain);
    			}
    		});
    		}
    		
    	}
    
    }

    测试结果:

    pool-1-thread-1被初始化了
    pool-1-thread-2被初始化了
    dataRequest:nb进来了
    dataRequest:nb进来了
    dataRequest:udp进来了
    dataRequest:udp进来了
    dataRequest:one进来了
    dataRequest:one进来了
    dataReponse:one进来了
    dataReponse:udp进来了
    dataReponse:nb进来了
    dataReponse:one进来了
    dataReponse:udp进来了
    dataReponse:nb进来了


    展开全文
  • java设计模式之责任链模式 在现实生活中,一个事件需要经过多个对象处理是很常见的场景。例如,采购审批流程、请假流程等。公司员工请假,可批假的领导有部门负责人、副总经理、总经理等,但每个领导能批准的天数...

    java设计模式之责任链模式

    在现实生活中,一个事件需要经过多个对象处理是很常见的场景。例如,采购审批流程、请假流程等。公司员工请假,可批假的领导有部门负责人、副总经理、总经理等,但每个领导能批准的天数不同,员工必须根据需要请假的天数去找不同的领导签名,也就是说员工必须记住每个领导的姓名、电话和地址等信息,这无疑增加了难度。

    在计算机软硬件中也有相关例子,如总线网中数据报传送,每台计算机根据目标地址是否同自己的地址相同来决定是否接收;还有异常处理中,处理程序根据异常的类型决定自己是否处理该异常;还有 Struts2 的拦截器、JSP 和 Servlet 的 Filter 等,所有这些,都可以考虑使用责任链模式来实现。

    1、定义与特点

    责任链(Chain of Responsibility)模式的定义:为了避免请求发送者与多个请求处理者耦合在一起,于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止。

    注意:责任链模式也叫职责链模式

    在责任链模式中,客户只需要将请求发送到责任链上即可,无须关心请求的处理细节和请求的传递过程,请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。

    责任链模式是一种对象行为型模式,其主要优点如下。
    1.降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构,发送者和接收者也无须拥有对方的明确信息。
    2.增强了系统的可扩展性。可以根据需要增加新的请求处理类,满足开闭原则。
    3.增强了给对象指派职责的灵活性。当工作流程发生变化,可以动态地改变链内的成员或者调动它们的次序,也可动态地新增或者删除责任。
    4.责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用,不需保持其他所有处理者的引用,这避免了使用众多的 if 或者 if···else 语句。
    5.责任分担。每个类只需要处理自己该处理的工作,不该处理的传递给下一个对象完成,明确各类的责任范围,符合类的单一职责原则。

    其主要缺点如下。
    1、不能保证每个请求一定被处理。由于一个请求没有明确的接收者,所以不能保证它一定会被处理,该请求可能一直传到链的末端都得不到处理。
    2、对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能将受到一定影响。
    3、职责链建立的合理性要靠客户端来保证,增加了客户端的复杂性,可能会由于职责链的错误设置而导致系统出错,如可能会造成循环调用。

    2、结构与实现

    通常情况下,可以通过数据链表来实现职责链模式的数据结构。

    2.1 结构

    职责链模式主要包含以下角色。
    1、抽象处理者(Handler)角色:定义一个处理请求的接口,包含抽象处理方法和一个后继连接。
    2、具体处理者(Concrete Handler)角色:实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给它的后继者。
    3、客户类(Client)角色:创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。

    责任链模式的本质是解耦请求与处理,让请求在处理链中能进行传递与被处理;理解责任链模式应当理解其模式,而不是其具体实现。责任链模式的独到之处是将其节点处理者组合成了链式结构,并允许节点自身决定是否进行请求处理或转发,相当于让请求流动起来。

    2.2 实现

    public class ChainOfResponsibilityPattern {
        public static void main(String[] args) {
            //组装责任链
            Handler handler1 = new ConcreteHandler1();
            Handler handler2 = new ConcreteHandler2();
            handler1.setNext(handler2);
            //提交请求
            handler1.handleRequest("two");
        }
    }
    //抽象处理者角色
    abstract class Handler {
        private Handler next;
        public void setNext(Handler next) {
            this.next = next;
        }
        public Handler getNext() {
            return next;
        }
        //处理请求的方法
        public abstract void handleRequest(String request);
    }
    //具体处理者角色1
    class ConcreteHandler1 extends Handler {
        public void handleRequest(String request) {
            if (request.equals("one")) {
                System.out.println("具体处理者1负责处理该请求!");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(request);
                } else {
                    System.out.println("没有人处理该请求!");
                }
            }
        }
    }
    //具体处理者角色2
    class ConcreteHandler2 extends Handler {
        public void handleRequest(String request) {
            if (request.equals("two")) {
                System.out.println("具体处理者2负责处理该请求!");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(request);
                } else {
                    System.out.println("没有人处理该请求!");
                }
            }
        }
    }
    

    程序运行结果如下:

    具体处理者2负责处理该请求!

    在上面代码中,我们把消息硬编码为 String 类型,而在真实业务中,消息是具备多样性的,可以是 int、String 或者自定义类型。因此,在上面代码的基础上,可以对消息类型进行抽象 Request,增强了消息的兼容性。

    3、实际案例

    【例1】用责任链模式设计一个请假条审批模块。

    分析:假如规定学生请假小于或等于 2 天,班主任可以批准;小于或等于 7 天,系主任可以批准;小于或等于 10 天,院长可以批准;其他情况不予批准;这个实例适合使用职责链模式实现。

    首先,定义一个领导类(Leader),它是抽象处理者,包含了一个指向下一位领导的指针 next 和一个处理假条的抽象处理方法 handleRequest(int LeaveDays);然后,定义班主任类(ClassAdviser)、系主任类(DepartmentHead)和院长类(Dean),它们是抽象处理者的子类,是具体处理者,必须根据自己的权力去实现父类的 handleRequest(int LeaveDays) 方法,如果无权处理就将假条交给下一位具体处理者,直到最后;客户类负责创建处理链,并将假条交给链头的具体处理者(班主任)
    代码:

    public class LeaveApprovalTest {
        public static void main(String[] args) {
            //组装责任链
            Leader teacher1 = new ClassAdviser();
            Leader teacher2 = new DepartmentHead();
            Leader teacher3 = new Dean();
            //Leader teacher4=new DeanOfStudies();
            teacher1.setNext(teacher2);
            teacher2.setNext(teacher3);
            //teacher3.setNext(teacher4);
            //提交请求
            teacher1.handleRequest(8);
        }
    }
    //抽象处理者:领导类
    abstract class Leader {
        private Leader next;
        public void setNext(Leader next) {
            this.next = next;
        }
        public Leader getNext() {
            return next;
        }
        //处理请求的方法
        public abstract void handleRequest(int LeaveDays);
    }
    //具体处理者1:班主任类
    class ClassAdviser extends Leader {
        public void handleRequest(int LeaveDays) {
            if (LeaveDays <= 2) {
                System.out.println("班主任批准您请假" + LeaveDays + "天。");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(LeaveDays);
                } else {
                    System.out.println("请假天数太多,没有人批准该假条!");
                }
            }
        }
    }
    //具体处理者2:系主任类
    class DepartmentHead extends Leader {
        public void handleRequest(int LeaveDays) {
            if (LeaveDays <= 7) {
                System.out.println("系主任批准您请假" + LeaveDays + "天。");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(LeaveDays);
                } else {
                    System.out.println("请假天数太多,没有人批准该假条!");
                }
            }
        }
    }
    //具体处理者3:院长类
    class Dean extends Leader {
        public void handleRequest(int LeaveDays) {
            if (LeaveDays <= 10) {
                System.out.println("院长批准您请假" + LeaveDays + "天。");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(LeaveDays);
                } else {
                    System.out.println("请假天数太多,没有人批准该假条!");
                }
            }
        }
    }
    //具体处理者4:教务处长类
    class DeanOfStudies extends Leader {
        public void handleRequest(int LeaveDays) {
            if (LeaveDays <= 20) {
                System.out.println("教务处长批准您请假" + LeaveDays + "天。");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(LeaveDays);
                } else {
                    System.out.println("请假天数太多,没有人批准该假条!");
                }
            }
        }
    }
    

    程序运行结果如下:

    院长批准您请假8天。

    假如增加一个教务处长类,可以批准学生请假 20 天,也非常简单,代码如下:

    //具体处理者4:教务处长类
    class DeanOfStudies extends Leader {
        public void handleRequest(int LeaveDays) {
            if (LeaveDays <= 20) {
                System.out.println("教务处长批准您请假" + LeaveDays + "天。");
            } else {
                if (getNext() != null) {
                    getNext().handleRequest(LeaveDays);
                } else {
                    System.out.println("请假天数太多,没有人批准该假条!");
                }
            }
        }
    }
    

    4、应用场景

    前边已经讲述了关于责任链模式的结构与特点,下面介绍其应用场景,责任链模式通常在以下几种情况使用。
    1、多个对象可以处理一个请求,但具体由哪个对象处理该请求在运行时自动确定。
    2、可动态指定一组对象处理请求,或添加新的处理者。
    3、需要在不明确指定请求处理者的情况下,向多个处理者中的一个提交请求。

    5、扩展

    职责链模式存在以下两种情况。
    1、纯的职责链模式:一个请求必须被某一个处理者对象所接收,且一个具体处理者对某个请求的处理只能采用以下两种行为之一:自己处理(承担责任);把责任推给下家处理。
    2、不纯的职责链模式:允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况,且一个请求可以最终不被任何接收端对象所接收。

    展开全文
  • 就是采用责任链模式来进行处理的,Mybatis中SqlSession下的四大对象Execute(执行器), StatementHandler(语句处理器),ResultHandler(结果集处理器)以及ParameterHandler(参数处理器)也是采用责任链模式来完成...

    责任链模式在我们的日常开发中会经常遇到,比如我们在servlet中的Filter过滤器,就是采用责任链模式来进行处理的,Mybatis中SqlSession下的四大对象Execute(执行器), StatementHandler(语句处理器),ResultHandler(结果集处理器)以及ParameterHandler(参数处理器)也是采用责任链模式来完成对数据的关系映射生成完整的sql和映射响应结果,还有很多很多,在这里就不一一累述了,今天主要记录一下使用java来优雅的实现责任链模式。

    1. 首先我们需要先了解一下什么是责任链模式,责任链模式简单而言就是:对一个请求创建一个对象链,每个对象依序检查此请求,并对其进行处理,或者将它传递到对象链中的下一个对象进行处理,依次处理直到链尾。(也就是说当你想对一个请求在需要满足一定条件下进行多次不同的处理时,可采用此模式)

    2. 首先我们定义一个抽象类Handler:

    /**
     * 处理器抽象类
     */
    public abstract class Handler {
    
        public abstract void setNextHandler(Handler handler);
    
        public abstract void handler(MyRequest request);
    
    }

    3. 我们定义一个处理器的优先级注解:

    @Inherited // 允许子类继承父类中的注解
    @Documented // 将注解包含在Javadoc中
    @Target(value = ElementType.TYPE) // 注解可以用于什么地方
    @Retention(value = RetentionPolicy.RUNTIME) // 表示需要在什么级别保存该注解信息
    public @interface HandlerAnnotation {
        int offset() default 0;
    }

    4. 我们定义三个实现类:

    (1)FirstHandler

    @HandlerAnnotation(offset = 1)
    public class FirstHandler extends Handler {
    
        private Handler handler;
    
        @Override
        public void setNextHandler(Handler handler) {
            this.handler = handler;
        }
    
        @Override
        public void handler(MyRequest request) {
            System.out.println("我是第一个责任链的第一个处理类,处理完成,流转到下一个处理类");
            if (Objects.isNull(handler)) {
                System.out.println("处理链已经到底了");
                System.out.println(request);
            }
            this.handler.handler(request);
        }
    }

    (2)SecondHandler

    @HandlerAnnotation(offset = 2)
    public class SecondHandler extends Handler {
    
        private Handler handler;
        @Override
        public void setNextHandler(Handler handler) {
            this.handler = handler;
        }
    
        @Override
        public void handler(MyRequest request) {
            System.out.println("我是责任链模式中的第二个处理类,处理完成,流转到下一个处理类");
            if (Objects.isNull(handler)) {
                System.out.println("处理链已经到底了");
                System.out.println(request);
            }
            handler.handler(request);
        }
    }

    (3) ThirdHander

    @HandlerAnnotation(offset = 3)
    public class ThirdHandler extends Handler {
    
        private Handler handler;
        @Override
        public void setNextHandler(Handler handler) {
            this.handler = handler;
        }
    
        @Override
        public void handler(MyRequest request) {
            System.out.println("我是第三个处理类,处理完成后,流转到下一个处理类");
            if (Objects.isNull(handler)) {
                System.out.println("处理链已经到底了");
                System.out.println(request);
            }
            handler.handler(request);
        }
    }

    4. 我的包路径如下所示:

    5. 在这里我们可以直接在TestChain类中测试处理链模式: 

    /**
     * 测试责任链模式
     * 当你想让一个及以上的对象有机会能够处理某个请求的时候,就是用此模式
     */
    public class TestChain {
    
        public static void main(String[] args) throws IOException {
            FirstHandler firstHandler = new FirstHandler();
            SecondHandler secondHandler = new SecondHandler();
            ThirdHandler thirdHandler = new ThirdHandler();
            firstHandler.setNextHandler(secondHandler);
            secondHandler.setNextHandler(thirdHandler);
            MyRequest request = new MyRequest();
            request.setName("bibi");
            request.setAge(12);
            firstHandler.handler(request);
        }
    }

    执行结果如下:

     

    这里,我们就简单完成了对责任链模式的简单实现,但是在实际开发中,我们如果编写这样的代码是不符合开发规则的,而且难以维护和处理,如果我们有几十个处理器,我们通过上面这种方式来处理显然是不合理的,而且如果当我们想要修改责任链中处理器的执行顺序时,我们也必须要修改代码,虽然一定程度上实现了对请求者和接受者之间的解耦,但是上面这种做法是不是和实际开发的,因此我对此做了优化处理,我们编写一个对责任链的统一处理器类HandlerChain:

    /**
     * 处理器链管理类
     */
    public class HandlerChain {
    
        // 责任链中的处理器优先级排序集合
        private List<Integer> offsets = new ArrayList<>();
        // 责任链的处理类集合
        private final Map<Integer,Handler> handlerList = new LinkedHashMap<>();
    
        public HandlerChain(String packageName) {
            try {
                generateInstances(packageName);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 扫描指定的包名,获取包下所有的类并创建实例
         * @param packageName
         * @throws IOException
         */
        public void generateInstances(String packageName) throws IOException {
                List<Class<?>> allClass = getAllClass(packageName);
                if (CollectionUtils.isEmpty(allClass)) {
                    return;
                }
                // 获取处理器优先级集合
                offsets = allClass.stream().map(t -> t.getAnnotation(HandlerAnnotation.class).offset()).sorted().collect(Collectors.toList());
                // 通过反射机制来生成处理器实例
                allClass.forEach(clazz -> {
                    HandlerAnnotation annotation = clazz.getAnnotation(HandlerAnnotation.class);
                    try {
                        handlerList.put(annotation.offset(), (Handler) clazz.newInstance());
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                });
                // 指定处理器的下一个处理器实例
                handlerList.forEach( (k, v) -> {
                    int size = offsets.size() - 1;
                    int index = offsets.indexOf(k);
                    if (size > index) {
                        v.setNextHandler(handlerList.get(offsets.get(index + 1)));
                    }
                });
        }
    
        /**
         * 扫描指定包,返回包下所有类的类对象集合
         * @param packageName
         * @return
         * @throws IOException
         */
        private List<Class<?>> getAllClass(String packageName) throws IOException {
            List<Class<?>> list = new ArrayList<>();
            // 获取类加载器
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            String path = packageName.replace('.', '/');
            Enumeration<URL> resources = classLoader.getResources(path);
            while (resources.hasMoreElements()) {
                File file = new File(resources.nextElement().getFile());
                // 获取当前文件夹下的所有文件信息
                File[] files = file.listFiles();
                // 获取类的全限类名
                Arrays.asList(files).forEach( f -> {
                    if (f.getName().endsWith(".class")) {
                        try {
                            String s = f.getName();
                            String[] split = s.split("\\.");
                            list.add(Class.forName(packageName + "." + split[0]));
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
            return list;
        }
    
        /**
         * 处理器执行类(总是从链首开始执行)
         * @param request
         */
        public void handler(MyRequest request) {
            handlerList.get(offsets.get(0)).handler(request);
        }

    我们在TestChain类中测试一下:

    /**
     * 测试责任链模式
     * 当你想让一个及以上的对象有机会能够处理某个请求的时候,就是用此模式
     */
    public class TestChain {
    
        public static void main(String[] args) throws IOException {
            MyRequest request = new MyRequest();
            request.setName("bibi");
            request.setAge(12);
            HandlerChain handlerChain = new HandlerChain("com.feifei.demo.chain.handler");
            handlerChain.handler(request);
        }
    }

    运行结果如下所示: 

    我们修改下处理器的执行顺序,将FirstHandler中的offset改为2,SecondHandler中的offset改为1,我们查询运行结果:

     在这里,我们就实现了对责任链处理器的统一管理。当然,这个程序中还有很多细节需要优化,比如说,执行顺序不应该出现相等的情况已经部分对象的执行需要加入非空判断等等,但是大体的实现机制就是这样,后续会对其完善。

    展开全文
  • 前言很多框架如mybatis的插件,servlet的filter,dubbo,安全框架诸如Spring security、apache shiro都会用到设计模式中的责任链模式,所以学习责任链模式成为帮助你学习以上这些框架的一个好的手段之一。...
  • 目录 1.1 简介 1.2 责任链模式优缺点 ...责任链模式为请求创建一个接收者对象链,每个接收者都包含对另一个接收者的引用,如果一个对象不能处理该请求,那么它会把请求传给下一个接收者,依此类...
  • 责任链模式可以很好的帮我们处理对一个请求或者数据的阶梯级链式处理。例如,对于一个OA审批过程,需要从主管->部门经理->分公司经理->总经理…层层递进;或是对于某个叠加数据的层层处理,如一个Json串{A:...
  • 所谓责任链:即是 将一系列的条件限制用一条“链”关联起来,这点类似于Struts中的过滤器一样。多个限制条件对某一个数据或者事物相限制。当链中的前一个链节处理完成以后,就将此处理后的结果交给下一个链节去处...
  • 设计模式 之 责任链模式 责任链模式是一种对象的行为模式。在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。发出这个请求的...
  • 责任链也可以叫做过滤器或者拦截器,只是不同的叫法而已,都是对当前的数据在使用前做相应的处理。 阶段一: 从简单的例子入手。问题描述:有一个字符串,需要对这个字符串做一些处理,然后输出。这里我定义了一个...
  • 管道模式(Pipeline Pattern) 是 责任链模式(Chain of Responsibility Pattern)的常用变体之一。...PS:纯的责任链模式在链上只会有一个处理器用于处理数据,而管道模式上多个处理器都会处理数据。何时使用管道模...
  • 【项目实践】单例模式、责任链模式、策略模式项目实践 【项目实践】商业计算怎样才能保证精度不丢失 【项目实践】使用Vue.js和ElementUI快速实现后台管理系统的界面布局 联系方式 我是「RudeCrab」,一只粗鲁的螃蟹...
  • 责任链模式 212 命令模式 216 解释器模式 219 迭代器模式 222 中介者模式 224 备忘录模式 226 观察者模式 230 状态模式 233 空对象模式 236 策略模式★★★★★ 238 模板模式 240 访问者模式 244 设计模式总结★★★...
  • java 面试题 总结

    2009-09-16 08:45:34
     GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  •  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  • Java开发实战1200例.第2卷.part3

    热门讨论 2013-05-08 22:46:34
    7.3 处理图表的边框 274 实例171 隐藏图表边框 274 实例172 图表边框颜色和笔触 275 7.4 修改图表的图例 277 实例173 设置图例背景色 277 实例174 设置图例边框 278 实例175 设置图例边缘间距 279 实例176 设置图例...
  • Java开发实战1200例.第2卷.part2

    热门讨论 2013-05-08 22:45:35
    7.3 处理图表的边框 274 实例171 隐藏图表边框 274 实例172 图表边框颜色和笔触 275 7.4 修改图表的图例 277 实例173 设置图例背景色 277 实例174 设置图例边框 278 实例175 设置图例边缘间距 279 实例176 设置图例...
  • Java开发实战1200例.第2卷.part1

    热门讨论 2013-05-08 22:44:13
    7.3 处理图表的边框 274 实例171 隐藏图表边框 274 实例172 图表边框颜色和笔触 275 7.4 修改图表的图例 277 实例173 设置图例背景色 277 实例174 设置图例边框 278 实例175 设置图例边缘间距 279 实例176 设置图例...
  • 深入浅出设计模式(中文版)

    热门讨论 2013-03-12 10:48:06
    5.1ChainofResponsibility(责任链模式) 168 5.1.1定义 168 5.1.2现实中的实例——军情的传递 169 5.1.3C#实例——采购分级审批 170 5.1.4Java实例——智能大厦安全系统 174 5.1.5优势和缺陷 178 5.1.6应用...
  • 这就是『责任链模式』? 责任链模式通用代码 建造者模式 :guitar:HTTP+JSON+XML 30页的HTTP HTTP就是这么简单 HTTP常见面试题 HTTP2和HTTPS来不来了解一下? XML就是这么简单 JSON就是这么简单 XML+JSON面试题都...
  • 书名:《Java Web开发实战1200例(第II卷)》(清华大学出版社.卢瀚.王春斌) PDF格式扫描版,全书分为7篇23章,共960页。2011年6月出版。 注:原书只有前20章818页,本人添加了剩余章节重新编辑成完整版本,为了方便...
  • commons-chain 提供实现组织复杂的处理流程的“责任链模式” commons-cli 命令行参数解析 , 由 Werken, Avalon 和 Optz 组成 commons-codec 包含一些通用的编码解码算法。包括一些语音编码器, Hex, Base64, 以及...
  • 欢迎大家来到 Higmin GitHub Project! 创建此工程是为了巩固基础知识 当然能对社区做点贡献也是我小小的心愿~ 本工程包含了 SpringAOP,死锁,JUC同步锁,读-...行为型:责任链模式、命令模式、解释器模式、迭代模式、...
  • Template Method(模板方法模式), Chain Of Responsibleity(责任链模式) 工厂模式:工厂模式是一种经常被使用到的模式,根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例, 通常这一组类...
  • 作者:国外数据作者未知 版本:中文译本 主要内容: 本书以一种清晰并易于接受的方式将深奥的互联网技术问题表达给具有各种背景的读者。作者是互联网最早期的研究者之一,他以独树一帜的方法把技术上的准确性和...
  • Spring面试题

    2015-05-06 07:19:39
    IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样,Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。 BeanFactory 接口 因为 org.springframework.beans....
  • 2.1.2 安装Java开发包(JDK) 20 2.1.3 安装Eclipse开发环境 21 2.1.4 其他开发环境 22 2.1.5 安装Android软件开发包(SDK) 22 2.1.6 安装与配置Android Eclipse插件(ADT) 23 2.1.7 ADT安装释疑 25 2.1.8...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

java责任链模式处理数据

java 订阅