技能篇:实际开发经常使用设计模式

2021年11月22日 阅读数:3
这篇文章主要向大家介绍技能篇:实际开发经常使用设计模式,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

建立型

单例模式

单例对象能节约系统资源,一个对象的建立和消亡的开销可能很小。可是平常的服务接口,就算是通常小公司也有十几万的QPS吧。每一次的功能运转都建立新的对象来响应请求,十几万对象的建立和销毁,想一想就是一笔大开销,因此 spring 管理构造的 bean 对象通常都是单例。并且单例模式能够更好的解决并发的问题,方便实现数据的同步性java

  • 优势
    • 在内存中只有一个对象,节省内存空间
    • 避免频繁的建立销毁对象,能够提升性能
    • 避免对共享资源的多重占用,简化访问
    • 为整个系统提供一个全局访问点
  • 缺点
    • 不适用于变化频繁的对象
//饿汉式
private static Singleton singleton = new Singleton();
//懒汉式
private static Singleton singleton;
public static Singleton getSingleton(){
    if (singleton == null) {
        singleton = new Singleton(); //被动建立,在真正须要使用时才去建立
    }
    return singleton;
}
//双重判断加锁机制
private volatile static Singleton instance;
//程序运行时建立一个静态只读的进程辅助对象
public static Singleton GetInstance() {
    //先判断是否存在,不存在再加锁处理
    if (instance == null){
        synchronized (Singleton.class){
            if(instance == null){
                instance = new Singleton();
            }
        }
    }
    return instance;
}
//静态初始化
private static readonly Singleton instance= new Singleton();
public static Singleton GetInstance(){
    return instance;
}

工厂模式

使用者不关心对象的实例化过程,只关心对象的获取。工厂模式使得产品的实例化过程和消费者解耦mysql

  • 优势
    • 一个调用者想建立一个对象,只需经过其名称或其余惟一键值在工厂获取
    • 扩展性高,若是想增长生产一种类型对象,只要扩展工厂类就能够
  • 缺点
    • 工厂类不太理想,由于每增长一产品,都要在工厂类中增长相应的生产判断逻辑,这是违背开闭原则的
public interface Sender{  public void send();  }  
public class MailSender implements Sender {  
    @Override  
    public void send() {  
        System.out.println("this is mailsender!");  
    }  
}
public class SmsSender implements Sender {  
    @Override  
    public void send() {  
        System.out.println("this is sms sender!");  
    }  
}
public class SendFactory {  
    public Sender produce(String type) {  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            return null;  
        }  
    } 
    //若还有其余产品 则在工厂里加对应的 produce 方法
}  

建造者模式

主要解决在软件系统中一个复杂对象的建立工做,其一般由各个部分的子对象用必定的算法构成;因为需求的变化,这个复杂对象的各个部分常常面临着剧烈的变化,可是将它们组合在一块儿的算法却相对稳定算法

  • 优势
    • 扩展性好,对象每个属性的构建相互独立,有利于解耦。
    • 建造者能够对建立过程逐步细化,而不对其它模块产生任何影响,便于控制细节风险
  • 缺点
    • 若是对象建造者发生变化,则建造者也要同步修改,后期维护成本较大
    • 一种建造者对应一种类型建造,一个建造者基本很难建造多种类型对象
@Data
class Product {
    private String name;
    private String price;
    // Product 的建造者  Builder
    public static class Builder{
        public static Builder builder(){
            Builder builder = Builder();
        }
        private Product product = new Product();
        public Builder name(String name){ product.name = name; return this;}
        public Builder price(String price){ product.price = price; return this; }
        //返回产品对象
        public Product build() { return product; }
    }
}

结构型

适配器模式

连通上下游功能。通常是现有的功能和产品要求的接口不兼容,须要作转换适配。平时见到的 PO,BO,VO,DTO 模型对象之间的相互转换也是一种适配的过程spring

  • 优势:提升了类的复用,灵活性好
  • 缺点:过多地使用适配器,会让系统很是零乱,不易总体进行把握。好比,明明看到调用的是 A 接口,其实内部被适配成了 B 接口的实现
