设计模式及其应用

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

7.单一职责原则

一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

单例模式：某个类只能有一个实例，提供一个全局的访问点。spring的天下，个人编程并不需要自己创建单例

简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。常用，但不符合开闭原则

工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。不常用，1工厂-1产品

抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。不常用，但很完美的符合了设计原则（1工厂-n产品）

建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。链式调用

原型模式：通过复制现有的实例来创建新的实例。借助序列化实现深度克隆

适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。不常用（类适配、接口适配、方法适配）

组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。不常用

装饰模式：动态的给对象添加新的功能。常用，和代理写法上，几乎一致

代理模式：为其他对象提供一个代理以便控制这个对象的访问。AOP（cglib、jdk）、AspectJ

亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。线程池、数据库连接池、缓存池

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。迪米特法则

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。ODBC的实现

模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。常用

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。几乎不用

策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。常用

状态模式：允许一个对象在其对象内部状态改变时改变它的行为。相对常用，实际项目中，常与volatile结合

观察者模式：对象间的一对多的依赖关系。发布-订阅，spring初始化，大量用到了观察者

备忘录模式：在不破坏封装的前提下，保持对象的内部状态。几乎不用

中介者模式：用一个中介对象来封装一系列的对象交互。常用

命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。几乎不用，Struts中大量使用

访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。不常用，最复杂的一种模式

责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。相对常用，审批流

迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。不会自行编写，java集合中大量使用

创建型模式

工厂模式

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

/**
 * Description: 简单工厂模式
 *
 * 优点：实现对象的创建和使用的分离
 * 缺点：工厂类集中了所有产品创建逻辑
 */
public class SimpleFactory {
    public static Product produceProduct(String type){
        Product product = null;
        if(type.equals("A"))
            product =  new ProductA();
        if(type.equals("B"))
            product =  new ProductB();
        return product;
    }

    public static void main(String[] args) {
        Product product = SimpleFactory.produceProduct("A");
        product.produce();
    }

}

abstract class Product{
    public abstract void produce();
}
class ProductA extends Product{

    @Override
    public void produce() {
        System.out.println("产品A");
    }
}
class ProductB extends Product{
    @Override
    public void produce() {
        System.out.println("产品B");
    }
}

抽象工厂模式

/**
 * 工厂方法模式：每一个具体工厂都负责生产一种具体的产品
 * 抽象工厂：在一个产品族里面，定义多个产品。
 * */
public class FactoryMethod {

    public static void main(String[] args) {
        AbstractFactory bydFactory = new BYDFactory();
        AbstractFactory tslFactory = new TSLFactory();
        bydFactory.produce().generate();
        tslFactory.produce().generate();
        bydFactory.mask().produceMask();
    }
}

interface AbstractFactory{
    Car produce();
    // 可以新增某一大类
    Mask mask();
}


interface Mask{
    void produceMask();
}
interface Car{
    void generate();
}

class BYDFactory implements AbstractFactory{

    @Override
    public Car produce() {
        return new BYD();
    }

    @Override
    public Mask mask() {
        return new MaskWUHAN();
    }
}

class TSLFactory implements AbstractFactory{

    @Override
    public Car produce() {
        return new TSL();
    }

    @Override
    public Mask mask() {
        return new MaskWUHAN();
    }
}

class TSL implements Car{

    @Override
    public void generate() {
        System.out.println("特斯拉");
    }
}

class BYD implements Car{

    @Override
    public void generate() {
        System.out.println("比亚迪");
    }
}

class MaskWUHAN implements Mask{

    @Override
    public void produceMask() {
        System.out.println("还可以生产口罩");
    }
}

单例模式

单例模式确保某一个类只有一个实例，并提供一个访问它的全局访问点。

代码举例：

/*
饿汉式:
类加载到内存中，就实例化一个单例，JVM保证线程安全
唯一缺点：不管用到与否，类装载时就完成实例化
*/
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

/*
懒汉式:
虽然达到了按需加载的目的，但却带来线程不安全的问题
*/
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

/*
双检锁/双重校验锁
*/
public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}
/*
静态内部类
*/
public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

/*
枚举
*/
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
} 

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式

public class BuildPattern {
    public static void main(String[] args) {
        Builder builder = new Builder();
        System.out.println(builder.levelOne(new BigDecimal(20)).getDetail());
        System.out.println(builder.levelTwo(new BigDecimal(10)).getDetail());
    }
}

class Builder{
    IMenu levelOne(BigDecimal area) {
        return new DecorationMenu(area, "豪华欧式")
                .appendCelling(new LevelOneCeiling())
                .appendFloor(new DerFloor());
    }
    IMenu levelTwo(BigDecimal area){
        return new DecorationMenu(area, "轻奢⽥园")
                .appendCelling(new LevelOneCeiling())
                .appendFloor(new DerFloor());
    }
}

interface Matter{
    String scene(); // 场景；地板、地砖、涂料、吊顶
    String brand(); // 品牌
    String model(); // 型号
    BigDecimal price(); // 价格
    String desc(); // 描述
}

