Java design pattern-responsibility chain model

Blog Expert BenefitsC Currency Exchange platform on-lineOctober Recommended Articles Summarydescription of the cyber attack on November 28 csdnJava Design Pattern--responsibility chainCategory: Java Design patterns-java 2012-03-23 15:19 4045 people reading reviews (4) favorite reports Design mode javafilterstringclassstruts

The goal of the responsibility chain model (Chain of Responsibility) is to allow multiple objects to have the opportunity to process requests, thus avoiding the coupling between the sender and receiver of the request. Connect these objects as a chain and pass the request along this chain until an object is processed.

You may want to add different processing logic to the request when you are dealing with a user's request, and you can use the responsibility chain to design it at this time. It is convenient to add a processing node when you need to add a processing logic.

Now our requirement is to process the user's request, to layer the user's submitted string information, and to return the result when the processing is complete, and to process the returned string in the same order that it was processed when the returned case was processed in the reverse order.

First set up the user request and receive object requests and response:

[Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Public class Request {
8. String Requeststr;
12. Public String Getrequeststr () {
14. return requeststr;
16. }
20. public void Setrequeststr (String requeststr) {
22. this.requeststr = requeststr;
24. }
28. }

Package Com.lcq.filter;public class Request {string Requeststr;public string Getrequeststr () {return requeststr;} public void Setrequeststr (String requeststr) {this.requeststr = Requeststr;}}

[Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Public class Response {
8. String Responsestr;
12. Public String Getresponsestr () {
14. return responsestr;
16. }
20. public void Setresponsestr (String responsestr) {
22. this.responsestr = responsestr;
24. }
28. }

Package Com.lcq.filter;public class Response {string Responsestr;public string Getresponsestr () {return responsestr;} public void Setresponsestr (String responsestr) {this.responsestr = Responsestr;}}

We will process the logical abstraction of user information into one filter, further abstracting out the filter interface filter:
[Java]View Plaincopyprint?

1. Package com.lcq.filter;
3. Public interface Filter {
4. public void DoFilter (Request request, Response Response,filterchain chain);
6. }

Package Com.lcq.filter;public interface Filter {public void DoFilter (Request request, Response Response,filterchain Chain);}

Note that there is a filterchain variable in the Dofilter method parameter in the Filte interface, and we then build the Filterchain class: [Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Import java.util.ArrayList;
8. Import java.util.List;
12. Public class Filterchain implements Filter {
14. list<filter> filters = new arraylist<filter> ();
16. int index = 0;
20. Public Filterchain addfilter (Filter f) {
22. This.filters.add (f);
24. return this ;
26. }
30. @Override
32. public void DoFilter (Request request, Response Response, Filterchain chain) {
34. if (index = = filters.size ())
36. return;
38. Filter f = filters.get (index);
40. index++;
42. F.dofilter (Request, response, chain);
44. }
46. }

Package Com.lcq.filter;import Java.util.arraylist;import Java.util.list;public class Filterchain implements filter { list<filter> filters = new arraylist<filter> (); int index = 0;public filterchain addfilter (Filter f) {This.fil Ters.add (f); return this;} @Overridepublic void DoFilter (Request request, Response Response, Filterchain chain) {if (index = = filters.size ()) return; Filter f = filters.get (index); Index++;f.dofilter (request, response, chain);}}

The filter interface is inherited in Filterchain, which implements the Dofilter method, and in Filterchain there is an index variable that is used to mark which filter is currently accessed, which is stored in the ArrayList, In this way, users can implement their own filters when they are in use, write their own processing logic, add their own filters to ArrayList, and then call Filterchain's Dofilter method to traverse the entire chain of responsibility.

Below we write three filters:

Htmlfilter class:

[Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. /**
8. * Filter script elements in HTML
10. * @author LCQ
12. *
14. */
16. Public class Htmlfilter implements Filter {
20. @Override
22. public void DoFilter (Request request, Response Response,filterchain chain) {
24. Request.requeststr = Request.getrequeststr (). Replace ("<", "[")
26. . replace (">", "]--------htmlfilter");
28. Chain.dofilter (Request, response, chain);
30. Response.responsestr + = "--------htmlfilter";
34. }
38. }

Package com.lcq.filter;/** * Filter script elements in HTML * @author LCQ * */public class Htmlfilter implements filter {@Overridepublic Voi D DoFilter (Request request, Response Response,filterchain chain) {request.requeststr = Request.getrequeststr (). Replace ("<", "["). Replace (">", "]--------htmlfilter"); Chain.dofilter (request, response, chain); response.responsestr + = "--------Htmlfilter";}}

Sesitivefilter class:
[Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Public class Sesitivefilter implements Filter {
10. @Override
12. public void DoFilter (Request request, Response Response, Filterchain chain) {
14. Request.requeststr = Request.getrequeststr (). Replace ("sensitive", "" ")
16. . replace ("Cat Cat", "haha------sesitivefilter");
18. Chain.dofilter (Request, response, chain);
20. Response.responsestr + = "------Sesitivefilter";
24. }
28. }

Package Com.lcq.filter;public Class Sesitivefilter implements filter {@Overridepublic void DoFilter (Request request, Response Response, Filterchain chain) {request.requeststr = Request.getrequeststr (). Replace ("sensitive", "  "). Replace (" Cat "," haha------sesitivefilter "); Chain.dofilter (request, response, chain); Response.responsestr + ="------ Sesitivefilter ";}}

Facefilter class:
[Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Public class Facefilter implements Filter {
10. @Override
12. public void DoFilter (Request request, Response Response, Filterchain chain) {
14. Request.requeststr = Request.getrequeststr (). Replace (":)",
16. "^v^-------facefilter");
18. Chain.dofilter (Request, response, chain);
20. Response.responsestr + = "-------Facefilter";
24. }
28. }

Package Com.lcq.filter;public Class Facefilter implements filter {@Overridepublic void DoFilter (Request request, Response Response, Filterchain chain) {request.requeststr = Request.getrequeststr (). replace (":)", "^v^------- Facefilter "); Chain.dofilter (request, response, chain); Response.responsestr + ="-------Facefilter ";}}

Finally write the test class: [Java]View Plaincopyprint?

2. Package com.lcq.filter;
6. Public class Main {
8. public static void Main (string[] args) {
10. String message = "Sensitive vocabulary, Chongqing,<script> Hide and seek:)";
12. Request Request = new request ();
14. REQUEST.SETREQUESTSTR (message);
16. Response Response = new Response ();
18. RESPONSE.SETRESPONSESTR ("response");
20. Filterchain FC = new Filterchain ();
22. Fc.addfilter (new Htmlfilter ()). addfilter (new Sesitivefilter ());
26. Filterchain FC2 = new Filterchain ();
28. Fc2.addfilter (new Facefilter ());
30. Fc.addfilter (FC2);
32. Fc.dofilter (Request, RESPONSE,FC);
34. System.out.println ("request =" + REQUEST.GETREQUESTSTR ());
36. SYSTEM.OUT.PRINTLN ("response =" + RESPONSE.GETRESPONSESTR ());
38. }
42. }

Package Com.lcq.filter;public class Main {public static void main (string[] args) {String message = "sensitive vocabulary, Chongqing,<script> Hide and seek:) "; Request Request = new request (); REQUEST.SETREQUESTSTR (message); Response Response = new Response (); Response.setresponsestr ("Response"); Filterchain FC = new Filterchain (); Fc.addfilter (new Htmlfilter ()). addfilter (New Sesitivefilter ()); Filterchain FC2 = new Filterchain () Fc2.addfilter (New Facefilter ()); Fc.addfilter (FC2); Fc.dofilter (request, Response, FC); SYSTEM.OUT.PRINTLN ("request =" + REQUEST.GETREQUESTSTR ()); SYSTEM.OUT.PRINTLN ("response =" + RESPONSE.GETRESPONSESTR ());}}

Two places should be noted in the above example:

1. The filter interface is inherited in the filterchain we build, so the filterchain can be used like other filters in the test class, which greatly improves the flexibility.

2. For the implementation of the order of access processing of the responsibility chain, the problem is solved by using the idea of recursion, so that the first called node is reversed in the order in which it invokes the filter when it processes the return result. This solution is more common and ingenious in using struts and other frameworks to implement filters and interceptors.

Java design pattern-responsibility chain model