//类的适配器模式
public class Source {  
    public void sayHello() {  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
// Source 用 Adapter 适配成 Targetable
public class Adapter extends Source implements Targetable {  
    @Override  
    public void hi() {  
        System.out.println("csc:hi!");  
    }  
}
//对象的适配器模式
public class Source {  
    public void sayHello() {  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
//  Source的对象适配成 Targetable
public class Adapter implements Targetable {
    private Source source;  
    public Adapter(Source source){ this.source = source; }
    public void sayHello(){ source.sayHello(); }
    @Override  
    public void hi() {  
        System.out.println("csc:hi!");  
    }  
}

装饰器模式

加强对象功能,动态的为一个对象增长功能,并且还能动态撤销。(继承不能作到这一点,继承的功能是静态的,不能动态增删)sql

public interface Show(){ public void acting(); }
public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}  
public class DecoratorArtist implements Show{
    Artist artist;
    DecoratorArt(Artist artist){
        this.artist = artist;
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //加强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //加强的功能
    }
}

代理模式

代理类是客户类和委托类的中介,能够经过给代理类增长额外的功能来扩展委托类的功能,这样只须要修改代理类而不须要再修改委托类,符合代码设计的开闭原则数据库

  • 和装饰器模式的区别:代理模式着重于加强类功能,且对面屏蔽原对象的建立过程;装饰器模式加强的是对象,且装饰器模式有一个动态传递原对象的步骤
  • 和对象的适配器模式优势像:不过代理模式着重的是对原功能加强,适配器模式着重的是对新功能的兼容
  • 优势-一、职责清晰。 二、高扩展性
public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}
public class ProxyArtist implements Show{
    Artist artist;
    ProxyArtist(){ 
        this.artist = new Artist();//屏蔽了 artist 对象的建立
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //加强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //加强的功能
    }
}
public class Demo {
    public static void main(String[] arg){
        Show show = new ProxyArtist();
        show.acting();
    }
}

桥接模式

桥接模式侧重于功能的抽象,从而基于这些抽象接口构建上层功能。通常的java 项目都会将接口和实现分离缘由,就是基于桥接模式。提升了系统的扩展能力,当引用的底层逻辑有不一样的设计实现时,继承抽象接口从新实现一套便可,旧的不变,符合代码设计的开闭原则数组

  • jdbc 的驱动:经常使用的JDBC 和 DriverManager,JDBC进行链接数据库的时候,在各个数据库之间进行切换,基本不须要动太多的代码,缘由就是JDBC提供统一接口,每一个数据库提供各自的实现,用一个叫作数据库驱动的程序来桥接
  • Unix 的文件系统:VFS(virtual File System)使得 Unix 系统能够在不一样物理介质上的不一样文件系统进行读写
public interface FileSystem(){ 
  public void open(int file); 
  public String loading(int file); 
  public void store(int file, String data); 
}
//网络上的文件系统
public class NetFileSystem implements FileSystem {  
  public void open(int file){ System.out.println(" netfile opening...."); }
  public String loading(int file) {System.out.println(" net loading ...."); }  
  public void store(int file, String data) {System.out.println(" send to network ...."); }  
}
//磁盘文件系统
public class DiskFileSystem implements FileSystem{
  public void open(int file){ System.out.println(" disk opening...."); }
  public String loading(int file) {System.out.println(" disk loading ...."); } 
  public void store(int file, String data) {System.out.println(" write back disk ...."); }   
}
public class Linux {
    FileSystem fileSystem; 
    //底层功能提供接口,桥接模式:功能和具体实现分离
    //能够桥接 NetFileSystem 或者 DiskFileSystem 做为文件系统
    public void set(FileSystem fileSystem){ this.fileSystem = fileSystem; }
    //上层功能读数据
    public String read(int file){
        fileSystem.open(file);
        ... // Linux 本身的系统功能
        fileSystem.loading(file);
        ... 
    }
    //上层功能写数据
    public String write(int file, String data){
        fileSystem.open(file);
        ....
        fileSystem.store(file,data);
    }
}
  • 可配合适配器模式使用

享元模式

多个对象共享某些属性。在建立有大量对象时,可能会形成内存溢出,把其中共同的部分抽象出来,若是有相同的请求,直接返回在内存中同一份属性,避免从新建立网络

  • 如 jdbc 链接池的链接对象,它们会共享池对象的 url、driverClassName、username、password 等属性
public class ConnectionPool {  
    private Vector<Connection> pool;  
    /*公有属性*/  
    private String url = "jdbc:mysql://localhost:3306/test";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
    public ConnectionPool() {  
        pool = new Vector<Connection>(poolSize);  
        for (int i = 0; i < poolSize; i++) {  
            Class.forName(driverClassName);  
                // 每个 conn 共享了 driverClassName ,url, username, password 等属性
                Connection conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);
            }
    }
    ....
}

外观模式

