@[toc]
Delegate pattern
Delegate mode, can simplify the program logic, improve the readability of code. The basic function of the Delegate Pattern is to invoke and assign tasks. For example, when the Boss assigns tasks to the project manager, the project manager will assign tasks to each employee according to the actual situation. After the employee completes the tasks, the project manager will report the work progress and results to the Boss.
And proxy mode
Much like the proxy pattern, it can be thought of as a carte Blanche of a static agent in a special case, but the proxy pattern focuses on the process, while the delegate pattern focuses on the outcome. The delegate pattern is widely used in Spring and is used in dispatcherServlets.
case
public interface IEmployee {
void doing(String command);
}
Copy the codePublic class EmployeeA implements IEmployee {@override public void doing(String command) {system.out.println (" EmployeeA implements IEmployee {@override public void doing(String command) {system.out.println (" I'm going to command now. } } ```java public class EmployeeB implements IEmployee { @Override public void doing(String command) { System.out.println(" I am employee B, I am now doing "+ command +" work "); }}Copy the codepublic class Leader implements IEmployee { private Map<String, IEmployee> targets = new HashMap<>(); Public Leader() {targets. Put (" login ", new EmployeeA()); Targets. Put (" encrypt ", new EmployeeB()); } @Override public void doing(String command) { targets.get(command).doing(command); }}Copy the codepublic class Boss { public void command(String command, Leader leader) { leader.doing(command); }}Copy the codeTesting:
Public class DelegateTest {public static void main(String[] args) {public static void main(String[] args) { // Delegate mode is process oriented, delegate mode is result oriented // strategy mode is extensible (external extension), delegate mode is internal flexibility and reuse // The core of delegation is dispatch, dispatch, dispatch // Delegate mode: New Boss().command(" login ",new Leader()); New Boss().command(" encrypt ", new Leader()); }}Copy the code
Application scenarios
Write a DispatcherServlet: The method method that DispatcherServlet assigns to the corresponding controller based on the URL represents the delegate pattern.
public class DispatcherServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
try {
doDispatch(req, resp);
} catch (Exception e) {
e.printStackTrace();
}
}
private void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
String uri = request.getRequestURI();
String mid = request.getParameter("mid");
if ("/getMemberById".equals(uri)) {
new MemberController().getMemberById(mid);
} else if ("/getOrderById".equals(uri)) {
new OrderController().getOrderById(mid);
} else if ("/logout".equals(uri)) {
new SystemController().logout();
} else {
response.getWriter().write("404 Not Found!!");
}
}Copy the codepublic class MemberController { public void getMemberById(String mid){ System.out.println(mid); }}Copy the codepublic class OrderController {
public void getOrderById(String mid){
}
}Copy the codepublic class SystemController {
public void logout(){
}
}
Copy the codeThe strategy pattern
introduce
Application scenario of policy Pattern 1. Suppose there are many classes in the system, and they differ only in their behavior. A system needs to dynamically choose one of several algorithms.
Case 1.
Courses often have preferential activities, and there are many possible preferential strategies, such as: receiving coupons, cash back promotion, group discount. To simulate this in code, we first create an abstract PromotionStrategy of a PromotionStrategy
public interface PromotionStrategy {
void doPromotion();
}Copy the code/** * Created by HFL */ public class CashbackStrategy implements PromotionStrategy {@override public void DoPromotion () {system.out.println (" cash back promotion, return the amount to alipay account "); }}Copy the codePublic implements PromotionStrategy {@override public void doPromotion() { System.out.println(" to receive coupons, the price of the course is directly deducted from the coupon face value "); }}Copy the code** / public implements PromotionStrategy {@override public void doPromotion() { System.out.println(" no promotion "); }}Copy the code/** */ public class GroupbuyStrategy implements PromotionStrategy{@override public void doPromotion() { System.out.println(" group, full 20 people group, whole group enjoy group purchase price "); }}Copy the codeFavourable activity
public class PromotionActivity { private PromotionStrategy promotionStrategy; public PromotionActivity(PromotionStrategy promotionStrategy) { this.promotionStrategy = promotionStrategy; } public void execute(){ promotionStrategy.doPromotion(); }}Copy the codeTest 1:
public class PromotionActivityTest {
public static void main(String[] args) {
PromotionActivity activity618 = new PromotionActivity(new CouponStrategy());
PromotionActivity activity1111 = new PromotionActivity(new CashbackStrategy());
activity618.execute();
activity1111.execute();
}Copy the code
public static void main(String[] args) { PromotionActivity promotionActivity = null; String promotionKey = "CASHBACK"; if(StringUtils.equals(promotionKey,"COUPON")){ promotionActivity = new PromotionActivity(new CouponStrategy()); }else if(StringUtils.equals(promotionKey,"CASHBACK")){ promotionActivity = new PromotionActivity(new CashbackStrategy()); } / /... promotionActivity.execute(); }Copy the codeIn form, this test class is similar to a simple factory based on conditions. So we can change the method of simple factory optimization: write a simple factory class. For production policy classes:
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"; }}Copy the codeRewrite the test class:
public static void main(String[] args) {
String promotionKey = "GROUPBUY";
PromotionActivity promotionActivity = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey));
promotionActivity.execute();
}Copy the code
Case 2: Order payment strategy case
/** * public abstract class Payment {// Public abstract String getName(); // queryBalance protected abstract double queryBalance(String uid); Public MsgResult pay(String uid, Double amount){if(queryBalance(uid) < amount){return new MsgResult(500," failed to pay "," insufficient balance "); } return new MsgResult(200," paid successfully "," paid amount: "+ amount); }}Copy the codePublic class JDPay extends Payment {public String getName() {return "JDPay "; } protected double queryBalance(String uid) { return 500; }}Copy the codePublic class extends Payment {public String getName() {return "AliPay "; } protected double queryBalance(String uid) { return 900; }}Copy the codePublic class UnionPay extends Payment {public String getName() {return "UnionPay "; } protected double queryBalance(String uid) { return 120; }}Copy the codePublic class WechatPay extends Payment {public String getName() {return "WechatPay "; } protected double queryBalance(String uid) { return 256; }}Copy the codePolicy Class (most important)
public class PayStrategy {
public static final String ALI_PAY = "AliPay";
public static final String JD_PAY = "JdPay";
public static final String UNION_PAY = "UnionPay";
public static final String WECHAT_PAY = "WechatPay";
public static final String DEFAULT_PAY = ALI_PAY;
private static Map<String, Payment> payStrategy = new HashMap<String, Payment>();
static {
payStrategy.put(ALI_PAY, new AliPay());
payStrategy.put(WECHAT_PAY, new WechatPay());
payStrategy.put(UNION_PAY, new UnionPay());
payStrategy.put(JD_PAY, new JDPay());
}
public static Payment get(String payKey) {
if (!payStrategy.containsKey(payKey)) {
return payStrategy.get(DEFAULT_PAY);
}
return payStrategy.get(payKey);
}
}Copy the codeResponse object after payment:
public class MsgResult { private int code; private Object data; private String msg; public MsgResult(int code, String msg, Object data) { this.code = code; this.data = data; this.msg = msg; } public String toString(){return (" status: [" + code + "]," + MSG + ", "+ data"); }}Copy the codeTesting:
Public class PayStrategyTest {public static void main(String[] args) { Order Order = new Order("1","20180311001000009",324.45); // MsgResult pay = order.pay(paystrategy.jd_pay); // MsgResult pay = order. // system.out.println (order.pay(paystrategy.ali_pay)); // System.out.println(order.pay(paystrategy.ali_pay)); System.out.println(pay); // arrays.sort (); //Resource // InstantiationStrategy } }Copy the code
Switch to Alipay payment: Just change one parameter:
MsgResult pay = order.pay(PayStrategy.JD_PAY);Copy the code
The policy pattern is reflected in the JDK source code
ParallelSort method of the Arrays class, etc
The compare() method is a policy abstraction implementation.
public class Arrays {
public static <T> void parallelSort(T[] a, int fromIndex, int toIndex,
Comparator<? super T> cmp) {
}
}Copy the codepublic interface Comparator<T> {
int compare(T o1, T o2);
}Copy the codeAdvantages and disadvantages of strategic patterns
Advantages: 1. The strategy mode conforms to the open and close principle. 2. Avoid multiple conditional statements such as if… else… 3. The use of policy mode can improve the confidentiality and security of the algorithm. Disadvantages: 1. The client must know all the policies and decide which policy class to use. 2. There will be many policy classes in the code, which will increase the maintenance difficulty.
Delegate pattern and policy pattern are applied comprehensively
There must be more than just a few controllers in the actual project, usually thousands of controllers, obviously, we can’t write thousands of if… else… . So how do we do it? We do it strategically:
public class DispatcherServlet extends HttpServlet { private List<Handler> handlerMapping = new ArrayList<Handler>(); @Override public void init() throws ServletException { try { Class<? > memberControllerClass = MemberController.class; handlerMapping.add(new Handler() .setController(memberControllerClass.newInstance()) .setMethod(memberControllerClass.getMethod("getMemberById", new Class[]{String.class})) .setUrl("/web/getMemberById.json")); } catch (Exception e) { } } @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { try { doDispatch(req, resp); } catch (Exception e) { e.printStackTrace(); } } private void doDispatch(HttpServletRequest request, HttpServletResponse Response) throws IOException {// if a Serlvet is set for each pair of urls, Url The browser enters String uri = request.getrequesturi (); // Based on the url requested by the user, // Find the url corresponding to a Java class method //3, get the URL to handlerMapping (we consider this as a policy constant) Handler handle = null; for (Handler h : handlerMapping) { if (uri.equals(h.getUrl())) { handle = h; break; } //4, assign the task to Method (by reflection) Object Object = null; try { object = handle.getMethod().invoke(handle.getController(), request.getParameter("mid")); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); Response.getwriter ().write(""); } class Handler { private Object controller; private Method method; private String url; public Object getController() { return controller; } public Handler setController(Object controller) { this.controller = controller; return this; } public Method getMethod() { return method; } public Handler setMethod(Method method) { this.method = method; return this; } public String getUrl() { return url; } public Handler setUrl(String url) { this.url = url; return this; }}}Copy the codeSummary: 1. Using the delegate pattern, you can write more elegant code. 2. Strategy mode, can eliminate a lot of redundant code and multiple conditional transfer statements in the program. 3. Delegation mode belongs to behavioral mode, and its basic function is to be responsible for the scheduling and assignment of tasks. Similar to the agent mode, delegation mode can be regarded as the full agent of a static agent in special cases, but the agent mode focuses on the process, while the delegation mode focuses on the results. 4. Strategy Pattern is behavioral Pattern :(Strategy Pattern) it defines algorithm families and encapsulates them separately so that they can be replaced with each other, so that the change of the algorithm will not affect the users who use the algorithm. Can avoid multiple branches of if… else… And switch statements.
Personal wechat public number: search: in full bloom de every day irregular push related articles, look forward to growing up with you!!
After the
Thank you for your support