1、单例模式

常见模式：

SpringBoot启动的加载到容器中，以后再调用时也不会重新创建，而是之间从容器中拿。

像@Component、@Service、@Bean都是这样

懒汉式：

如果你的单例对象在启动过程比较耗时服务启动又追求服务效率的话，或者你的单例对象在启动的过程中初始化可能会失败，这种时候就需要使用懒汉式进行处理，最简单的做法就是单例对象初始化的地方还有使用单例对象加载的地方添加@Lazy。如下：

@Component
@Lazy
@Slf4j
public class SingleCaseService {

    public SingleCaseService() {
      log.info("start to init SingleCaseService");
    }

    public String sayHi() {
        return "hi";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

@SpringBootTest
@Slf4j
class SingleCaseServiceTest {

    @Autowired
    @Lazy
    SingleCaseService singleCaseService;

    @Test
    void sayHi() {
        log.info("sayHi");
        singleCaseService.sayHi();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

补充：@DependsOn也会让@Lazy失效, 需要注意用法

2、策略模式

先看一下定义：

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的context 对象。策略对象改变context对象的执行算法

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

解决的丑陋代码形如：

if(fixType.equal("A")){

}else if (fixType.equal("B")){
    
}else if (fixType.equal("C")){
    
}else if (fixType.equal("D")){
    
}
1
2
3
4
5
6
7
8
9

or

switch(type){
    case A:
        break;
    case B:
        break;
    case C:
        break;
    case D:
        break;
    default:
        break;
}
1
2
3
4
5
6
7
8
9
10
11
12

参考代码：

使用接口定义策略的共性接口，例如有些修复的大致流程差不多，而且有公共的处理操作，主要是片段是否支持修复和进行修复，目前有操作系统修复和数据库修复策略两种，后面可能会继续扩展其他修复场景

第一种方法是使用接口，承载一些对应的业务功能，然后使用Context进行自动装配和选择，代码如下：

public interface IFixStrategy {

    boolean isSupport(FixInfo fixInfo);

    void fix(FixInfo fixInfo);
}
1
2
3
4
5
6

@Component("dbFix")
public class DbFixStrategy extends FixStrategy implements IFixStrategy {

    @Override
    public boolean isSupport(FixInfo fixInfo) {
        return false;
    }

    @Override
    public void fix(FixInfo fixInfo) {
        //
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

@Component
public class FixStrategyContext {
    @Resource
    Map<String, IFixStrategy> iFixStrategyMap;

    @Resource
    Map<String, FixStrategy> fixStrategyMap;

    public IFixStrategy getCorrespondingIFixStrategy(String type) {
        return iFixStrategyMap.get(type);
    }

    public FixStrategy getCorrespondingFixStrategy(String type) {
        return fixStrategyMap.get(type);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

另外一种是使用抽象类来承载，这种可以将子类的一些公共能力放一起

public abstract class FixStrategy {

    boolean isSupport(FixInfo fixInfo) {
        throw new NotImplementedException();
    }

    void fix(FixInfo fixInfo) {
        throw new NotImplementedException();
    }

    void commonHandle() {

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

对应的架构图下图：

对应的代码github链接：https://github.com/junkaitongxue/LearnSpringBoot/tree/main/demo/src/main/java/com/dreamkite/demo/service/strategy

3、工厂模式

策略模式是一种行为型模式，工厂模式跟其类似，不过位创建型模式，以上代码则做个简单的改造即可，将Context变化成Factory, 根据FixInfo选择对应的工厂进行对象创建即可，这里就不做展开

4、TODO

后续有想到设计模式跟Springboot框架可以很好配合的再继续补充分享，感兴趣的话记得点赞~

（以上为DreamKite本人原创，转载请附上原文链接）