实战！工作中常用到哪些设计模式

前言

大家好，我是捡田螺的小男孩。

平时我们写代码呢，多数情况都是流水线式写代码，基本就可以实现业务逻辑了。如何在写代码中找到乐趣呢，我觉得，最好的方式就是：使用设计模式优化自己的业务代码。今天跟大家聊聊日常工作中，我都使用过哪些设计模式。

工作中常用到哪些设计模式

1.策略模式

1.1 业务场景

假设有这样的业务场景，大数据系统把文件推送过来，根据不同类型采取不同的解析方式。多数的小伙伴就会写出以下的代码：

1. if(type=="A"){
2. //按照A格式解析
4. }elseif(type=="B"){
5. //按B格式解析
6. }else{
7. //按照默认格式解析
8. }

这个代码可能会存在哪些问题呢?

• 如果分支变多，这里的代码就会变得臃肿，难以维护，可读性低。
• 如果你需要接入一种新的解析类型，那只能在原有代码上修改。

说得专业一点的话，就是以上代码，违背了面向对象编程的开闭原则以及单一原则。

• 开闭原则(对于扩展是开放的，但是对于修改是封闭的)：增加或者删除某个逻辑，都需要修改到原来代码
• 单一原则(规定一个类应该只有一个发生变化的原因)：修改任何类型的分支逻辑代码，都需要改动当前类的代码。

如果你的代码就是酱紫：有多个if...else等条件分支，并且每个条件分支，可以封装起来替换的，我们就可以使用策略模式来优化。

1.2 策略模式定义

策略模式定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的的客户。这个策略模式的定义是不是有点抽象呢?那我们来看点通俗易懂的比喻：

假设你跟不同性格类型的小姐姐约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去逛街买买买最合适。当然，目的都是为了得到小姐姐的芳心，请看电影、吃小吃、逛街就是不同的策略。

策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。

1.3 策略模式使用

策略模式怎么使用呢?酱紫实现的：

一个接口或者抽象类，里面两个方法(一个方法匹配类型，一个可替换的逻辑实现方法)

不同策略的差异化实现(就是说，不同策略的实现类)

使用策略模式

1.3.1 一个接口，两个方法

1. publicinterfaceIFileStrategy{
3. //属于哪种文件解析类型
4. FileTypeResolveEnumgainFileType();
6. //封装的公用算法（具体的解析方法）
7. voidresolve(Objectobjectparam);
8. }

1.3.2 不同策略的差异化实现

A 类型策略具体实现

1. @Component
2. publicclassAFileResolveimplementsIFileStrategy{
4. @Override
5. publicFileTypeResolveEnumgainFileType(){
6. returnFileTypeResolveEnum.File_A_RESOLVE;
7. }
9. @Override
10. publicvoidresolve(Objectobjectparam){
11. logger.info("A类型解析文件，参数：{}",objectparam);
12. //A类型解析具体逻辑
13. }
14. }

B 类型策略具体实现

1. @Component
2. publicclassBFileResolveimplementsIFileStrategy{
4. @Override
5. publicFileTypeResolveEnumgainFileType(){
6. returnFileTypeResolveEnum.File_B_RESOLVE;
7. }
10. @Override
11. publicvoidresolve(Objectobjectparam){
12. logger.info("B类型解析文件，参数：{}",objectparam);
13. //B类型解析具体逻辑
14. }
15. }

默认类型策略具体实现

1. @Component
2. publicclassDefaultFileResolveimplementsIFileStrategy{
4. @Override
5. publicFileTypeResolveEnumgainFileType(){
6. returnFileTypeResolveEnum.File_DEFAULT_RESOLVE;
7. }
9. @Override
10. publicvoidresolve(Objectobjectparam){
11. logger.info("默认类型解析文件，参数：{}",objectparam);
12. //默认类型解析具体逻辑
13. }
14. }

1.3.3 使用策略模式

