Java 设计模式(剖析spring源码 jdk源码 等)

Java 设计模式

高内聚，低耦合，可维护，可读性

设计模式七大设计原则

单一职责原则

Single Responsibility

一个类应该只负责一项单一的职责

• 降低类的复杂度，一个类负责一个单一职责
• 提高类的可可读性和可维护性
• 降低变更带来的风险

接口隔离原则

Interface Segregation Priciple

一个类对另一个类的依赖应该建立在最小的接口上。客户端不应该依赖它不需要的接口。

如果一个接口的一部分被A依赖，另一部分被B依赖，这个时候应该把接口拆分成两个字接口，实现接口隔离原则，减少冗余代码。

依赖倒转原则

Dependence Inversion Priciple

• 高层模块不应该依赖低层模块，二者都应该依赖其抽象
• 抽象不应该依赖细节，细节应该依赖抽象
• 依赖倒转的中心思想是面向接口编程
• 相对于细节的多变性，抽象的东西要稳定，细节就是具体实现

依赖关系传递的三种方式：

• 接口传递
• 构造方法传递
• setter方法传递

依赖倒转原则的注意事项和细节：

• 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好
• 变量的声明类型尽量都是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化 （父类方便拓展子类）
• 继承时遵循里氏替换原则

里氏替换原则

如果对每个类型为T1对对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2室类型T1点字类型。换句话说：所有引用基类的地方必须能透明地使用其子类的对象。

使用继承的时候，子类尽量不要重写父类的方法。

里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

• 聚合：整体和部分的关系，可以分开。成员类可以脱离整体对象存在。汽车这个类包含引擎类

• 组合：整体和部分的关系，不可以分开。一旦整体不存在，成员类也不可以存在。例如某公司的某个部门，公司倒闭了，部门也不存在了。

• 依赖：A类的对象作为B类的一个成员变量

开闭原则 ocp

Open Close Principle：是编程中最基础，最重要的设计原则。

• 一个软件实体，例如类，模块，函数都应该对扩展（提供方）开放，对修改（使用方）关闭。用抽象构建框架，用实现扩展细节。
• 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有代码。
• 设计模式的目的就是遵循开闭原则。

迪米特法则

Demeter Principle：最小知道原则，一个类对自己依赖的类知道的越少越好。除了对外暴露public方法，不对外泄露任何信息。只和直接朋友进行通讯。

合成复用原则

尽量使用聚合，合成， 而不是使用继承

UML基本介绍

• Dependency: 依赖（使用）。只要一个类在类中用到了对方，方法返回值，方法参数，函数中的局部变量。

• Association: 关联（一对多; 一对一; 双向一对一）。一个人和一个身份证是一一对应的。如果人这个类中有身份证类，身份证类中也有人这个类，那么他们关系是双向的。

• Generalization: 泛化（继承）

• Realization: 实现

• Aggregation: 聚合 （通过set方法传入别的类，称为聚合）。如果A类中可以有多个B类，就是多聚合，否则就是单聚合（一台电脑可以有多个内存）。聚合类可以分开，例如鼠标可以离开电脑存在。

• Composite: 组合（当B类被实例化的时候，A类也被实例化的时候，称为组合）。如果类创建的时候自动创建了别的类，则是组合关系。例如：

  public class A {
       
    private B b = new B();
  }
  
  public class B {
       
  }
  

  这种情况下，A创建的时候，B直接被创建，所以是共生死的，所以是组合关系。如果删除的时候进行极联删除，那么就是组合关系。

设计模式概略

• 创建型模式：单例模式，抽象工厂模式，原型模式，创建者模式，工厂模式
• 结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式
• 行为型模式：模板方法模式，命令模式，访问者模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式（Interpreter模式），状态模式，策略模式，职责链模式（责任链模式）

单例模式

保证整个软件中，某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法（静态方法），比如 ConnectionFactory，SessionFactory。

饿汉式（静态常量）

class type1 {
   
    //饿函式 静态成员变量
    private static type1 instance = new type1();

    private type1() {
   };

    public static type1 getInstance() {
   
        return instance;
    }
}

饿汉式（静态代码块）

class type2 {
   
    //饿汉式 静态代码块
    private static type2 instance;

    static {
   
        instance = new type2();
    }

    private type2() {
   };

    public static type2 getInstance() {
   
        return instance;
    }
}

懒汉式（线程不安全）

class type3 {
   
    //懒汉式
    private static type3 instance;
    
    private type3() {
   };
    
    public static type3 getInstance() {
   
        if (instance == null)
            instance = new type3();
        return instance;
    }
}

懒汉式（线程不安全，同步方法）

class type4 {
   
    //懒汉式
    private static type4 instance;

    private type4() {
   };

    public static type4 getInstance() {
   
        if (instance == null)
            synchronized (type4.class) {
   
                instance = new type4();
            }
        return instance;
    }
}

多个线程进入if语句后，好几个线程都会创建instance，线程不安全，不能使用！

懒汉式（线程安全，同步代码块，双重检查）

class type5 {
   
    //懒汉式 线程安全 double check
    private static volatile type5 instance;
    
    private type5() {
   }
    
    public static type5 getInstance() {
   
        if (instance == null) 
            synchronized (type5.class) {
   
                if (instance == null)
                    instance = new type5();
            }
        return instance;
    }
}

静态内部类（线程安全）

写一个静态内部类，该类中有一个静态属性 Singleton

属于懒汉式，外部类的加载不会导致静态内部类的加载

class type6 {
   
    //静态内部类
    private type6() {
   }
    
    private static class SingletonInstance {
   
        private static final type6 INSTANCE = new type6();
    }
    
    public static type6 getInstance() {
   
        return SingletonInstance.INSTANCE;
    }
}

枚举

可以防止反序列化重新创建新的对象

class type7 {
   
    //枚举
    public static void main(String[] args) {
   
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
    }
}

enum Singleton {
   
    INSTANCE;
    public void sayOK() {
   
        System.out.println("ok ");
    }
}

单例模式总结

工具类，数据源，重量级对象等都可以使用单例模式

工厂模式

简单工厂模式

属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式也叫做静态工厂模式

public static Object createObject() {
   }

工厂方法模式

定一个抽象类class来表示factory，具体的实例化对象操作下放到子类（继承这个抽象类的类）实现。

抽象工厂模式

把抽象的类换成interface，最顶层是抽象接口，多个子类工厂族来实现不同的对象实例化。

interface AbstractFactory {
    createObject() }
class SubFactory1 implements subFactory1 {
    createObject() }
class SubFactory2 implements subFactory2 {
    createObject() }

/**
*	使用的时候只需要传入一个具体的实现子类，然后通过其来实例化对象，而使用层面只需要用interface来表明需要使用的类，可以减少代码修改量
**/
public static void main(String[] args) {
   
  //如果想用子工厂1来创建对象
  createBean(new SubFactory1);
  
  //如果想用子工厂2来创建对象
  createBean(new SubFactory2);
}
// 这样写的好处是，createBean的函数主体不需要更具工厂族的变化而变化
public static Object createBean(AbstractFactory a)