设计模式系列

最新推荐文章于 2023-07-07 13:51:22 发布

后端技术那点事

最新推荐文章于 2023-07-07 13:51:22 发布

阅读量329

点赞数 1

CC 4.0 BY-SA版权

分类专栏：设计模式系列面试系列文章标签：设计模式 java 图解案例实操应用场景

本文链接：https://blog.youkuaiyun.com/prefect_start/article/details/124518787

面试系列同时被 2 个专栏收录

44 篇文章

订阅专栏

设计模式系列

4 篇文章

订阅专栏

在这里插入图片描述

因为代码比较多，可以下载设计模式案例代码查看，以上是设计模式代码的案例目录
代码下载

1、设计模式的七大原则

1.1、单一职责原则 (Single Responsibility Principle)

一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a class to change）
简单来说指的是每个类只负责自己的事情，而不是变成万能

1.2、开放-关闭原则 (Open-Closed Principle)

软件实体应当对扩展开放，对修改关闭（Software entities should be open for extension，but closed for modification），简单来说指的是扩展新类而不是修改旧类。
合成复用原则、里氏替换原则相辅相成，都是开闭原则的具体实现规范。

1.3、里氏替换原则 (Liskov Substitution Principle)

继承必须确保超类所拥有的性质在子类中仍然成立（Inheritance should ensure that any property proved about supertype objects also holds for subtype objects）

简单来说指的是继承父类而不去改变父类.

1.4、依赖倒转原则 (Dependence Inversion Principle)

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象（High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions）
简单来说指的是面向接口编程，而不是面向实现类

1.5、接口隔离原则 (Interface Segregation Principle)

一个类对另一个类的依赖应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。
简单来说指的是各个类建立自己的专用接口，而不是建立万能接口

1.6、迪米特法则（Law Of Demeter）

最少知识原则（Least Knowledge Principle，LKP)，只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）
简单来说指的是无需直接交互的两个类，如果需要交互，使用中间者

过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低

1.7、组合/聚合复用原则 (Composite/Aggregate Reuse Principle)

又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）
软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

简单来说指的是优先组合，其次继承

2、设计模式的分类

2.1、创建型模式（Creational Patterns）

单例（Singleton）模式
原型（Prototype）模式
工厂方法（FactoryMethod）模式
抽象工厂（AbstractFactory）模式
建造者（Builder）模式

2.2、结构型模式（Structural Patterns）

代理（Proxy）模式
适配器（Adapter）模式
桥接（Bridge）模式
装饰（Decorator）模式
外观（Facade）模式
享元（Flyweight）模式
组合（Composite）模式
过滤器模式（Filter Pattern）

2.3、行为型模式（Behavioral Patterns）

模板方法（Template Method）模式
策略（Strategy）模式
命令（Command）模式
职责链（Chain of Responsibility）模式
状态（State）模式
观察者（Observer）模式
中介者（Mediator）模式
迭代器（Iterator）模式
访问者（Visitor）模式
备忘录（Memento）模式
解释器（Interpreter）模式

3、设计模式详解-创建型模式

创建型模式关注点“怎样创建出对象？
“将对象的创建与使用分离”，降低系统的耦合度，使用者无需关注对象的创建细节

对象的创建由相关的工厂来完成；（各种工厂模式）
对象的创建由一个建造者来完成；（建造者模式）
对象的创建由原来对象克隆完成；（原型模式）
对象始终在系统中只有一个实例；（单例模式）

3.1、单例（Singleton）模式

3.1.1、概述

一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建。

3.1.2、模式图解

在这里插入图片描述

某个类只能有一个实例；（构造器私有）
它必须自行创建这个实例；（自己编写实例化逻辑）
它必须自行向整个系统提供这个实例；（对外提供实例化方法）

3.1.3、代码实现

package com.song.design.creatation.singleton;

/**
 * boss只能有一个
 */
public class Person {
    private String name;
    private String age;

    //懒汉、饿汉
    private volatile static Person instance;  //饿汉

    //构造器私有，外部不能实例化
    private Person() {
        System.out.println("创建了Person");
    }


    //提供给外部的方法
    //1、public static synchronized Person guiguBoss() 锁太大
    //2、双重检查锁+内存可见性（设计模式）
    public static Person guiguBoss() {
        //如果没有再去创建
        if (instance == null) {
            synchronized (Person.class) {
                if(instance == null){
                    Person person = new Person();
                    //多线程问题
                    instance = person;
                }
            }
        }
        return instance;
    }
}