如何使用呢?我们借助spring的生命周期，使用ApplicationContextAware接口，把对用的策略，初始化到map里面。然后对外提供resolveFile方法即可。

1. /**
2. *@author公众号：捡田螺的小男孩
3. */
4. @Component
5. publicclassStrategyUseServiceimplementsApplicationContextAware{
8. privateMapiFileStrategyMap=newConcurrentHashMap<>();
10. publicvoidresolveFile(FileTypeResolveEnumfileTypeResolveEnum,ObjectobjectParam){
11. IFileStrategyiFileStrategy=iFileStrategyMap.get(fileTypeResolveEnum);
12. if(iFileStrategy!=null){
13. iFileStrategy.resolve(objectParam);
14. }
15. }
17. //把不同策略放到map
18. @Override
19. publicvoidsetApplicationContext(ApplicationContextapplicationContext)throwsBeansException{
20. MaptmepMap=applicationContext.getBeansOfType(IFileStrategy.class);
21. tmepMap.values().forEach(strategyService->iFileStrategyMap.put(strategyService.gainFileType(),strategyService));
22. }
23. }

2. 责任链模式

2.1 业务场景

我们来看一个常见的业务场景，下订单。下订单接口，基本的逻辑，一般有参数非空校验、安全校验、黑名单校验、规则拦截等等。很多伙伴会使用异常来实现：

1. publicclassOrder{
3. publicvoidcheckNullParam(Objectparam){
4. //参数非空校验
5. thrownewRuntimeException();
6. }
7. publicvoidcheckSecurity(){
8. //安全校验
9. thrownewRuntimeException();
10. }
11. publicvoidcheckBackList(){
12. //黑名单校验
13. thrownewRuntimeException();
14. }
15. publicvoidcheckRule(){
16. //规则拦截
17. thrownewRuntimeException();
18. }
20. publicstaticvoidmain(String[]args){
21. Orderorder=newOrder();
22. try{
23. order.checkNullParam();
24. order.checkSecurity();
25. order.checkBackList();
26. order2.checkRule();
27. System.out.println("ordersuccess");
28. }catch(RuntimeExceptione){
29. System.out.println("orderfail");
30. }
31. }
32. }

这段代码使用了异常来做逻辑条件判断，如果后续逻辑越来越复杂的话，会出现一些问题：如异常只能返回异常信息，不能返回更多的字段，这时候需要自定义异常类。

并且，阿里开发手册规定：禁止用异常做逻辑判断。

【强制】 异常不要用来做流程控制，条件控制。说明：异常设计的初衷是解决程序运行中的各种意外情况，且异常的处理效率比条件判断方式要低很多。

如何优化这段代码呢?可以考虑责任链模式

2.2 责任链模式定义

当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。

责任链模式为请求创建了一个接收者对象的链。执行链上有多个对象节点，每个对象节点都有机会(条件匹配)处理请求事务，如果某个对象节点处理完了，就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

责任链模式实际上是一种处理请求的模式，它让多个处理器(对象节点)都有机会处理该请求，直到其中某个处理成功为止。责任链模式把多个处理器串成链，然后让请求在链上传递：

责任链模式

打个比喻：

假设你晚上去上选修课，为了可以走点走，坐到了最后一排。来到教室，发现前面坐了好几个漂亮的小姐姐，于是你找张纸条，写上：“你好, 可以做我的女朋友吗?如果不愿意请向前传”。纸条就一个接一个的传上去了，后来传到第一排的那个妹子手上，她把纸条交给老师，听说老师40多岁未婚...

2.3 责任链模式使用

责任链模式怎么使用呢?

• 一个接口或者抽象类
• 每个对象差异化处理
• 对象链(数组)初始化(连起来)

2.3.1 一个接口或者抽象类

这个接口或者抽象类，需要：

