设计模式简单的运用Demo（策略，适配器，单例）

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
public class DemoHandlerService {

    private Demo1Service demo1Service;
    private Demo2Service demo2Service;
    private Demo3Service demo3Service;
    
    /**
     * 通过不同的类型去处理参数
     *
     * @param demoType 策略类型
     * @param param 参数
     * @throws Exception 类型错误异常
     */
    public void handleDemo(String demoType, Object... param) throws Exception {
        if (Objects.equals(demoType, "Demo1")) {
            System.out.println("Demo1开始处理");
            demo1Service.handle(param);
            System.out.println("Demo1处理结束");
        } else if (Objects.equals(demoType, "Demo2")) {
            System.out.println("Demo2开始处理");
            demo2Service.handle(param);
            System.out.println("Demo2处理结束");
   } else if (Objects.equals(demoType, "Demo3")) {
            System.out.println("Demo3开始处理");
            demo3Service.handle(param);
            System.out.println("Demo3处理结束");
        } else {
            throw new Exception("Demo Type Error");
        }
    }
}

class Demo1Service {
    public void handle(Object... param) {
        System.out.println("Demo1正在被处理中，参数:" + Arrays.toString(param));
    }
}

class Demo2Service {
    public void handle(Object... param) {
        System.out.println("Demo1正在被处理中，参数:" + Arrays.toString(param));
    }
}

class Demo3Service {
    public void handle(Object... param) {
        System.out.println("Demo1正在被处理中，参数:" + Arrays.toString(param));
    }
}


策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换。策略模式通常包含以下角色：

  • 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
  • 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
  • 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换。策略模式通常包含以下角色：

  • 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
  • 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
  • 环境（Context）类：持有一个策略类的引用，最终给客户端调用。
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
public interface Strategy {
    void handleDemo(Object... param);
}

class Demo1 implements Strategy{
    private Demo1Service demo1Service;

    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo1开始处理");
        demo1Service.handle(param);
        System.out.println("Demo1处理结束");
    }
}

class Demo2 implements Strategy{
    private Demo2Service demo2Service;

    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo2开始处理");
        demo2Service.handle(param);
        System.out.println("Demo2处理结束");
    }
}

class Demo3 implements Strategy{
    private Demo3Service demo3Service;

    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo3开始处理");
        demo3Service.handle(param);
        System.out.println("Demo3处理结束");
    }
}

class StrategyContext{
    public static Strategy getStrategy(String demoType) throws Exception {
        switch (demoType){
            case "Demo1":
                return new Demo1();
            case "Demo2":
                return new Demo2();
            case "Demo3":
                return new Demo3();
            default:
                throw new Exception("Demo Type Error");
        }
    }
}

class DemoHandlerService{
    public void handleDemo(String demoType, Object... param) throws Exception {
        Strategy strategy = StrategyContext.getStrategy(demoType);
        strategy.handleDemo(param);
    }
}

单例模式设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
class StrategyContext{

    /**
     * 维护一个注册表
     */
    private static final Map<String, Strategy> REGISTER_MAP = new HashMap<>();

    /**
     * 注册策略
     * @param demoType demo类型
     * @param strategy 策略实例
     */
    public static void registerStrategy(String demoType, Strategy strategy){
        REGISTER_MAP.putIfAbsent(demoType, strategy);
    }

    /**
     * 获取策略
     * @param demoType demo类型
     * @return 策略实例
     */
    public static Strategy getStrategy(String demoType){
        return REGISTER_MAP.get(demoType);
    }
}
abstract class AbstractStrategy implements Strategy{
    public void register(){
        StrategyContext.registerStrategy(getClass().getSimpleName(), this);
    }
}
public interface Strategy {
    void handleDemo(Object... param);
}

class Demo1 extends AbstractStrategy implements Strategy{
    private static final Demo1 INSTANCE = new Demo1();
    private Demo1Service demo1Service;
    private Demo1(){
        register();
    }
    public static Demo1 getInstance(){
        return INSTANCE;
    }
    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo1开始处理");
        demo1Service.handle(param);
        System.out.println("Demo1处理结束");
    }
}

abstract class AbstractStrategy implements Strategy{
    public void register(){
        StrategyContext.registerStrategy(getClass().getSimpleName(), this);
    }
}
public interface Strategy {
    void handleDemo(Object... param);
}

class Demo1 extends AbstractStrategy implements Strategy{
    private static final Demo1 INSTANCE = new Demo1();
    private Demo1Service demo1Service;
    private Demo1(){
        register();
    }
    public static Demo1 getInstance(){
        return INSTANCE;
    }
    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo1开始处理");
        demo1Service.handle(param);
        System.out.println("Demo1处理结束");
    }
}

class Demo3 extends AbstractStrategy implements Strategy{
    private static final Demo3 INSTANCE = new Demo3();
    private Demo3Service demo3Service;

    private Demo3(){
        register();
    }

    public static Demo3 getInstance(){
        return INSTANCE;
    }

    @Override
    public void handleDemo(Object... param) {
        System.out.println("Demo3开始处理");
        demo3Service.handle(param);
        System.out.println("Demo3处理结束");
    }
}

class DemoHandlerService{
    public void handleDemo(String demoType, Object... param) throws Exception {
        Strategy strategy = StrategyContext.getStrategy(demoType);
        strategy.handleDemo(param);
    }
}