Shulou(Shulou.com)06/02 Report--

This article mainly explains "what is the Spring delegation mode". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the Spring delegation mode".

Understand

First of all, delegation patterns do not belong to 23 design patterns.

The so-called delegation, personal understanding is: to achieve the final result of the matter to other people or middlemen to do, I just want the final result, other things, by the person I appointed to arrange.

To put it more bluntly, for example, we want to build a building, and after it is finished, I will paint it. I certainly can't do these things myself, so I will find a "contractor" to help me finish it. I just have to tell the "contractor" that I want to build the house, I want to paint the house, and so on. I don't care about anything else, and I can finally deliver it to me after painting the house. Then it is impossible for the "contractor" to do it on his own. at this time, he will find someone to build the building, paint, and so on; then he will ask them to do it, and when he is done, he will give me a house that has been painted. This process is an embodiment of the delegation model.

The delegation pattern looks very similar to what we called "static mode", which can be said to be the full agent of a static agent in a special case. But there is a difference. The "static agent" focuses more on the process, while the "delegation mode" focuses only on the "result".

Example

Using the example above, let's use the code to implement the following:

Code

First create a worker abstract class interface, all of which have the function of Worker:

/ * Abstract worker * * @ author EamonZzz * @ date 2019-10-26 15:09 * / public interface Worker {/ * work * * @ param command follow orders * / void doWork (String command);}

Then there is a worker A, bricklaying is very good, very suitable for building, WorkerA:

/ * worker An is good at bricklaying, so it is better to call in to build a building * * @ author EamonZzz * @ date 2019-10-26 15:11 * / public class WorkerA implements Worker {@ Override public void doWork (String command) {System.out.println ("I am worker A, the contractor calls me" + command);}}

Then there is a worker B, who is a professional painter WorkerB:

/ * worker An is good at bricklaying, so it is better to call in to build a building * * @ author EamonZzz * @ date 2019-10-26 15:11 * / public class WorkerA implements Worker {@ Override public void doWork (String command) {System.out.println ("I am worker A, the contractor calls me" + command);}}

Let's find a contractor. The contractor is also a worker, but this contractor mainly organizes workers to work, Contractor:

/ * contractor (also a worker), undertake the project, assign workers * * @ author EamonZzz * @ date 2019-10-26 15:07 * / public class Contractor implements Worker {private Map targets = new HashMap (); public Contractor () {targets.put ("building", new WorkerA ()); targets.put ("painting", new WorkerB ()) } / * the contractor does not need to work by himself * @ param command * / @ Override public void doWork (String command) {targets.get (command) .doWork (command);}}

Finally, there are people who need to paint buildings, Boss:

/ * I, who need to build a building, give the order of building and painting to the contractor * * @ author EamonZzz * @ date 2019-10-26 15:06:09 * * / public class Boss {/ * issue a request * * @ param command * @ param contractor * / public void command (String command, Contractor contractor) {contractor.doWork (command);}}

Take a look at the test class:

/ * @ author EamonZzz * @ date 2019-10-26 15:23 * / public class BossTest {@ Test public void test () {Boss boss = new Boss (); boss.command ("Building", new Contractor ()); boss.command ("painting", new Contractor ());}}

End result:

I am worker A, the contractor asked me to build the building, I am worker B, and the contractor asked me to paint the class diagram.

When this process was simulated, Boss gave the contractor an order that I would build a building, and then the contractor went to find someone who could build the building to build the building; then he ordered that my building needed to be painted, and the contractor went to find a painter to do it.

Scenarios that use delegation mode in SpringMVC

In SpringMVC, there is also a delegate pattern, such as our most common DispatcherServlet, which is used to distribute requests from our front-end URL to the corresponding Controller controller to process the requests, so how does it complete this process?

In fact, combined with the above example scenario, it is not difficult to analyze the principle.

Summary

As for the difference between "delegate mode" and "static proxy mode", it has been mentioned at the beginning of the article that "static proxy" focuses on process, and both proxy class and principal class have to implement an interface; while "delegate mode" pays more attention to results, Boss does not need to implement the interface Worker. Take the ability to knock code, for example, the Boss class of the "static proxy" needs to be able to knock the code, while the Boss in "delegate mode" does not need to be able to knock the code.

Thank you for your reading, the above is the content of "what is Spring delegation mode". After the study of this article, I believe you have a deeper understanding of what is Spring delegation mode, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.