------Broker Pattern for Java 23 design Patterns

One Broker Mode (mediator)

The mediator pattern is also used to reduce the coupling between class classes, because if there is a dependency between class classes, it is not conducive to the expansion and maintenance of functions, because as long as you modify an object, the other associated objects will have to be modified. If you use the mediator mode, just care about the relationship with the Mediator class, the relationship between the specific class classes and scheduling to mediator on the line, which is a bit like the role of spring container. First look at the picture:

User Class Unified interface, User1 and User2 are different objects, there is a correlation between the two, if you do not use the intermediary mode, you need to hold a reference to each other, so that the coupling is very high, for the understanding of decoupling, introduced the Mediator class, provides a unified interface, Mymediator for its implementation class, which holds User1 and User2 instances, used to achieve User1 and User2 control. So User1 and User2 two objects are independent of each other, they just need to keep good and mediator relationship between the line, the rest of all by the Mymediator class to maintain! Basic implementation:

1. Public interface Mediator {
2. public void Createmediator ();
3. public void Workall ();
4. }

 

2. Public class Mymediator implements mediator {
6. Private User user1;
8. Private User User2;
12. Public User GetUser1 () {
14. return user1;
16. }
20. Public User GetUser2 () {
22. return user2;
24. }
28. @Override
30. public void Createmediator () {
32. User1 = new User1 (this);
34. User2 = new User2 (this);
36. }
40. @Override
42. public void Workall () {
44. User1.work ();
46. User2.work ();
48. }
50. }

 

1. Public abstract class User {
3. Private mediator mediator;
5. Public Mediator Getmediator () {
6. return mediator;
7. }
9. Public User (mediator mediator) {
10. This.mediator = Mediator;
11. }
13. public abstract void work ();
14. }

 

1. public class User1 extends User {
3. Public User1 (mediator mediator) {
4. Super (mediator);
5. }
7. @Override
8. public void work () {
9. System.out.println ("User1 exe!");
10. }
11. }

 

1. public class User2 extends User {
3. Public User2 (mediator mediator) {
4. Super (mediator);
5. }
7. @Override
8. public void work () {
9. System.out.println ("User2 exe!");
10. }
11. }

Test class:

1. public class Test {
3. public static void Main (string[] args) {
4. Mediator Mediator = new Mymediator ();
5. Mediator.createmediator ();
6. Mediator.workall ();
7. }
8. }

Output:

User1 exe!
User2 exe!

Reprinted from Https://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

------Broker Pattern for Java 23 design Patterns