interface IMenu{
    IMenu appendCelling(Matter matter);  // 吊顶
    IMenu appendFloor(Matter matter); // 地板
    String getDetail(); // 明细
}

class DecorationMenu implements IMenu{
    private BigDecimal area; // ⾯积
    private String grade; // 装修等级；豪华欧式、轻奢⽥园、现代简约

    private List<Matter> list = new ArrayList<Matter>(); // 装修清单
    private BigDecimal price = BigDecimal.ZERO; // 装修价格

    public DecorationMenu(BigDecimal area, String grade) {
        this.area = area;
        this.grade = grade;
    }
    public DecorationMenu() {}

    public IMenu appendCelling(Matter matter) {
        list.add(matter);
        price = price.add(area.multiply(new
                BigDecimal("0.2")).multiply(matter.price()));
        return this;
    }

    public IMenu appendFloor(Matter matter) {
        list.add(matter);
        price = price.add(area.multiply(new
                BigDecimal("1.4")).multiply(matter.price()));
        return this;
    }

    public String getDetail() {
        StringBuilder detail = new StringBuilder("\r\n--------------------\r\n" +
                "装修清单" + "\r\n" +
                "套餐等级：" + grade + "\r\n" +
                "套餐价格：" + price.setScale(2, BigDecimal.ROUND_HALF_UP) +
                " 元\r\n" +
                "房屋⾯积：" + area.doubleValue() + " 平⽶\r\n" +
                "材料清单：\r\n");
        for (Matter matter: list) {
            detail.append(matter.scene()).append("：").append(matter.brand()).
                    append("、").append(matter.model()).append("、平⽶价格：").
                    append(matter.price()).append(" 元。\n");
        }
        return detail.toString();
    }
}

class LevelOneCeiling implements Matter{
    public String scene() {
        return "吊顶";
    }
    public String brand() {
        return "装修公司⾃带";
    }
    public String model() {
        return "⼀级顶";
    }
    public BigDecimal price() {
        return new BigDecimal(260);
    }
    public String desc() {
        return "造型只做低⼀级，只有⼀个层次的吊顶，⼀般离顶120-150mm";
    }
}

class DerFloor implements  Matter{
    public String scene() {
        return "地板";
    }
    public String brand() {
        return "德尔(Der)";
    }
    public String model() {
        return "A+";
    }
    public BigDecimal price() {
        return new BigDecimal(119);
    }
    public String desc() {
        return "DER德尔集团是全球领先的专业⽊地板制造商，北京2008年奥运会家装和公装地板供应商";
    }
}

原型模式

Java中的Object类提供了浅克隆的clone()方法，具体原型类只要实现Cloneable接口就可实现对象的浅克隆。

原型模式主要解决的问题就是创建重复对象，⽽这部分对象内容本身⽐较复杂，⽣成过程可能从库或者RPC接⼝中获取数据的耗时较⻓，因此采⽤克隆的⽅式节省时间。

public class Location01 implements Cloneable{
    String street;
    int roomNo;
    public Location01(String street, int roomNo){
        this.street = street;
        this.roomNo = roomNo;
    }

    public String toString(){
        return "Location["+"street:"+street+",roomNo:"+roomNo+"]";
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Location01 location01 = new Location01("黄河大街", 1001);
        Location01 clone = (Location01) location01.clone();
        System.out.println(location01);
        System.out.println(clone);
        System.out.println(location01 == clone);
    }
}

结构型模式

适配器模式

桥接模式

过滤器模式

组合模式

装饰器模式

public class DecoratorPattern07 {
    public static void main(String[] args) {
        RedShapeDecorator decorator = new RedShapeDecorator(new Circle());
        decorator.draw();
    }
}
interface Shape{
    void draw();
}
class Rectangle implements Shape{
    public void draw() {
        System.out.println("正方形...");
    }
}

class Circle implements Shape{
    public void draw() {
        System.out.println("圆形...");
    }
}

abstract class ShapeDecorator implements Shape{
    protected Shape shape;

    public ShapeDecorator(Shape shape) {
        this.shape = shape;
    }

    public void draw(){
        shape.draw();
    }
}

class RedShapeDecorator extends ShapeDecorator{

    public RedShapeDecorator(Shape shape) {
        super(shape);
    }

    @Override
    public void draw() {
        shape.draw();
        System.out.println("给形状添加红色");
    }
}

外观模式

享元模式

package com.design;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description: 享元模式
 **/
public class FlyweightPattern05 {
    public static void main(String[] args) {
        String[] strArr = new String[]{"red","green","blue","green"};
        for (String str : strArr) {
            Color circle = ShapeFactory.getCircle(str);
            System.out.println(circle);
            circle.draw();
        }
    }
}

interface Color{
    void draw();
}

class DrawColor implements Color{
    String color;
    Integer radius;

    public DrawColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Integer getRadius() {
        return radius;
    }

    public void setRadius(Integer radius) {
        this.radius = radius;
    }

    public void draw() {
        System.out.println("color: " + color + " radius: " + radius);
    }
}