package com.song.design.creatation.singleton;
public class MainTest {
    public static void main(String[] args) {
	      Person person1 = Person.guiguBoss();
      	  Person person2 = Person.guiguBoss();
          System.out.println(person1 == person2);
    }
}

3.1.4、应用场景

多线程中的线程池
数据库的连接池
系统环境信息
上下文（ServletContext）
…

3.2、原型（Prototype）模式

3.2.1、概述

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。本体给外部提供一个克隆体进行使用

将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。

3.2.2、模式图解

在这里插入图片描述

3.2.3、代码实现

package com.song.design.creatation.prototype;
import java.util.HashMap;
import java.util.Map;
public class GuiguMybatis {
    //缓存user.序列化和反序列化-深克隆
    private Map<String,User> userCache = new HashMap<>();
    /**
     * 从数据库查数据
     * @return
     */
    public User getUser(String username) throws Exception {
        User user = null;
        //缓存中没有
        if(!userCache.containsKey(username)){
            //查询数据库
            user = getUserFromDb(username);
        }else {
            //从缓存中直接拿，脏缓存问题
            //原型已经拿到，但是不能直接给。（本人）
            user = userCache.get(username);
            System.out.println("从缓存中拿到的是："+user);
            //从这个对象快速得到一个克隆体（克隆人）==原型模式
            user = (User) user.clone();
        }
        return user;
    }

    private User getUserFromDb(String username) throws Exception{
        System.out.println("从数据库查到："+username);
        User user = new User();
        user.setUsername(username);
        user.setAge(18);
        //给缓存中放一个clone
        userCache.put(username, (User) user.clone());
        return user;
    }
}

package com.song.design.creatation.prototype;

import lombok.Data;

/**
 * 当前对象是可克隆的
 */
@Data
public class User implements Cloneable {

    private String username;
    private Integer age;
    /**
     * 再创建一个人，赋予我的所有属性
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        User user = new User();
        user.setUsername(username);
        user.setAge(age);
        return user;
    }
}

package com.song.design.creatation.prototype;

/**
 * 是用于创建重复的对象，同时又能保证性能。
 * 1、GuiguMyBatis：操作数据库，从数据库里面查出很多记录（70%改变很少）
 * 2、每次查数据库，查到以后把所有数据都封装一个对象，返回。
 *    10000 thread：查一个记录： new User("zhangsan",18)；每次创建一个对象封装并返回
 *    系统里面就会有10000个User;浪费内存
 * 3、解决：缓存；查过的保存。
 *          如果再查相同的记录，拿到原来的原型对象
 *
 * 4、此时直接拿到缓存中的对象。
 *
 *
 */
public class MainTest {

    public static void main(String[] args) throws Exception {
        GuiguMybatis mybatis = new GuiguMybatis();

        //十分危险
        //得到的是克隆体
        User zhangsan1 = mybatis.getUser("zhangsan");
        System.out.println("1==>"+zhangsan1);
        zhangsan1.setUsername("李四2.。。");
        System.out.println("zhangsan1自己改了："+zhangsan1);


        //得到的是克隆体
        User zhangsan2 = mybatis.getUser("zhangsan");
        System.out.println("2-->"+zhangsan2);

        //得到的是克隆体
        User zhangsan3 = mybatis.getUser("zhangsan");
        System.out.println("3-->"+zhangsan3);

        //得到的是克隆体
        User zhangsan4 = mybatis.getUser("zhangsan");
        System.out.println("4-->"+zhangsan4);

        System.out.println(zhangsan1 == zhangsan3);

    }
}

3.2.5、应用场景

资源优化
性能和安全要求
一个对象多个修改者的场景。
一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时可以考虑使用原型模式拷贝多个对象供调用者使用。
深（两个完全对象不一样的【递归克隆】，内容却完全一样）、浅（只是属性赋值）…
…

3.3、简单工厂（Simple Factory）模式

3.3.1、概述

三个角色

Factory：工厂角色， WuLinFactory
Product：抽象产品角色，Car
ConcreteProduct：具体产品角色， VanCar、MiniCar

3.3.2、模式图解

在这里插入图片描述

缺点：违背开闭，扩展不易

3.3.3、代码实现

package com.song.design.creatation.factory.simplefactory;


/**
 * 简单工厂
 * 1、产品数量极少
 */
public class WuLinSimpleFactory {