  • 用多个不一样的对象实现一组更复杂的功能。使得类与类之间的关系解耦。如 spring 将使用各个简单的 component、dao 实现复杂的service,就是一种外观模式
  • 功能的组合,组合优于继承
public class DAO { 
    public void queryData(){
        System.out.print(" query data ")
    }
}
public class Deal {  
    public void dealData(){
        System.out.print(" dealing data ")
    }
}
public class Sender {  
    public void send(){
        System.out.print(" send data ")
    }
}
public class Service(){
    private DAO dao;  
    private Deal deal;  
    private Sender sender;
    //封装 DAO,Deal,Sender 的功能,统一对外提供服务
    public void reponse(){
        dao.queryData();
        deal.dealData();
        sender.send();
    }
}

行为型

策略模式

策略模式侧重于不一样的场景使用不一样的策略。在有多种算法类似的状况下,解决 if...else 所带来的复杂和难以维护并发

  • 和桥接模式的区别:而桥接模式是结构型模式,侧重于分离底层功能的抽象和实现,底层只有一种实现也能够
// 上学的策略
abstract class Strategy{
    private static final Map<Integer,Strategy> strategyMap = new ConcurrentHashMap<>();
    public Strategy(){
        strategyMap.put(getType(), this);
    }
    public static Strategy routing(int type){
        return strategyMap.get(type);
    }
    abstract int getType();
    abstract void method(); //留待子类实现差别
}
//跑路去学校
class RunningStrategy extends Strategy{
    int getType() { return 0; }
    void method() { System.out.println(" Run to school "); }
}
//公交去学校
class BusStrategy extends Strategy{
    int getType() { return 1; }
    void method() { System.out.println(" Go to school by bus "); }
}
//飞去学校
class FlyStrategy extends Strategy{
    int getType() { return 2; }
    void method() { System.out.println(" Fly to school "); }
}
class Context{
    //使用不一样的策略
    void method(int strategy){
        Strategy.routing(strategy).method();
    }
}

模板方法

和享元模式有必定的类似处,享元模式侧重于属性的共享,并且是结构上的引用,不必定须要继承;而模板方法是共享相同行为,必定有继承行为ide

  • 区别于策略模式是它有能抽象出来的共同行为,每个子类再实现有差别细节
abstract class AbstractHandler{
    // handle是抽象出来的共同逻辑
    void handle(String data){
        System.out.println("通用逻辑1...");
        stepOne(data);
        System.out.println("通用逻辑2...");
        stepTwo(data);
        System.out.println("通用逻辑3...");
    }
    abstract void stepOne(String data); //留待子类实现差别
    abstract void stepTwo(String data); //留待子类实现差别
}
class HelloHandler extends AbstractHandler{
    @Override
    void stepOne(String data) {
        System.out.println("hello: "+data);
    }
    @Override
    void stepTwo(String data) {
        System.out.println("hi: "+data);
    }
}

迭代子模式

循环处理多个相同对象,用来遍历集合或者数组

//迭代的抽象接口
public interface Iterator {  
    //前移  
    public Object previous();  
    //后移  
    public Object next();  
    public boolean hasNext();   
} 
// 数组的迭代类
public class ArrayIterator implements Iterator {  
    private Object[] datas; 
    private int cur = 0;  
    public ArrayIterator(Object[] datas){  
        this.datas = datas;  
    }  
    public String previous() {  
        if(cur > 0){ cur--;}  
        return datas[cur];  
    }  
    public Object next() {  
        if(cur < datas.length-1){ cur++;}  
        return datas[cur];  
    }  
    public boolean hasNext() {  
        return pos < datas.length-1 ? true :false;
    }  
}  

责任链模式

负责处理上游的传递下来的对象,并传递给下一个处理者

