设计模式

第一章、简单工厂模式

简单工厂模式就是新建一个工厂类，用来创建需要的实体对象，所有被该工厂产生的实体对象都必须继承于同一个接口，这样做的好处是当新增一个类似功能时不需要对以前已经存在的稳定功能类做修改。如图1.1，计算器UML类图
类图常见示例如图1.2，类图示例

第二章、策略模式

策略模式，是使用一个策略处理类来处理所有继承了策略抽象类的策略算法，策略处理类可以直接调用一系列策略中的方法，对外界而言，你只要给策略处理类策略算法的类别，和相关的参数，你就能得到结果，这样做的好处就是对外隐藏更多策略算法相关的东西，只暴露策略处理类，同时使用继承抽象类可以将一些算法通用的东西复用，另外这样单个算法可以更加方便的测试，同时不同算法间没有直接关系。如图2.1，策略UML类图。

第三章、装饰模式
装饰模式和责任链模式有些相似，具体比较等学习了责任链再详细处理，装饰模式需要一个抽象的装饰类，一个具体的实现类，还有一个可以设置装饰类实体的实现类，其他具体的装饰类都是继承自改具有set的装饰类。如图3.1，装饰UML类图。

2.在写一个项目时候要考虑依赖倒转原则（使用抽象类，子类可以替换父类）、开放封闭原则（将变化开放）、单一原则（就一个类而言就一个引起变化的原因）。

第四章、代理模式
代理模式是A类和B类同时继承于同一个抽象类，B类中保存一个引用，使得可以往B类中放A的实体，且B中通常有A的所有方法，当需要使用A时，可以直接使用B来代替，且我们可以在B中添加前后处理代码，比如常用的执行时间代码。如图4.1，代理UML类图。

第五章、工厂方法模式
工厂方法模式相对简单工厂模式，同样是继承一个抽象类，但是每一个需要创建的类都有自己单独的工厂类，我们同样还有工厂方法类，只是这里不在具体的去创建实体了，改由工厂生成，我们在工厂方法类中只需要调用就行，这个相对简单工厂模式，对开放闭合做了更生的实现。如图5.1，工厂方法UML类图。

第六章、模板方法模式
我们经常使用数据库操作方式，大多使用了模板方法模式，这样的好处是避免了重复的劳动，模板方法模式通常是把重复的动作搬到父类中去，子类只重写变化的部分。如图6.1，模板方法UML类图。

第七章、外观模式
外观模式是为了封装一系列复杂操作，提供一个简单的对外接口，我们只需要关心对外接口的调用，其内部复杂的操作我们并不关心，都在外观接口中进行操作。如图7.1 外观模式UML类图。

第八章、建造者模式

当我们进行某一个流程比较复杂的程序时，经常害怕自己会忘记其中某些步骤，这个时候我们可以使用建造者模式，通过定义一个建筑抽象类来规定整个流程，其他流程都继承该抽象类，这样就再也不会存在流程过程缺失了。如图8.1，建造者模式UML类图。

第九章、观察者模式

观察者模式是一种联动效果，当一个事情发生时，观察者捕捉到，然后会通知其下注册的所有被观察对象，执行相应操作，好一点的观察者模式可以将观察者做出抽象类，具体的观察者可以实现抽象类，不至于所有鸡蛋放到一个篮子里。如图9.1，观察者UML类图。

第十章、抽象工厂模式

抽象工厂的出现是为了方便管理同一品牌有不同产品，我们为每个平台创建一个抽象工厂，这样一个工厂就可以管理一批产品。如图10.1，抽象工厂UML类图。

第十一章、状态模式
状态模式有点类似责任链模式，只不过每种状态只会有一个正确的类做出响应，这么做的好处就是当状态特别多时，且每个状态的处理都比较复杂，且状态可能发生变化，这个时候状态模式就是比较合适的。如图11.1，状态模式UML类图。

第十二章、适配器模式
适配器模式就像手机充电适配器一样，一般情况下是不可以使用该模式的，只有当新旧接口存在一定的不适应情况下才会使用，该模式就是使用代码进行硬解码，将原本不一样的字段通过做对应关系变成可以适配的代码。如图12.1，适配器模式UML类图。

第十三章、备忘录模式
当一局游戏打到关键关卡时我们一般会选择保存一个备份，备忘录模式类似，我们希望能够只有当前对象能管理备忘录，且很少受别人影响，将备忘录封装起来。如图13.1，备忘录模式。

第十四章、组合模式
组合模式，像树形结构的数据最合适使用组合模式。如图14.1，组合模式。

第十五章、迭代器模式
迭代器可能是我们使用比较多的一种模式，像foreach，java直接作为一种语法了。如图15.1，迭代器模式。
第十六章、桥接模式
1.桥接模式主要是针对多个可变操作对主体流程产生影响，例如计薪系统中，会有加班和正常工作产生薪水，但是加班可能会公司政策有所调整，薪水也是随着公司政策有所调整，我们不想计薪系统随着节气改变就把主程序改动。桥接模式就可以应对这种情况
ActionAbstract 文件

abstract class ActionAbstract {
    abstract void operate();
}

NormalPayroll文件

class NormalPayroll extends ActionAbstract{
    void operate() {
        System.out.println("正常计薪");
    }
}

OvertimeContinues文件

class OvertimeContinues extends ActionAbstract{
    void operate() {
        System.out.println("加班得薪");
    }
}

PayrollSystem文件

class PayrollSystem {
    private ActionAbstract actionAbstract;

    void setActionAbstract(ActionAbstract actionAbstract) {
        this.actionAbstract = actionAbstract;
    }
    void operate() {
        actionAbstract.operate();
    }
}

PayrollMain文件

public class PayrollMain {

