Design Pattern Catena of Curae Pattern

Design Pattern Catena of Cura Pattern

2024-07-12

1. conceptus

Catena responsabilitatis Pattern: Mittens et accipientis petitionem fuge copulationem, da multiplicia obiectis facultatem recipiendi petitionem, haec obiecta in catena coniunge, et petitionem per hanc catenam transi donec res attingat.Vinculum officii exemplar est aobject morum exemplar。

2. Structure

nucleus catenae structurae formarum officiorum est introductio aabstractum processus
Insert imaginem descriptionis hic

Ut e schemate videri potest, catena officiorum formarum structurae schematis continet duas partes sequentes:
(1) Handler (tracto abstracto): Interfaciem definit in petitionibus processus et generaliter designatur ut genus abstractum. Quia tractatores diversi concretae postulationes aliter tractant, petitio abstracta tractandi methodi definiuntur in illis.Quia subordinatum cuiusque processus adhuc est processus, obiectum processus speciei abstracti (successor in structura schematis) definitur in processu abstracto ut eius subordinatus.Quote . Per hanc comparationem tracti in catenam coniungi possunt.
(2) ConcreteHandler (tracto concreto): Subclassis tracto abstracti est et petitiones usorum tractare potest.Abstracta petitio processus methodi definitae in processu abstracto perficiatur in processu concreto ordinis, et potest accedere proximum obiectum in catena ad assequendum.Request procuretEffectum.
In catenis responsabilitatis exemplaris, cuiusque rei notae ad posteros pertinent catenae formandae. Petitiones hanc catenam transmittuntur donec id quod in catena tandem pertractat postulatio. Haec ratio permittit ut catenam dynamice componat et officia assignet sine cliente afficiendi.

3.Typical code

Coro vinculi responsabilitatis exemplar in consilio classis tracto abstracti consistit.

abstract class Handler {
    //维持对下家的引用
    protected Handler successor;
    
    public void setSuccessor(Handler successor) {
        this.successor = successor;    
    }
    
    public abstract void handleRequest(String request);
}
1
2
3
4
5
6
7
8
9
10

In codice praedicto, processus abstractus obiectivum relationis ad proximum processum definit ut petitionem ad processum proximum transmittat. Accessor huius rei defendi potest, quae in suis classibus adhiberi potest.

Tractatores concreti sunt subclasses tractorum abstractorum et duas functiones maiores habent;

Ad petitiones processus, differentes processus specificae efficiunt petitionem abstractam processus methodi tractandae Request() in diversis formis;
Postulationem transmittere. Si petitio processui processui excedit, petitio ad proximum processum transmitti potest.

Typical codicem pro certo tracto classis talis est:

class ConcreteHandler extends Handler {
    public void handleRequest(String request) {
        if (请求满足条件) {
            //处理请求        
        } 
        else {
            this.successor.handleRequest(request);  //转发请求
        }
    }
}
1
2
3
4
5
6
7
8
9
10

4. Causa Study I: Purchase Ordinis Approbatio Ratio

Ratio quaedam emptionis ordinis approbatio hierarchica est, id est, approbata a fabris in diversis gradibus secundum quantitatem emptionis.

Moderator potest approbare ordines emptionis minus quam 50,000 Yuan, praeses vice-praeses potest ordines emptionis [5, 100,000 Yuan], praeses tabulae approbare potest ordines emptionis [10, 500,000 Yuan], et ordines emptionis 500,000 Yuan et supra.
Insert imaginem descriptionis hic

Cum probatores uniuscuiusque dignitatis subordinatos habeant (praeter tabulam moderatorum), et mores communes, omnes approbationes suas successores promovendi implicant. Ita designant approbatorem classis tamquam processus abstractus;

//审批者类: 抽象处理者
abstract class Approver {
    protected Approver successor;  //定义后继对象
    protected String name;  //审批者姓名

    public Approver(String name) {
        this.name = name;
    }