  • 和迭代子模式的区别,责任链模式是多个hander处理同一个data,且 hander 处理具备顺序性,不用所有 hander 处理,可在某一 hander 中断,也可继续传递
abstract class Handler<T,R> {
    private Handler<R,?> next;
    abstract R handle(T data);
    public void setNext(Handler<R, ?> next){ this.next = next; }
    public void loopHandle(T data){
        R result = this.handle(data);
        if(next!=null && result!=null ) { next.loopHandle(result); }
    }
}
//负责问候
class HelloHandler extends Handler<String, Integer> {
    Integer handle(String data) {
        System.out.println(data + " hello! ");
        return 10;
    }
}
//负责计数
class CountHandler extends Handler<Integer, Double> {
    Double handle(Integer data) {
        System.out.println(" it is " + data);
        return 2.0;
    }
}
public class demo{
    public static void main(String[] args){
        HelloHandler hello = new HelloHandler();
        CountHandler count = new CountHandler();
        hello.setNext(count);
        hello.loopHandle("lwl");
    }
}

观察者模式

事件通知: 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,全部依赖于它的对象都获得通知

  • 优势:观察者和被观察者是抽象耦合的
  • 缺点
    • 若是一个被观察者对象有不少的直接和间接的观察者的话,将全部的观察者都通知到会花费不少时间
    • 若是在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能致使系统崩溃
//观察者
public abstract class Observer<T> {
    public abstract void update(T data);
}
// 被观察对象
public class Subject<T> {
    private List<Observer<T>> observers = new ArrayList<>();
    private T state;
    public void deal() { 
        ....// 逻辑处理
        //若是修改了 state,通知观察者
        if(...) notifyAllObservers();
    }
    //增长一个观察观察
    public void observe(Observer<T> observer) {
        observers.add(observer);
    }
    public void notifyAllObservers() {
        for (Observer<T> observer : observers) {
            observer.update(state);
        }
    }
}

状态机模式

不一样的状态不一样的响应,实现状态之间的转移

  • 和策略模式的区别
    • 状态机模式是策略模式的孪生兄弟。策略模式可让用户指定更换的策略算法,而状态机模式是状态在知足必定条件下的自动更换,用户没法指定状态,最多只能设置初始状态
    • 状态机模式重点在各状态之间的切换,从而作不一样的事情;而策略模式更侧重于根据具体状况选择策略,并不涉及切换
interface State<T> {
    //当前状态进行处理数据,并返回下一个状态
    abstract State<T> action(T data);
}
@Data
class Context<T>{
    private State<T> state;
    public void invoke(T data){
        state != null ? state = state.action(data) : System.out.println(" nothing " + data);
    }
}
// HelloState -> HiState
class HelloState implements State<String>{
    public State<String> action(String data) {
        System.out.println("hello!" + data);
        return new HiState();
    }
}
// HiState -> FineState
class HiState implements State<String>{
    public State<String> action(String data) {
        System.out.println("how are you ?" + data);
        return new FineState();
    }
}
//最后的状态
class FineState implements State<String>{
    public State<String> action(String data) {
        System.out.println("I am  fine!");
        return null;
    }
}
public class demo{
    public static void main(String[] args){
        Context<String> context = new Context<>();
        context.setState(new HelloState());
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
    }
}

备忘录

记录上一次的状态,方便回滚。不少时候咱们是须要记录当前的状态,这样作的目的就是为了容许用户取消不肯定或者错误的操做,恢复到原先的状态

  • 缺点:消耗资源。若是类的成员变量过多,势必会占用比较大的资源,并且每一次保存都会消耗必定的内存
@Data
public class Memento { 
    private String state;
    public Memento(String state){ this.state = state; }
}
@Data
public class Storage { 
    private String value;  
    public void storeMemento(){
        return new Memento(value);  
    }
    public void restoreMemento(Memento memento){  
        this.value = memento.getValue();  
    }
    public void action(){ System.out.println(" Storage类逻辑运行 ");}
      
}
public class MementoPatternDemo { 
    public static void main(String[] args) {
        Storage storage = new Storage();
        storage.setValue(1);
        storage.storeMemento();//备忘,一下
        storage.action();//....逻辑运行
        restoreMemento(Memento memento);//使用备忘录的恢复状态
    }
}