聊聊工作中使用了哪些设计模式-ag真人游戏

运行结果如下：

非空参数检查
安全调用校验
校验黑名单
check rule

3. 模板方法模式

3.1 业务场景

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

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

• 查询商户信息

• 对请求报文加签

• 发送http请求出去

• 对返回的报文验签

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

// 商户a处理句柄
companyahandler implements requesthandler {
   resp hander(req){
   //查询商户信息
   querymerchantinfo();
   //加签
   signature();
   //http请求（a商户假设走的是代理）
   httprequestbyproxy()
   //验签
   verify();
   }
}
// 商户b处理句柄
companybhandler implements requesthandler {
   resp hander(rreq){
   //查询商户信息
   querymerchantinfo();
   //加签
   signature();
   // http请求（b商户不走代理，直连）
   httprequestbydirect();
   // 验签
   verify(); 
   }
}

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

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

3.2 模板方法模式定义

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

打个通俗的比喻：

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

3.3 模板方法使用

• 一个抽象类，定义骨架流程（抽象方法放一起）

• 确定的共同方法步骤，放到抽象类（去除抽象方法标记）

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

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

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

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

• 查询商户信息

• 对请求报文加签

• 发送http请求出去

• 对返回的报文验签

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

/**
 * 抽象类定义骨架流程（查询商户信息，加签，http请求，验签）
 */
abstract class abstractmerchantservice  { 
      //查询商户信息
      abstract querymerchantinfo();
      //加签
      abstract signature();
      //http 请求
      abstract httprequest();
       // 验签
       abstract verifysinature();
 
}

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

abstract class abstractmerchantservice  { 
     //模板方法流程
     resp handlertempplate(req){
           //查询商户信息
           querymerchantinfo();
           //加签
           signature();
           //http 请求
           httprequest();
           // 验签
           verifysinature();
     }
      // http是否走代理（提供给子类实现）
      abstract boolean isrequestbyproxy();
}

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

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

商户a的请求实现：