• 有一个指向责任下一个对象的属性
• 一个设置下一个对象的set方法
• 给子类对象差异化实现的方法(如以下代码的doFilter方法)

1. /**
2. *关注公众号：捡田螺的小男孩
3. */
4. publicabstractclassAbstractHandler{
6. //责任链中的下一个对象
7. privateAbstractHandlernextHandler;
9. /**
10. *责任链的下一个对象
11. */
12. publicvoidsetNextHandler(AbstractHandlernextHandler){
13. this.nextHandler=nextHandler;
14. }
16. /**
17. *具体参数拦截逻辑,给子类去实现
18. */
19. publicvoidfilter(Requestrequest,Responseresponse){
20. doFilter(request,response);
21. if(getNextHandler()!=null){
22. getNextHandler().filter(request,response);
23. }
24. }
26. publicAbstractHandlergetNextHandler(){
27. returnnextHandler;
28. }
30. abstractvoiddoFilter(RequestfilterRequest,Responseresponse);
32. }

2.3.2 每个对象差异化处理

责任链上，每个对象的差异化处理，如本小节的业务场景，就有参数校验对象、安全校验对象、黑名单校验对象、规则拦截对象

1. /**
2. *参数校验对象
3. **/
4. @Component
5. @Order(1)//顺序排第1，最先校验
6. publicclassCheckParamFilterObjectextendsAbstractHandler{
8. @Override
9. publicvoiddoFilter(Requestrequest,Responseresponse){
10. System.out.println("非空参数检查");
11. }
12. }
14. /**
15. *安全校验对象
16. */
17. @Component
18. @Order(2)//校验顺序排第2
19. publicclassCheckSecurityFilterObjectextendsAbstractHandler{
21. @Override
22. publicvoiddoFilter(Requestrequest,Responseresponse){
23. //invokeSecuritycheck
24. System.out.println("安全调用校验");
25. }
26. }
27. /**
28. *黑名单校验对象
29. */
30. @Component
31. @Order(3)//校验顺序排第3
32. publicclassCheckBlackFilterObjectextendsAbstractHandler{
34. @Override
35. publicvoiddoFilter(Requestrequest,Responseresponse){
36. //invokeblacklistcheck
37. System.out.println("校验黑名单");
38. }
39. }
41. /**
42. *规则拦截对象
43. */
44. @Component
45. @Order(4)//校验顺序排第4
46. publicclassCheckRuleFilterObjectextendsAbstractHandler{
48. @Override
49. publicvoiddoFilter(Requestrequest,Responseresponse){
50. //checkrule
51. System.out.println("checkrule");
52. }
53. }

2.3.3 对象链连起来(初始化)&& 使用

1. @Component("ChainPatternDemo")
2. publicclassChainPatternDemo{
4. //自动注入各个责任链的对象
5. @Autowired
6. privateListabstractHandleList;
8. privateAbstractHandlerabstractHandler;
10. //spring注入后自动执行，责任链的对象连接起来
11. @PostConstruct
12. publicvoidinitializeChainFilter(){
14. for(inti=0;isize();i++){
15. if(i==0){
16. abstractHandler=abstractHandleList.get(0);
17. }else{
18. AbstractHandlercurrentHander=abstractHandleList.get(i-1);
19. AbstractHandlernextHander=abstractHandleList.get(i);
20. currentHander.setNextHandler(nextHander);
21. }
22. }
23. }
25. //直接调用这个方法使用
26. publicResponseexec(Requestrequest,Responseresponse){
27. abstractHandler.filter(request,response);
28. returnresponse;
29. }
31. publicAbstractHandlergetAbstractHandler(){
32. returnabstractHandler;
33. }
35. publicvoidsetAbstractHandler(AbstractHandlerabstractHandler){
36. this.abstractHandler=abstractHandler;
37. }
38. }

运行结果如下：

1. 非空参数检查
2. 安全调用校验
3. 校验黑名单
4. checkrule

3. 模板方法模式

