Design Mode (Java)-factory mode + policy mode + facade Mode

Scenario: design a sub-module in a transaction system ------ fee deduction sub-module

The fee deduction submodule consists of two parts:

1. IC card and transaction information

The IC card includes two types of amounts: fixed amount and free amount. The transaction information Class records each transaction.

2. Deduction strategies

There are two types of deduction policies:

A. Fixed Amount of IC Card = existing fixed amount of IC card-transaction amount/2

Free amount of IC Card = Free amount of IC card-transaction amount/2

B. All expenses are deducted from the free amount of the IC card.

Class chart implementation:

It mainly involves the following roles:

1. IC card and transaction

2. Debit Policy Interface

3. Deduction policy encapsulation class

4. Policy Enumeration class

5. Policy Factory

6. deduction module Encapsulation

7. Scenario

CodeImplementation

Card class:

 

Package Org. apache. java. designpatter. factoryandstrategy; public class card {private string no; private int steadymoney; // Private int freemoney of the fixed transaction amount in the card; // Public String getno () {return no ;} public void setno (string no) {No = no;} public int getsteadymoney () {return steadymoney;} public void setsteadymoney (INT steadymoney) {This. steadymoney = steadymoney;} public int getfreemoney () {return freemoney;} public void setfreemoney (INT freemoney) {This. freemoney = freemoney ;}}
 

Trade:

 

 

 
Public class trade {private string tradeno; private int Mount; // transaction amount Public String gettradeno () {return tradeno;} public void settradeno (string tradeno) {This. tradeno = tradeno;} public int getmount () {return Mount;} public void setmount (INT mount) {This. mount = Mount ;}}
 

Deduction Policy Interface

 

 

 
Public interface ideduction {public Boolean exec (card, trade );}
 

Deduction policies

 

 

 
Public class steadydeduction implements ideduction {public Boolean exec (card, trade Trade) {int halfmoney = (INT) math. RINT (trade. getmount ()/2.0); card. setsteadymoney (card. getsteadymoney ()-halfmoney); card. setfreemoney (card. getfreemoney ()-halfmoney); Return true ;}} public class freededuction implements ideduction {public Boolean exec (card, trade Trade) {card. setfreemoney (card. getfreemoney ()-trade. getmount (); Return true ;}}
 

Deduction policy Encapsulation

 

 

Public class deductioncontext {private ideduction deduction; Public deductioncontext (ideduction deduction) {This. deduction = deduction;} public Boolean exec (card, trade Trade) {return this.deduction.exe C (card, trade );}}
 

Rule Enumeration

 

 

 
Public Enum strategymanage {steadydeduction ("org. apache. java. designpatter. factoryandstrategy. steadydeduction "), freededucation (" org. apache. java. designpatter. factoryandstrategy. freededuction "); string value =" "; private strategymanage (string value) {This. value = value ;}public string getvalue () {return value ;}}
 

Policy Factory

 

 

Public class strategyfactory {public static ideduction getdeduction (strategymanage Strategy) {ideduction deduction = NULL; try {deduction = (ideduction) class. forname (strategy. getvalue ()). newinstance ();} catch (exception e) {e. printstacktrace ();} return deduction ;}}
 

Deduction module Encapsulation

 

 

 
Public class deductionfacade {public static card deduct (card, trade Trade) {strategymanage Reg = getdeducationtype (trade); // obtain the consumption policy ideduction deduction = strategyfactory. getdeduction (REG); // initialize a consumption policy object deductioncontext context = new deductioncontext (deduction); // execute the encapsulation context.exe C (card, trade); // execute the deduction return card ;} private Static strategymanage getdeducationtype (trade Trade) {If (trade. gettradeno (). contains ("ABC") {return strategymanage. freededucation;} else {return strategymanage. steadydeduction ;}}}
 

Scenario

 

 

 
Public class client {Private Static card initcard () {card = new card (); card. setno (""); card. setfreemoney (0); card. setsteadymoney (0); Return card;} Private Static trade inittrade () {Trade trade Trade = new trade (); trade. setmount (0); trade. settradeno (""); return trade;} public static void main (string [] ARGs) {card = initcard (); Boolean flag = true; while (FLAG) {Trade trade = inittrade (); deductionfacade. deduct (card, trade );}}}
 

 

 

The following design patterns are used in this scenario:

Strategy Mode: The load encapsulates the deduction policy to ensure that the two policies can be switched freely.

Factory mode: the Policy mode must expose the problem of a specific policy. The factory mode directly generates a specific policy object, and other modules do not need to rely on specific policies.

Facade mode: It is responsible for sealing and Transferring Complex fee deduction systems. The result of the transfer is to prevent high-level modules from going deep into the subsystem and provide high cohesion and low coupling characteristics of the system.