设计模式：策略模式和工厂模式混合使用

有时单个设计模式并不能满足我们的业务需求，这个时候就要根据具体的业务来混合使用设计模式，其中策略模式和工厂模式是比较常用的一个组合。工厂模式可以管理具体策略的生命周期，策略模式可以丰满具体细节的逻辑。

代码示例

interface Strategy {
    void execute();
}
 // 具体策略类1
class StrategyImpl1 implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略1");
    }
}
 // 具体策略类2
class StrategyImpl2 implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略2");
    }
}
 // 工厂接口
interface Factory {
    Strategy createStrategy();
}
 // 具体工厂类1
class FactoryImpl1 implements Factory {
    @Override
    public Strategy createStrategy() {
        return new StrategyImpl1();
    }
}
 // 具体工厂类2
class FactoryImpl2 implements Factory {
    @Override
    public Strategy createStrategy() {
        return new StrategyImpl2();
    }
}
 // 测试类
public class Main {
    public static void main(String[] args) {
        Factory factory1 = new FactoryImpl1();
        Strategy strategy1 = factory1.createStrategy();
        strategy1.execute();
         Factory factory2 = new FactoryImpl2();
        Strategy strategy2 = factory2.createStrategy();
        strategy2.execute();
    }
}
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

在这个示例中，我们定义了一个策略接口和两个具体策略类。然后，我们创建了一个工厂接口和两个具体工厂类，每个工厂类负责创建不同的策略实例。最后，在测试类中，我们使用工厂类创建了不同的策略实例，并调用它们的执行方法。

以上只是个简单的示例，我们可以把工厂模式用map改进一下，并不需要这么多的子工厂类。

interface Strategy {
    void execute();
}

// 具体策略类1
class StrategyImpl1 implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略1");
    }

	@PostConstruct
	public void registryFactory(){
		Factory.CHOOSER_MAP.registry("1",this);
	}
}

// 具体策略类2
class StrategyImpl2 implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略2");
    }

	@PostConstruct
	public void registryFactory(){
		Factory.CHOOSER_MAP.registry("2",this);
	}
}

// 工厂接口
public class Factory {

    private final static Map<String, Strategy > CHOOSER_MAP = new ConcurrentHashMap<>();

    public static void registry(String code, Strategy strategy ) {
        CHOOSER_MAP.put(code, strategy );
    }

    public static Strategy chose(String code) {
		CHOOSER_MAP.get(code);
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        StrategyImpl1  StrategyImpl1  = PlatformChooserFactory.chose(“1”);

		StrategyImp2  StrategyImpl2  = PlatformChooserFactory.chose(2”);
    }
}
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

以上就是改造后的代码，这样就比较简单直观了。工厂类中我们使用map去存储具体的策略类，并且提供注册和获取方法。具体策略类在初始化的时候，会把当前类注册到工厂类的map中。这样我们使用的时候，只要根据具体的key就可以拿到具体的策略类。

优缺点

优点：

1. 灵活性：策略模式允许在运行时选择不同的策略，而工厂模式可以根据需求创建相应的对象。这种组合可以使系统更加灵活，能够根据不同的需求选择合适的策略和对象。
2. 可扩展性：通过工厂模式，可以轻松添加新的具体产品或策略，而无需修改现有代码。这使得系统更容易扩展，可以根据需要动态添加新的产品和策略。
3. 代码复用：策略模式和工厂模式都鼓励代码的重用。策略模式中的策略和工厂模式中的产品可以在不同的上下文中被重复使用，避免了重复编写相似的代码。
4. 松耦合：策略模式和工厂模式的结合可以实现松耦合的设计。策略模式通过接口与具体策略解耦，工厂模式通过抽象工厂与具体产品解耦。这种松耦合设计使得系统更加灵活、可维护和可测试。

缺点：

1. 增加复杂性：使用策略模式和工厂模式的混合会增加代码的复杂性，需要定义多个接口、类和实现。这可能会增加开发和维护的成本。
2. 增加类的数量：使用策略模式和工厂模式的混合可能导致类的数量增加，特别是在有多个具体策略和产品时。这可能会增加系统的复杂性和内存占用。

总结

需要根据具体的应用场景和需求来权衡使用策略模式和工厂模式的混合。在某些情况下，这种组合可以提供更灵活、可扩展和可维护的设计，但也需要考虑代码复杂性和类的数量增加的影响。