3.1 业务场景

假设我们有这么一个业务场景：内部系统不同商户，调用我们系统接口，去跟外部第三方系统交互(http方式)。走类似这么一个流程，如下：

一个请求都会经历这几个流程：

• 查询商户信息
• 对请求报文加签
• 发送http请求出去
• 对返回的报文验签

这里，有的商户可能是走代理出去的，有的是走直连。假设当前有A，B商户接入，不少伙伴可能这么实现，伪代码如下：

1. //商户A处理句柄
2. CompanyAHandlerimplementsRequestHandler{
3. Resphander(req){
4. //查询商户信息
5. queryMerchantInfo();
6. //加签
7. signature();
8. //http请求（A商户假设走的是代理）
9. httpRequestbyProxy()
10. //验签
11. verify();
12. }
13. }
14. //商户B处理句柄
15. CompanyBHandlerimplementsRequestHandler{
16. Resphander(Rreq){
17. //查询商户信息
18. queryMerchantInfo();
19. //加签
20. signature();
21. //http请求（B商户不走代理，直连）
22. httpRequestbyDirect();
23. //验签
24. verify();
25. }
26. }

假设新加一个C商户接入，你需要再实现一套这样的代码。显然，这样代码就重复了，一些通用的方法，却在每一个子类都重新写了这一方法。

如何优化呢?可以使用模板方法模式。

3.2 模板方法模式定义

定义一个操作中的算法的骨架流程，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。它的核心思想就是：定义一个操作的一系列步骤，对于某些暂时确定不下来的步骤，就留给子类去实现，这样不同的子类就可以定义出不同的步骤。

打个通俗的比喻：

模式举例：追女朋友要先“牵手”，再“拥抱”，再“接吻”， 再“拍拍..额..手”。至于具体你用左手还是右手牵，无所谓，但是整个过程，定了一个流程模板，按照模板来就行。

3.3 模板方法使用

• 一个抽象类，定义骨架流程(抽象方法放一起)
• 确定的共同方法步骤，放到抽象类(去除抽象方法标记)
• 不确定的步骤，给子类去差异化实现

我们继续那以上的举例的业务流程例子，来一起用 模板方法优化一下哈：

3.3.1 一个抽象类，定义骨架流程

因为一个个请求经过的流程为一下步骤：

• 查询商户信息
• 对请求报文加签
• 发送http请求出去
• 对返回的报文验签

所以我们就可以定义一个抽象类，包含请求流程的几个方法，方法首先都定义为抽象方法哈：

1. /**
2. *抽象类定义骨架流程（查询商户信息，加签，http请求，验签）
3. */
4. abstractclassAbstractMerchantService{
6. //查询商户信息
7. abstractqueryMerchantInfo();
8. //加签
9. abstractsignature();
10. //http请求
11. abstracthttpRequest();
12. //验签
13. abstractverifySinature();
15. }

3.3.2 确定的共同方法步骤，放到抽象类

1. abstractclassAbstractMerchantService{
3. //模板方法流程
4. ResphandlerTempPlate(req){
5. //查询商户信息
6. queryMerchantInfo();
7. //加签
8. signature();
9. //http请求
10. httpRequest();
11. //验签
12. verifySinature();
13. }
14. //Http是否走代理（提供给子类实现）
15. abstractbooleanisRequestByProxy();
16. }

3.3.3 不确定的步骤，给子类去差异化实现

因为是否走代理流程是不确定的，所以给子类去实现。

商户A的请求实现：