    /**
     *
     * @param type  Class: 好像具有扩展性，但是没有解决实际问题
     * @return
     */
    public AbstractCar newCar(String type){

        //核心方法：一切从简
        if("van".equals(type)){
            // 钣金、喷漆、放发动机、申请环保

            return new VanCar();
        }else if("mini".equals(type)){
            return new MiniCar();
        }

        //.....

        //更多的产品，违反开闭原则。应该直接扩展出一个类来造
        return null;
    }
}

package com.song.design.creatation.factory.simplefactory;

/**
 * 工厂的产品
 */
public abstract class AbstractCar {

    String engine;
    public abstract void run();
}

package com.song.design.creatation.factory.simplefactory;

public class MiniCar extends AbstractCar{

    public MiniCar(){
        this.engine = "四缸水平对置发动机";
    }

    @Override
    public void run() {
        System.out.println(engine+"--> 嘟嘟嘟...");
    }
}

package com.song.design.creatation.factory.simplefactory;

/**
 * 具体产品
 */
public class VanCar extends AbstractCar{
    public VanCar(){
        this.engine = "单杠柴油机";
    }

    @Override
    public void run() {
        System.out.println(engine+"--》嗒嗒嗒....");
    }
}

package com.song.design.creatation.factory.simplefactory;

public class MainTest {

    public static void main(String[] args) {

        WuLinSimpleFactory factory = new WuLinSimpleFactory();

        AbstractCar van = factory.newCar("van");
        AbstractCar mini = factory.newCar("mini");
        van.run();
        mini.run();

    }
}

3.3.4、应用场景

NumberFormat、SimpleDateFormat
LoggerFactory：
SqlSessionFactory：MyBatis
BeanFactory：Spring的BeanFactory（就是为了造出bean）
…

3.4、工厂方法（FactoryMethod）模式

3.4.1、概述

四个角色

Product：抽象产品
ConcreteProduct：具体产品
Factory：抽象工厂
ConcreteFactory：具体工厂

3.4.2、模式图解

在这里插入图片描述

缺点：系统复杂度增加，产品单一

设计模式系列

1、设计模式的七大原则

1.1、单一职责原则 (Single Responsibility Principle)

1.2、开放-关闭原则 (Open-Closed Principle)

1.3、里氏替换原则 (Liskov Substitution Principle)

1.4、依赖倒转原则 (Dependence Inversion Principle)

1.5、接口隔离原则 (Interface Segregation Principle)

1.6、迪米特法则（Law Of Demeter）

1.7、组合/聚合复用原则 (Composite/Aggregate Reuse Principle)

2、设计模式的分类

2.1、创建型模式（Creational Patterns）

2.2、结构型模式（Structural Patterns）

2.3、行为型模式（Behavioral Patterns）

3、设计模式详解-创建型模式

3.1、单例（Singleton）模式

3.1.1、概述

3.1.2、模式图解

3.1.3、代码实现

3.1.4、应用场景

3.2、原型（Prototype）模式

3.2.1、概述

3.2.2、模式图解

3.2.3、代码实现

3.2.5、应用场景

3.3、简单工厂（Simple Factory）模式

3.3.1、概述

3.3.2、模式图解

3.3.3、代码实现

3.3.4、应用场景

3.4、工厂方法（FactoryMethod）模式

3.4.1、概述

3.4.2、模式图解

3.4.3、代码实现

3.4.4、应用场景

3.5、抽象工厂（AbstractFactory）模式

3.5.1、概述

3.5.2、模式图解

3.5.3、代码实现

3.5.4、应用场景

3.6、建造者（Builder）模式

3.6.1、概述

3.6.2、模式图解

3.6.3、代码实现

3.6.4、应用场景

4、设计模式详解-结构型模式

4.1、代理（Proxy）模式

4.1.1、概述

4.1.2、模式图解

4.1.3、代码实现

4.1.4、应用场景

4.2、适配器（Adapter）模式

4.2.1、概述

4.2.2、模式图解

4.2.3、代码实现

4.2.4、应用场景

4.3、桥接（Bridge）模式

4.3.1、概述

4.3.2、模式图解

4.3.3、代码实现

4.3.4、应用场景

4.4、装饰（Decorator）模式

4.4.1、概述

4.4.2、模式图解

4.4.3、代码实现

4.4.4、应用场景

4.5、外观（Facade）模式

4.5.1、概述

4.5.2、模式图解

4.5.3、代码实现

4.5.4、应用场景

4.6、享元（Flyweight）模式

4.6.1、概述

4.6.2、模式图解

4.6.3、代码实现

4.6.4、应用场景

4.7、组合（Composite）模式

4.7.1、概述

4.7.2、模式图解

4.7.3、代码实现

4.7.4、应用场景