    public static void main(String[] args) {
        PayrollSystem payrollSystem = new PayrollSystem();
        payrollSystem.setActionAbstract(new NormalPayroll());
        payrollSystem.operate();
        payrollSystem.setActionAbstract(new OvertimeContinues());
        payrollSystem.operate();
    }
}

第十七章、命令模式
1.命令模式由命令、执行者、司令组成，什么时候使用命令模式呢？？当一个功能需要结果，不关心下面怎么操作，而且还要有超时之类的情况下可以撤回部分命令的功能时，可以使用命令模式。开发中可能我们不知不觉中就使用了命令模式，比如一个功能比较复杂时，我们分好几个类，每个类各干各的事，然后再把这几个类合并起来完成特定功能，这个就可以算是命令模式。
AbstractCommand文件

public abstract class AbstractCommand {
    abstract void operate();
}

AbstractReceiver文件

public abstract class AbstractReceiver {
    abstract void action();
}

MyCommand文件

public class MyCommand extends AbstractCommand{
    private AbstractReceiver receiver;

    public MyCommand(AbstractReceiver receiver) {
        this.receiver = receiver;
    }

    void operate() {
        receiver.action();
    }
}

Receiver文件

public class Receiver extends AbstractReceiver {
    void action(){
        System.out.println("处理命令");
    }
}

Invoker文件

public class Invoker {
    private AbstractCommand command;

    public Invoker(AbstractCommand command) {
        this.command = command;
    }

    public void action(){
        command.operate();
    }
}

CommandMain文件

public class CommandMain {
    public static void main(String[] args) {
        AbstractReceiver receiver = new Receiver();
        AbstractCommand command = new MyCommand(receiver);
        Invoker invoker = new Invoker(command);
        invoker.action();
    }
}

第十八章、责任链模式
1.责任链的最直接例子就是拦截器，当我们有一系列条件需要判断时，责任链就是最好的模式
AbstractChainOfResponsibility文件

public abstract class AbstractChainOfResponsibility {
    abstract void doPost();
}

ParameterInterception文件

public class ParameterInterception extends AbstractChainOfResponsibility{
    private PermissionInterception permissionInterception = new PermissionInterception();
    void doPost() {
        System.out.println("参数拦截");
        permissionInterception.doPost();
    }
}

PermissionInterception文件

public class PermissionInterception extends AbstractChainOfResponsibility{
    void doPost() {
        System.out.println("权限拦截");
    }
}

ChainOfResponsibilityMain文件

public class ChainOfResponsibilityMain {

    public static void main(String[] args) {
        AbstractChainOfResponsibility abstractChainOfResponsibility = new ParameterInterception();
        abstractChainOfResponsibility.doPost();
    }
}

第十九章、中介模式
1.中介模式是最好理解的一种模式，生活中找房子，我们首先会想到中介，这个模式和这个类似，买卖双方不需要自己见面，使用中介进行中间调和，这样就降低了买卖双方的耦合度，所以的变化到中介这就结束了。这个模式理解下就好。
第二十章、享元模式
1.享元模式和单例模式有点相似，作用都是减少类的创建，享元模式将大类分成小类，将具有共有特征的给抽象出来，只创建一次对象放到一个map中，下次使用直接获取，太简单，不再介绍。
第二十一章、解释模式
1.解释模式和适配器模式有点相似，解释模式更像是翻译，我们告诉机器给我们做什么，机器听不懂，需要使用用解释模式将文本翻译成机器可以听懂的二进制，缺点是每新增一种语义都得新增翻译解释，推荐使用语法树分析。
第二十二章、访问者模式
1.这个是所以模式中最让人搞不懂的模式，但是可以用在ui、过滤器等场所。首先是元素接口，需要定义accept方法，所有需要被外访问的对象需要实现这个接口，其次需要有观察者接口，这个接口主要定义可以操作被访问对象的方法，所有操作被访问对象的类都需要实现该接口，另外还有一个真正的操作对象，使用观察者操作元素。

abstract class Element
{
    public abstract void accept(IVisitor visitor);
    public abstract void doSomething();
}
class ConcreteElement1 extends Element{
    public void doSomething(){
        System.out.println("这是元素1");
    }
    public void accept(IVisitor visitor){
        visitor.visit(this);
    }
}
class ConcreteElement2 extends Element{
    public void doSomething(){
        System.out.println("这是元素2");
    }
    public void accept(IVisitor visitor){
        visitor.visit(this);
    }
}
class ConcreteElement3 extends Element{
    public void doSomething(){
        System.out.println("这是元素3");
    }
    public void accept(IVisitor visitor){
        visitor.visit(this);
    }
}
interface IVisitor{
    public void visit(ConcreteElement1 el1);
    public void visit(ConcreteElement2 el2);
    public void visit(ConcreteElement3 el3);
}
class Visitor implements IVisitor{
    public void visit(ConcreteElement1 el1){
        el1.doSomething();
    }
    public void visit(ConcreteElement2 el2){
        el2.doSomething();
    }
    public void visit(ConcreteElement3 el3){
        el3.doSomething();
    }
}
class ObjectStructure{
    private static List<Element> elements = new ArrayList<>();
    static List<Element> getElements(){
        elements.add(new ConcreteElement1());
        elements.add(new ConcreteElement2());
        elements.add(new ConcreteElement3());
        return elements;
    }
}
public class Client{
    public static void main (String[]args){
        Element e = new ConcreteElement3();
        e.accept(new Visitor());
        ObjectStructure.getElements().forEach(a->a.accept(new Visitor()));
    }
}

maven打包時將別的jar包中的配置文件導入當前jar

使用xtrabackup熱備份mysql innodb數據

Gradle簡單使用

批處理命令日常工作積累

springmvc耗時處理的結果返回優化Callable

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結