companyaserviceimpl extends abstractmerchantservice{
    resp hander(req){
      return handlertempplate(req);
    }
    //走http代理的
    boolean isrequestbyproxy(){
       return true;
    }

商户b的请求实现：

companybserviceimpl extends abstractmerchantservice{
    resp hander(req){
      return handlertempplate(req);
    }
    //公司b是不走代理的
    boolean isrequestbyproxy(){
       return false;
    }

4. 观察者模式

4.1 业务场景

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

void register(user user){
  insertregisteruser（user）;
  sendimmessage();
  sendemail()；
}

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

void register(user user){
  insertregisteruser（user）;
  sendimmessage();
  sendmobilemessage（）;
  sendemail()；
}

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

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

4.2 观察者模式定义

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

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

• 被观察者（observerable）：目标对象，状态发生变化时，将通知所有的观察者。

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

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

4.3 观察者模式使用

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

• 一个被观察者的类observerable ;

• 多个观察者observer ；

• 观察者的差异化实现

• 经典观察者模式封装：eventbus实战

4.3.1 一个被观察者的类observerable 和 多个观察者observer

public class observerable {
   
   private list observers 
      = new arraylist();
   private int state;
 
   public int getstate() {
      return state;
   }
 
   public void setstate(int state) {
      notifyallobservers();
   }
 
   //添加观察者
   public void addserver(observer observer){
      observers.add(observer);      
   }
   
   //移除观察者
   public void removeserver(observer observer){
      observers.remove(observer);      
   }
   //通知
   public void notifyallobservers(int state){
      if(state!=1){
          system.out.println(“不是通知的状态”);
         return ;
      }
   
      for (observer observer : observers) {
         observer.doevent();
      }
   }  
}

4.3.2 观察者的差异化实现

 //观察者
 interface observer {  
    void doevent();  
}  
//im消息
immessageobserver implements observer{
    void doevent（）{
       system.out.println("发送im消息");
    }
}
//手机短信
mobilenoobserver implements observer{
    void doevent（）{
       system.out.println("发送短信消息");
    }
}
//emailno
emailobserver implements observer{
    void doevent（）{
       system.out.println("发送email消息");
    }
}

4.3.3 eventbus实战

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

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

public class eventbuscenter {
    private static eventbus eventbus = new eventbus();
    private eventbuscenter() {
    }
    public static eventbus getinstance() {
        return eventbus;
    }
     //添加观察者
    public static void register(object obj) {
        eventbus.register(obj);
    }
    //移除观察者
    public static void unregister(object obj) {
        eventbus.unregister(obj);
    }
    //把消息推给观察者
    public static void post(object obj) {
        eventbus.post(obj);
    }
}

然后再声明观察者eventlistener

public class eventlistener {
    @subscribe //加了订阅，这里标记这个方法是事件处理方法  
    public void handle(notifyevent notifyevent) {
        system.out.println("发送im消息"   notifyevent.getimno());
        system.out.println("发送短信消息"   notifyevent.getmobileno());
        system.out.println("发送email消息"   notifyevent.getemailno());
    }
}
//通知事件类
public class notifyevent  {
    private string mobileno;
    private string emailno;
    private string imno;
    public notifyevent(string mobileno, string emailno, string imno) {
        this.mobileno = mobileno;
        this.emailno = emailno;
        this.imno = imno;
    }
 }

使用demo测试：

public class eventbusdemotest {
    public static void main(string[] args) {
        eventlistener eventlistener = new eventlistener();
        eventbuscenter.register(eventlistener);
        eventbuscenter.post(new notifyevent("13372817283", "[email protected]", "666"));
        }
}

运行结果：

发送im消息666
发送短信消息13372817283
发送email消息[email protected]

5. 工厂模式

5.1 业务场景

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

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

 
 ifilestrategy getfilestrategy(filetyperesolveenum filetype){
     ifilestrategy  filestrategy ;
     if(filetype=filetyperesolveenum.file_a_resolve){
       filestrategy = new afileresolve();
     }else if(filetype=filetyperesolveenum.file_a_resolv){
       filestrategy = new bfileresolve();
     }else{
       filestrategy = new defaultfileresolve();
     }
     return filestrategy;
 }

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

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

/**
 *  @author 公众号：捡田螺的小男孩
 */
@component
public class strategyuseservice implements applicationcontextaware{
    private map ifilestrategymap = new concurrenthashmap<>();
    //把所有的文件类型解析的对象，放到map，需要使用时，信手拈来即可。这就是工厂模式的一种体现啦
    @override
    public void setapplicationcontext(applicationcontext applicationcontext) throws beansexception {
        map tmepmap = applicationcontext.getbeansoftype(ifilestrategy.class);
        tmepmap.values().foreach(strategyservice -> ifilestrategymap.put(strategyservice.gainfiletype(), strategyservice));
    }
}

5.2 使用工厂模式

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

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

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

• 使用工厂模式

5.3.1 一个工厂接口

interface ifileresolvefactory{
   void resolve();
}

5.3.2 不同子类实现工厂接口

class afileresolve implements ifileresolvefactory{
   void resolve(){
      system.out.println("文件a类型解析");
   }
}
class bfileresolve implements ifileresolvefactory{
   void resolve(){
      system.out.println("文件b类型解析");
   }
}
class defaultfileresolve implements ifileresolvefactory{
   void resolve(){
      system.out.println("默认文件类型解析");
   }
}

5.3.3 使用工厂模式

//构造不同的工厂对象
ifileresolvefactory fileresolvefactory;
if(filetype=“a”){
    fileresolvefactory = new afileresolve();
}else if(filetype=“b”){
    fileresolvefactory = new bfileresolve();
 }else{
    fileresolvefactory = new defaultfileresolve();
}
fileresolvefactory.resolve();

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

6. 单例模式

6.1 业务场景

单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。 i/o与数据库的连接,一般就用单例模式实现de的。windows里面的task manager（任务管理器）也是很典型的单例模式。

来看一个单例模式的例子

/**
 *  公众号：捡田螺的小男孩
 */
public class lanhansingleton {
    private static lanhansingleton instance;
    private lanhansingleton(){
    }
    public static lanhansingleton getinstance(){
        if (instance == null) {
            instance = new lanhansingleton();
        }
        return instance;
    }
}
 

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

6.2 单例模式的经典写法

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

6.2.1 饿汉模式

public class ehansingleton {
   private static ehansingleton instance = new ehansingleton();
   
   private ehansingleton(){      
   }
   public static ehansingleton getinstance() {
       return instance;
   }
   
}

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

6.2.2 双重校验锁

public class doublechecksingleton {
   private static doublechecksingleton instance;
   private doublechecksingleton() { }
   
   public static doublechecksingleton getinstance(){
       if (instance == null) {
           synchronized (doublechecksingleton.class) {
               if (instance == null) {
                   instance = new doublechecksingleton();
               }
           }
       }
       return instance;
   }
}

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

6.2.3 静态内部类

public class innerclasssingleton {
   private static class innerclasssingletonholder{
       private static final innerclasssingleton instance = new innerclasssingleton();
   }
   private innerclasssingleton(){}
   
   public static final innerclasssingleton getinstance(){
       return innerclasssingletonholder.instance;
   }
}

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

6.2.4 枚举

public enum singletonenum {
    instance;
    public singletonenum getinstance(){
        return instance;
    }
}

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