1, Delegation mode
In the delegate mode, the delegate mode is similar to the delegate mode. In the delegate mode, the delegate mode can be regarded as a result of the delegate mode.
give an example:
The Boss assigns tasks to the project manager. The project manager will distribute work tasks to each employee according to the actual situation. After the employee completes the work tasks, the project manager will report the work progress and results to the Boss.
Create employee IEmployee interface
public interface IEmployee { public void doing(String command);}
Create employee class EmployeeA
public class EmployeeA implements IEmployee { @Override public void doing(String command) { System.out.println("I'm an employee A,I'll start now" + command + "work"); }}
Create employee EmployeeB class
public class EmployeeB implements IEmployee { @Override public void doing(String command) { System.out.println("I'm an employee B,I'll start now" + command + "work"); }}
Create a project manager's class
public class Leader implements IEmployee { private Map<String,IEmployee> targets = new HashMap<String,IEmployee>(); public Leader() { targets.put("encryption",new EmployeeA()); targets.put("Sign in",new EmployeeB()); } //Public void doing (string command) {targets. Get (command). Doing (command);} }
Create a Boss class and issue a command
public class Boss { public void command(String command,Leader leader){ leader.doing(command); }}
Test code class
new Boss().command("Sign in",new Leader());
The above code can well reflect the scene of the project manager's work assignment, and it is also the embodiment of the delegation mode.
2, Strategy mode
Strategy Pattern refers to defining algorithm families and encapsulating them separately so that they can be replaced with each other. This mode makes the change of algorithm not affect the users who use the algorithm.
Application scenario
-
If there are many classes in the system, and their difference only lies in their behavior
-
A system needs to dynamically choose one of several algorithms
Advantages:
-
The strategy mode conforms to the opening and closing principle.
-
Avoid using multiple conditional transition statements, such as if else... Statement, switch statement
-
Using policy mode can improve the confidentiality and security of the algorithm
Disadvantages:
-
The client must know all the policies and decide which policy class to use.
-
Many policy classes will be generated in the code, which increases the difficulty of maintenance
give an example
Jingdong Mall sometimes has many preferential activities, such as receiving coupon deduction, cash back promotion and group discount
Create promotion policy class
public interface PromotionStrategy { void doPromotion();}
Then create CouponStrategy class of coupon deduction strategy, cashback promotion strategy class, GroupbuyStrategy class of group discount strategy and EmptyStrategy class of no discount strategy respectively:
public class CashbackStrategy implements PromotionStrategy { public void doPromotion() { System.out.println("Cash back promotion,Transfer the returned amount to Alipay account"); }}
public class CouponStrategy implements PromotionStrategy { public void doPromotion() { System.out.println("Receive coupons,The price of the course is deducted directly from the face value of the coupon"); }}
public class EmptyStrategy implements PromotionStrategy { public void doPromotion() { System.out.println("No promotions"); }}
public class GroupbuyStrategy implements PromotionStrategy{ public void doPromotion() { System.out.println("The whole group can enjoy the group purchase price"); }}
Create promotion activity class
public class PromotionActivity { private PromotionStrategy promotionStrategy; public PromotionActivity(PromotionStrategy promotionStrategy) { this.promotionStrategy = promotionStrategy; } public void execute(){ promotionStrategy.doPromotion(); }}
Test class
PromotionActivity activity618 = new PromotionActivity(new CouponStrategy()); PromotionActivity activity1111 = new PromotionActivity(new CashbackStrategy()); activity618.execute(); activity1111.execute();
There is no problem with the above code verification, but in the actual situation, if there are many activities, we need to change the verification, so we can optimize and refactor in combination with singleton and factory mode
Create factory class
public class PromotionStrategyFactory { private static Map<String,PromotionStrategy> PROMOTION_STRATEGY_MAP = new HashMap<String, PromotionStrategy>(); static { PROMOTION_STRATEGY_MAP.put(PromotionKey.COUPON,new CouponStrategy()); PROMOTION_STRATEGY_MAP.put(PromotionKey.CASHBACK,new CashbackStrategy()); PROMOTION_STRATEGY_MAP.put(PromotionKey.GROUPBUY,new GroupbuyStrategy()); } private static final PromotionStrategy NON_PROMOTION = new EmptyStrategy(); private PromotionStrategyFactory(){} public static PromotionStrategy getPromotionStrategy(String promotionKey){ PromotionStrategy promotionStrategy = PROMOTION_STRATEGY_MAP.get(promotionKey); return promotionStrategy == null ? NON_PROMOTION : promotionStrategy; } private interface PromotionKey{ String COUPON = "COUPON"; String CASHBACK = "CASHBACK"; String GROUPBUY = "GROUPBUY"; }
The client code can be written like this
String promotionKey = "GROUPBUY"; PromotionActivity promotionActivity = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey)); promotionActivity.execute();
Which activity is the parameter passed in from the front end? In this way, the original processing logic will not be affected!