1. CompanyAServiceImplextendsAbstractMerchantService{
2. Resphander(req){
3. returnhandlerTempPlate(req);
4. }
5. //走http代理的
6. booleanisRequestByProxy(){
7. returntrue;
8. }

商户B的请求实现：

1. CompanyBServiceImplextendsAbstractMerchantService{
2. Resphander(req){
3. returnhandlerTempPlate(req);
4. }
5. //公司B是不走代理的
6. booleanisRequestByProxy(){
7. returnfalse;
8. }

4. 观察者模式

4.1 业务场景

登陆注册应该是最常见的业务场景了。就拿注册来说事，我们经常会遇到类似的场景，就是用户注册成功后，我们给用户发一条消息，又或者发个邮件等等，因此经常有如下的代码：

1. voidregister(Useruser){
2. insertRegisterUser（user）;
3. sendIMMessage();
4. sendEmail()；
5. }

这块代码会有什么问题呢?如果产品又加需求：现在注册成功的用户，再给用户发一条短信通知。于是你又得改register方法的代码了。。。这是不是违反了开闭原则啦。

1. voidregister(Useruser){
2. insertRegisterUser（user）;
3. sendIMMessage();
4. sendMobileMessage（）;
5. sendEmail()；
6. }

并且，如果调发短信的接口失败了，是不是又影响到用户注册了?!这时候，是不是得加个异步方法给通知消息才好。。。

实际上，我们可以使用观察者模式优化。

4.2 观察者模式定义

观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被完成业务的更新。

观察者模式属于行为模式，一个对象(被观察者)的状态发生改变，所有的依赖对象(观察者对象)都将得到通知，进行广播通知。它的主要成员就是观察者和被观察者。

被观察者(Observerable)：目标对象，状态发生变化时，将通知所有的观察者。

观察者(observer)：接受被观察者的状态变化通知，执行预先定义的业务。

使用场景： 完成某件事情后，异步通知场景。如，登陆成功，发个IM消息等等。

4.3 观察者模式使用

观察者模式实现的话，还是比较简单的。

• 一个被观察者的类Observerable ;
• 多个观察者Observer ;
• 观察者的差异化实现
• 经典观察者模式封装：EventBus实战

4.3.1 一个被观察者的类Observerable 和 多个观察者Observer

1. publicclassObserverable{
3. privateListobservers
4. =newArrayList();
5. privateintstate;
7. publicintgetState(){
8. returnstate;
9. }
11. publicvoidsetState(intstate){
12. notifyAllObservers();
13. }
15. //添加观察者
16. publicvoidaddServer(Observerobserver){
17. observers.add(observer);
18. }
20. //移除观察者
21. publicvoidremoveServer(Observerobserver){
22. observers.remove(observer);
23. }
24. //通知
25. publicvoidnotifyAllObservers(intstate){
26. if(state!=1){
27. System.out.println(“不是通知的状态”);
28. return;
29. }
31. for(Observerobserver:observers){
32. observer.doEvent();
33. }
34. }
35. }

4.3.2 观察者的差异化实现

1. //观察者
2. interfaceObserver{
3. voiddoEvent();
4. }
5. //Im消息
6. IMMessageObserverimplementsObserver{
7. voiddoEvent（）{
8. System.out.println("发送IM消息");
9. }
10. }
12. //手机短信
13. MobileNoObserverimplementsObserver{
14. voiddoEvent（）{
15. System.out.println("发送短信消息");
16. }
17. }
18. //EmailNo
19. EmailObserverimplementsObserver{
20. voiddoEvent（）{
21. System.out.println("发送email消息");
22. }
23. }

4.3.3 EventBus实战

自己搞一套观察者模式的代码，还是有点小麻烦。实际上，Guava EventBus就封装好了，它 提供一套基于注解的事件总线，api可以灵活的使用，爽歪歪。

我们来看下EventBus的实战代码哈，首先可以声明一个EventBusCenter类，它类似于以上被观察者那种角色Observerable。

1. publicclassEventBusCenter{
3. privatestaticEventBuseventBus=newEventBus();
5. privateEventBusCenter(){
6. }
8. publicstaticEventBusgetInstance(){
9. returneventBus;
10. }
11. //添加观察者
12. publicstaticvoidregister(Objectobj){
13. eventBus.register(obj);
14. }
15. //移除观察者
16. publicstaticvoidunregister(Objectobj){
17. eventBus.unregister(obj);
18. }
19. //把消息推给观察者
20. publicstaticvoidpost(Objectobj){
21. eventBus.post(obj);
22. }
23. }

然后再声明观察者EventListener

1. publicclassEventListener{
3. @Subscribe//加了订阅，这里标记这个方法是事件处理方法
4. publicvoidhandle(NotifyEventnotifyEvent){
5. System.out.println("发送IM消息"+notifyEvent.getImNo());
6. System.out.println("发送短信消息"+notifyEvent.getMobileNo());
7. System.out.println("发送Email消息"+notifyEvent.getEmailNo());
8. }
9. }
11. //通知事件类
12. publicclassNotifyEvent{
14. privateStringmobileNo;
16. privateStringemailNo;
18. privateStringimNo;
20. publicNotifyEvent(StringmobileNo,StringemailNo,StringimNo){
21. this.mobileNo=mobileNo;
22. this.emailNo=emailNo;
23. this.imNo=imNo;
24. }
25. }

使用demo测试：

1. publicclassEventBusDemoTest{
3. publicstaticvoidmain(String[]args){
5. EventListenereventListener=newEventListener();
6. EventBusCenter.register(eventListener);
7. EventBusCenter.post(newNotifyEvent("13372817283","[e-mail]","666"));
8. }
9. }

运行结果：

1. 发送IM消息666
2. 发送短信消息13372817283
3. 发送Email消息[e-mail]

5. 工厂模式

5.1 业务场景

工厂模式一般配合策略模式一起使用。用来去优化大量的if...else...或switch...case...条件语句。

我们就取第一小节中策略模式那个例子吧。根据不同的文件解析类型，创建不同的解析对象

1. IFileStrategygetFileStrategy(FileTypeResolveEnumfileType){
2. IFileStrategyfileStrategy;
3. if(fileType=FileTypeResolveEnum.File_A_RESOLVE){
4. fileStrategy=newAFileResolve();
5. }elseif(fileType=FileTypeResolveEnum.File_A_RESOLV){
6. fileStrategy=newBFileResolve();
7. }else{
8. fileStrategy=newDefaultFileResolve();
9. }
10. returnfileStrategy;
11. }

其实这就是工厂模式，定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

策略模式的例子，没有使用上一段代码，而是借助spring的特性，搞了一个工厂模式，哈哈，小伙伴们可以回去那个例子细品一下，我把代码再搬下来，小伙伴们再品一下吧：

1. /**
2. *@author公众号：捡田螺的小男孩
3. */
4. @Component
5. publicclassStrategyUseServiceimplementsApplicationContextAware{
7. privateMapiFileStrategyMap=newConcurrentHashMap<>();
9. //把所有的文件类型解析的对象，放到map，需要使用时，信手拈来即可。这就是工厂模式的一种体现啦
10. @Override
11. publicvoidsetApplicationContext(ApplicationContextapplicationContext)throwsBeansException{
12. MaptmepMap=applicationContext.getBeansOfType(IFileStrategy.class);
13. tmepMap.values().forEach(strategyService->iFileStrategyMap.put(strategyService.gainFileType(),strategyService));
14. }
15. }

5.2 使用工厂模式

定义工厂模式也是比较简单的:

一个工厂接口，提供一个创建不同对象的方法。

其子类实现工厂接口，构造不同对象

使用工厂模式

5.3.1 一个工厂接口

1. interfaceIFileResolveFactory{
2. voidresolve();
3. }

5.3.2 不同子类实现工厂接口

1. classAFileResolveimplementsIFileResolveFactory{
2. voidresolve(){
3. System.out.println("文件A类型解析");
4. }
5. }
7. classBFileResolveimplementsIFileResolveFactory{
8. voidresolve(){
9. System.out.println("文件B类型解析");
10. }
11. }
13. classDefaultFileResolveimplementsIFileResolveFactory{
14. voidresolve(){
15. System.out.println("默认文件类型解析");
16. }
17. }

5.3.3 使用工厂模式

1. //构造不同的工厂对象
2. IFileResolveFactoryfileResolveFactory;
3. if(fileType=“A”){
4. fileResolveFactory=newAFileResolve();
5. }elseif(fileType=“B”){
6. fileResolveFactory=newBFileResolve();
7. }else{
8. fileResolveFactory=newDefaultFileResolve();
9. }
11. fileResolveFactory.resolve();

一般情况下，对于工厂模式，你不会看到以上的代码。工厂模式会跟配合其他设计模式如策略模式一起出现的。

6. 单例模式

6.1 业务场景

单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。I/O与数据库的连接,一般就用单例模式实现de的。Windows里面的Task Manager(任务管理器)也是很典型的单例模式。

来看一个单例模式的例子

1. /**
2. *公众号：捡田螺的小男孩
3. */
4. publicclassLanHanSingleton{
6. privatestaticLanHanSingletoninstance;
8. privateLanHanSingleton(){
10. }
12. publicstaticLanHanSingletongetInstance(){
13. if(instance==null){
14. instance=newLanHanSingleton();
15. }
16. returninstance;
17. }
19. }

以上的例子，就是懒汉式的单例实现。实例在需要用到的时候，才去创建，就比较懒。如果有则返回，没有则新建，需要加下 synchronized关键字，要不然可能存在线性安全问题。

6.2 单例模式的经典写法

其实单例模式还有有好几种实现方式，如饿汉模式，双重校验锁，静态内部类，枚举等实现方式。

6.2.1 饿汉模式

1. publicclassEHanSingleton{
3. privatestaticEHanSingletoninstance=newEHanSingleton();
5. privateEHanSingleton(){
6. }
8. publicstaticEHanSingletongetInstance(){
9. returninstance;
10. }
12. }

饿汉模式，它比较饥饿、比较勤奋，实例在初始化的时候就已经建好了，不管你后面有没有用到，都先新建好实例再说。这个就没有线程安全的问题，但是呢，浪费内存空间呀。

6.2.2 双重校验锁

1. publicclassDoubleCheckSingleton{
3. privatestaticDoubleCheckSingletoninstance;
5. privateDoubleCheckSingleton(){}
7. publicstaticDoubleCheckSingletongetInstance(){
8. if(instance==null){
9. synchronized(DoubleCheckSingleton.class){
10. if(instance==null){
11. instance=newDoubleCheckSingleton();
12. }
13. }
14. }
15. returninstance;
16. }
17. }

双重校验锁实现的单例模式，综合了懒汉式和饿汉式两者的优缺点。以上代码例子中，在synchronized关键字内外都加了一层 if条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。

6.2.3 静态内部类

1. publicclassInnerClassSingleton{
3. privatestaticclassInnerClassSingletonHolder{
4. privatestaticfinalInnerClassSingletonINSTANCE=newInnerClassSingleton();
5. }
7. privateInnerClassSingleton(){}
9. publicstaticfinalInnerClassSingletongetInstance(){
10. returnInnerClassSingletonHolder.INSTANCE;
11. }
12. }

静态内部类的实现方式，效果有点类似双重校验锁。但这种方式只适用于静态域场景，双重校验锁方式可在实例域需要延迟初始化时使用。

6.2.4 枚举

1. publicenumSingletonEnum{
3. INSTANCE;
4. publicSingletonEnumgetInstance(){
5. returnINSTANCE;
6. }
7. }

枚举实现的单例，代码简洁清晰。并且它还自动支持序列化机制，绝对防止多次实例化。

原文链接：https://mp.weixin.qq.com/s/5OSKWsesOoottffNHEDBWQ