    //设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    public abstract void processRequest(PurchaseRequest request);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Deinde quaelibet positio, ut processus specificus, processum abstractum efficere debet;

//主任: 具体处理者
class Director extends Approver{
    public Director(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 50000) {
            System.out.println(
                    MessageFormat.format("主任 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);  //转发请求
        }
    }
}

//副董事长：具体处理类
class VicePresident extends Approver{
    public VicePresident(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 100000) {
            System.out.println(
                    MessageFormat.format("副董事长 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);
        }
    }
}

//董事长类：具体处理者
class President extends Approver{
    public President(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 500000) {
            System.out.println(
                    MessageFormat.format("董事长 {0} 审批采购单:{1}, 金额:{2}元, 采购目的:{3}。",
                            this.name, request.getNumber(), request.getAmount(), request.getPurpose())
            );
        } else {
            this.successor.processRequest(request);
        }
    }
}

//董事会类：具体处理者
class Congress extends Approver{
    public Congress(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        System.out.println(
                MessageFormat.format("召开董事会 审批采购单:{0}, 金额:{1}元, 采购目的:{2}。",
                        request.getNumber(), request.getAmount(), request.getPurpose())
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

Categoriam emptionis alium ordinem definire sicut scopus probandus est;

//采购单: 请求类
class PurchaseRequest {
    private double amount;  //采购金额
    private int number;  //采购单编号
    private String purpose;  //采购目的

    public PurchaseRequest(double amount, int number, String purpose) {
        this.amount = amount;
        this.number = number;
        this.purpose = purpose;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getPurpose() {
        return purpose;
    }

    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Scribere clientis test code:

class Client {
    public static void main(String[] args) {
        Approver kangXi, yongZheng, qianLong, hanLinYuan;
        kangXi = new Director("康熙");
        yongZheng = new VicePresident("雍正");
        qianLong = new VicePresident("乾隆");
        hanLinYuan = new Congress("翰林院");

        //创建职责链
        kangXi.setSuccessor(yongZheng);
        yongZheng.setSuccessor(qianLong);
        qianLong.setSuccessor(hanLinYuan);

        //创建采购单
        PurchaseRequest pr1 = new PurchaseRequest(45000, 10001, "购买刀");
        kangXi.processRequest(pr1);

        PurchaseRequest pr2 = new PurchaseRequest(60000, 10002, "购买枪");
        kangXi.processRequest(pr2);

        PurchaseRequest pr3 = new PurchaseRequest(160000, 10003, "购买火炮");
        kangXi.processRequest(pr3);

        PurchaseRequest pr4 = new PurchaseRequest(800000, 10004, "购买军舰");
        kangXi.processRequest(pr4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Compilare et programma currere, output hoc est:

主任 康熙 审批采购单:10,001, 金额:45,000元, 采购目的:购买刀。
副董事长 雍正 审批采购单:10,002, 金额:60,000元, 采购目的:购买枪。
董事长 乾隆 审批采购单:10,003, 金额:160,000元, 采购目的:购买火炮。
召开董事会 审批采购单:10,004, 金额:800,000元, 采购目的:购买军舰。
1
2
3
4

5. Casus Analysis 2: Class Negotium Processing

Causam inspiciamus, quae paulo aliter a superioribus est, quae dilatare potest intellectum vinculorum responsabilitatis exemplar et missiones quibus applicari potest.

Prima differentia: tractans postulatio methodi valorem reditum habet, et informationes reduci potest ad exercitum pascere;
Secunda differentia: "Ratio Approbatio Purchase Ordinis" causa processus petitionem primum ac deinde incedit rogationem, dum "Class Negotium Processing" causa postulationem primum promovet et deinde petitionem procedit.

Schola quaedam officia classi ad dispensandum assignabit. Hae rationes unum, duo, tria, quattuor etc. In genere magister tria genera officiorum tractare potest unum, duo, tria, et monitor duo genera tractare potest. unum, duo. Cum magister classium munus acceperit, primum tradet ducem MANIPLUS ad expediendas si negotium scholae ad expediendum. Si altera classis id tractare non potest, magister classium ipse dux Manipulus ipsum tractabit; Et cum illud non attingunt, opiniones sursum dabunt.

Tracto genus inferius sicut processus abstractus designatur:
Cum tu et subditi tui necessario quaedam negotia ordinis tractare possint et feedback sursum est, postulatio processus methodi debet habere valorem reditus boolean ut superiori dicas an negotium tractare possit.

abstract class Handler {
    protected Handler successor;  //定义后继对象

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract boolean handleRequest(String taskName);
}
1
2
3
4
5
6
7
8
9

Infra, magister classium, dux MANIPLUS, et sodalis studiorum Institutorum tamquam tractores specifici designantur.
Defalta, magister classium monitori primum negotium dabit, et monitor negotium studii sodalis committens per defaltam dabit. Studiorum membrum solum unum genus operis tractare potest, et si illud tractare non potest falsum redibit;
Si falsae sunt opiniones receptae a duce MANIPLUS, ipse tractabit.
Si falsus est a capite doctoris opiniones, ipse tractabit. Operas tantum, duo, et tria tractare potest.

//班主任
class HeadTeacher extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled = successor.handleRequest(taskName);
        if (handled) {
            return true;
        }
        if (taskName.equals("one") || taskName.equals("two") || taskName.equals("three")) {
            System.out.println("班主任处理了该事务");
            return true;
        }

        return false;
    }
}

//班长
class Monitor extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled = successor.handleRequest(taskName);
        if (handled) {
            return true;
        }
        if (taskName.equals("one") || taskName.equals("two")) {
            System.out.println("班长处理了该事务");
            return true;
        }

        return false;
    }
}

//学习委员
class StudyCommissary extends Handler{
    @Override
    public boolean handleRequest(String taskName) {
        boolean handled;
        if (successor == null) {  //注意学习委员可能没有下家，所以这里判一下是否为空
            handled = false;
        } else {
            handled = successor.handleRequest(taskName);
        }

        if (handled) {
            return true;
        }
        if (taskName.equals("one")) {
            System.out.println("学习委员处理了该事务");
            return true;
        }

        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

Scribere clientis test code:
Sub-domos pro singulis positis constitue, sed nota quod nulla sub-doma est studiorum sodalium.
Item, si opus est quod magister caput tractare non potest, linea stipendii imprimendi rationem explicandi habet.

public class SchoolClient {
    public static void main(String[] args) {
        Handler headTeacher, monitor, studyCommissary;
        headTeacher = new HeadTeacher();
        monitor = new Monitor();
        studyCommissary = new StudyCommissary();

        headTeacher.setSuccessor(monitor);
        monitor.setSuccessor(studyCommissary);
        studyCommissary.setSuccessor(null);  //没有下一职责人

        startRequest(headTeacher, "one");
        startRequest(headTeacher, "two");
        startRequest(headTeacher, "three");
        startRequest(headTeacher, "four");
    }

    private static void startRequest(Handler headTeacher, String taskName) {
        if (! headTeacher.handleRequest(taskName)) {
            System.out.println("该班级处理不了此类任务！");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Compilare et programma currere, output hoc est:

学习委员处理了该事务
班长处理了该事务
班主任处理了该事务
该班级处理不了此类任务！
1
2
3
4

6. Lorem missionibus

Vinculum Officii exemplar considerari potest in adiunctis sequentibus:

Plures res eandem petitionem tractare possunt. Praecipuum obiectum quod tractat instantiam tempore temporis determinabitur.Cliens solum petitioni catenae submittere debet sine cura de quis petitio discursum sit et quomodo discursum sit.
Submittere petitionem uni multiplicium rerum sine expressis speciebus recipientis
Copia obiecti dynamice specificari potest ad petitiones tractandas.Cliens dynamice potest creare catenam officiorum ad petitiones tractandas, et ordinem inter processuum in vinculo mutare potest.

Relatio librorum
"Ars Design Patterns" - Liu Wei

Technology sharing