class ShapeFactory{
    private static final Map circleMap = new HashMap<String, Color>();
    public static Color getCircle(String color) {
        DrawColor circle = (DrawColor)circleMap.get(color);
        if(circle == null) {
            circle = new DrawColor(color);
            circleMap.put(color, circle);
        }
        return circle;
    }
}

代理模式

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

package com.design;
/**
 * @Description: 代理模式
 **/
public class ProxyPattern08 {
    public static void main(String[] args) {
        Movable proxyObject = new ProxyTask(new Task());
        proxyObject.run();
    }
}

interface Movable{
    void run();
}

class Task implements Movable{
    public void run() {
        System.out.println("Task is running...");
    }
}

class ProxyTask implements Movable{

    Movable movable;

    public ProxyTask(Movable movable) {
        this.movable = movable;
    }
    public void run() {
        System.out.println("Task start running...");
        movable.run();
        System.out.println("Task end running...");
    }
}

行为型模式

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

责任链模式

责任链模式(Chain of Responsibility)使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象能够处理它。

public class Main {
    public static void main(String[] args) {
        LeaveChain leaveChain = new LeaveChain();
        Person person = new Person("张三",16,"生病了");
        leaveChain.addLeave(new GroupLeader())
                .addLeave(new ManagerLeader())
                .addLeave(new BigManager());

        leaveChain.doFilter(person);
    }
}

class Person{
    String name;
    Integer day;
    String content;

    public String getName() {
        return name;
    }

    public Integer getDay() {
        return day;
    }

    public String getContent() {
        return content;
    }

    public Person(String name, Integer day, String content) {
        this.name = name;
        this.day = day;
        this.content = content;
    }
}

interface Leave {
    boolean doFilter(Person person);
}

class ManagerLeader implements Leave{

    @Override
    public boolean doFilter(Person person) {
        if(person.getDay() <= 7 && person.getDay() > 3){
            System.out.println("经理批准");
            return true;
        }
        return false;
    }
}

class GroupLeader implements  Leave{

    @Override
    public boolean doFilter(Person person) {
        if(person.getDay() <= 3){
            System.out.println("组长批准");
            return true;
        }
        return false;
    }
}

class BigManager implements Leave{

    @Override
    public boolean doFilter(Person person) {
        if(person.getDay() >= 15 && person.getDay() <= 60){
            System.out.println("总经理批准");
            return true;
        }else{
            System.out.println("无法处理您的请假要求！");
        }
        return false;
    }
}

class LeaveChain implements Leave{
    List<Leave> list = new ArrayList<>();

    public LeaveChain addLeave(Leave leave){
        list.add(leave);
        return this;
    }

    @Override
    public boolean doFilter(Person person) {
        for (Leave leave : list) {
            if(leave.doFilter(person)){
                return false;
            }
        }
        return true;
    }
}

命令模式

解释器模式

迭代器模式

中介者模式

备忘录模式

状态模式

空对象模式

策略模式

模板模式

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PolicyType {
    String value();
}

public class ProcessHandler {

    public static ProcessHandler getInstance(){
        return new ProcessHandler();
    }
    public void execute(){
        System.out.println("更新节点的值");
    }
}

public abstract class ProcessTemplate {

    public abstract void preMethod();
    public abstract void postMethod();
    public final void doInvoke(){
        preMethod();
        ProcessHandler.getInstance().execute();
        postMethod();
    }
}

@PolicyType(value = "A")
public class AProcess extends ProcessTemplate {

    @Override
    public void preMethod() {
        System.out.println("A的前置校验方法...");
    }

    @Override
    public void postMethod() {
        System.out.println("A的后置校验方法...");
    }
}

@PolicyType(value = "B")
public class BProcess extends ProcessTemplate {

    @Override
    public void preMethod() {
        System.out.println("B的前置校验方法...");
    }

    @Override
    public void postMethod() {
        System.out.println("B的后置校验方法...");
    }
}

@PolicyType(value = "A")
public class AProcess extends ProcessTemplate {

    @Override
    public void preMethod() {
        System.out.println("A的前置校验方法...");
    }

    @Override
    public void postMethod() {
        System.out.println("A的后置校验方法...");
    }
}

@PolicyType(value = "B")
public class BProcess extends ProcessTemplate {

    @Override
    public void preMethod() {
        System.out.println("B的前置校验方法...");
    }

    @Override
    public void postMethod() {
        System.out.println("B的后置校验方法...");
    }
}

@Component
public class ProcessContext {

    @Resource
    private ApplicationContext applicationContext;

    private final Map<String, ProcessTemplate> processMap = new ConcurrentHashMap<>();

    public void doInvoke(){
        Map<String, ProcessTemplate> beansOfType = applicationContext.getBeansOfType(ProcessTemplate.class);
        for(ProcessTemplate impl : beansOfType.values()){
            PolicyType annotation = AnnotationUtils.getAnnotation(impl.getClass(), PolicyType.class);
            if(annotation == null){
                continue;
            }
            processMap.put(annotation.value(), impl);
        }
    }

    public ProcessTemplate getProcess(String type){
        return processMap.get(type);
    }
}

访问者模式