设计模式

本质是面向对象的实际应用

oop七大原则：

1. 开闭原则：对扩展开放，对修改关闭
2. 里氏替换原则（lsp）：继承必须确保父类所拥有的的性质在子类中任然成立(不要破坏继承关系)
3. 依赖倒置原则：要面向接口编程，不要面向实现编程
4. 单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性。（原子操作，尽量保证一个对象做一件事情）
5. 接口隔离原则：要为各个类建立它们需要的专用接口 （精简单一）
6. 迪米特法则：只与你的直接朋友交谈，不跟陌生人说话。（a<--->b<--->c）a和c不要直接相关 （降低程序之间的耦合度）
7. 合成复用原则：尽量先使用组合或者聚合等关联关系来实现（has a），其次才考虑使用继承关系来实现（is a）

创建型模式：代替new

单例模式：

应用场景：

1. 业务系统全局只需要一个对象实例，比如发号器，redis连接对象等
2. spring IOC容器中的bean默认是单例
3. spring boot 中的controller、service、dao层中通过@Autowired的依赖注入对象默认都是单例的

分类：

• 饿汉：提前创建对象
• 懒汉：懒加载，延迟创建对象，需要的时候再创建

饿汉式：

package com.ggqq.singlemodel;
//饿汉式单例模式
public class Hungry {

    //可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    //构造器私有
    private Hungry(){

    }
    private final static Hungry HUNGRY= new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

DCL懒汉式：

package com.ggqq.singlemodel;

/*懒汉式单例模式*/  //(不安全，可以通过反射破解)
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazyMan lazyMan;

/*    //单线程模式下ok
    public static LazyMan getInstance(){
        if(lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }*/

    //多线程模式下加锁  (双重检测模式的  懒汉式单例 DCL懒汉式)
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan == null){//  // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
            // 当A线程执行完毕后，B再获得执行权，这时候再判断lazyMan == null是否成立
            // 如果不成立，B线程无法 实例化SingletonLazy
                    lazyMan = new LazyMan();//不是原子性操作，会发生指令重排，需要改进 加volatile关键字
                }
            }
        }
        return lazyMan;
    }
    //多线程并发
    public static void main(String[] args){
        for(int i=0;i<20;i++);{
            new Thread(()->{
                lazyMan.getInstance();
            }).start();

        }
    }
}

单例中懒汉和饿汉的本质区别在于以下几点：
①饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变。懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问是线程不安全的。
②从实现方式来讲他们最大的区别就是懒汉式是延时加载,他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建，饿汉式无需关注多线程问题、写法简单明了、能用则用。但是它是加载类时创建实例、所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。

懒汉与饿汉式如何选择？

• 如果对象内存占用不大，且创建不复杂，直接使用饿汉的方式即可
• 其他情况均采用懒汉方式(优选)

静态内部类：

package com.ggqq.singlemodel;

//静态内部类     (不安全，可以通过反射破解)
public class Holder {
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static  final Holder HOLDER = new Holder();

    }
}

单例不安全，因为有反射

枚举：

package com.ggqq.singlemodel;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


//枚举自带单例，而且不会被反射破坏
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }

}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

工厂模式：

⼯⼚模式有 3 种不同的实现⽅式：
① 简单⼯⼚模式（静态工厂）：通过传⼊相关的类型来返回相应的类，这种⽅式⽐较单⼀，可扩展性相对较差。
② ⼯⼚⽅法模式：通过实现类实现相应的⽅法来决定相应的返回结果，这种⽅式的可扩展性⽐较强。
③ 抽象⼯⼚模式：基于上述两种模式的拓展，且⽀持细化产品。

应⽤场景：
解耦：分离职责，把复杂对象的创建和使⽤的过程分开。
复⽤代码 降低维护成本：如果对象创建复杂且多处需⽤到，如果每处都进⾏编写，则很多重复代码，如果业务逻辑发⽣了改变，需⽤四处修改；使⽤⼯⼚模式统⼀创建，则只要修改⼯⼚类即可， 降低成本。
 

简单工厂模式：不满足开闭原则（新增产品需要修改）

例：

car接口：

package com.ggqq.factory.simple;

public interface Car {
    void name();
}

Tesla类：

package com.ggqq.factory.simple;

public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉！");
    }
}

Wuling类：

package com.ggqq.factory.simple;

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

CarFactory:工厂类

package com.ggqq.factory.simple;
//静态工厂模式
//增加一个新的产品，如果不修改代码，做不到
public class CarFactory {
    //方法一
    public static Car getCar(String carName){
        if(carName.equals("五菱宏光")){
            return new WuLing();
        }else if(carName.equals("特斯拉")){
            return new Tesla();
        }else{
            return null;
        }
    }
    //方法二
    public static Car getWuling(){
        return new WuLing();
    }
    public static Car getTesla(){
        return new Tesla();
    }
}

Consumer类

package com.ggqq.factory.simple;

public class Consumer {
    public static void main(String[] args) {
        //1.使用接口和实现类
/*        Car car1 = new WuLing();
        Car car2 = new Tesla();
        car1.name();
        car2.name();*/
        //2.使用工厂
        Car car1 = CarFactory.getCar("五菱宏光");
        Car car2 = CarFactory.getCar("特斯拉");
        car1.name();
        car2.name();

    }
}

工厂方法模式：

• ⼜称⼯⼚模式，是对简单⼯⼚模式的进⼀步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满⾜开闭原则。
• 相⽐简单⼯⼚⽽⾔，此种⽅法具有更多的可扩展性和复⽤性，同时也增强了代码的可读性。

CarFactory接口：

package com.ggqq.factory.method;

//工厂方法模式
//
public interface CarFactory {
    Car getCar();
}

TeslaFactory类

package com.ggqq.factory.method;

public class TeslaFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Tesla();
    }
}

Consumer类

package com.ggqq.factory.method;

public class Consumer {
    public static void main(String[] args) {
        Car car1 = new WuLingFactory().getCar();
        Car car2 = new TeslaFactory().getCar();
        Car car3 = new DaZhongFactory().getCar();

        car1.name();
        car2.name();
        car3.name();

    }
}

工厂方法模式优点：

• 符合开闭原则，增加⼀个产品类，只需要实现其他具体的产品类和具体的⼯⼚类；
• 符合单⼀职责原则，每个⼯⼚只负责⽣产对应的产品；

工厂方法模式缺点：

• 增加⼀个产品，需要实现对应的具体⼯⼚类和具体产品类；
• 每个产品需要有对应的具体⼯⼚和具体产品类；

 

根据设计原则：工厂方法模式！

根据实际业务：简单工厂模式！实际使用最多！

抽象工厂模式(在spring中应用最广泛)

围绕一个超级工厂创建其他工厂，即工厂的工厂

背景：

• ⼯⼚⽅法模式引⼊⼯⼚等级结构，解决了简单⼯⼚模式中⼯⼚类职责过重的问题。
• 但⼯⼚⽅法模式中每个⼯⼚只创建⼀类具体类的对象， 后续发展可能会导致⼯⼚类过多，因此将⼀些相关的具体类组成⼀个“具体类族”，由同⼀个⼯⼚来统⼀⽣产， 强调的是⼀系列相关的产品对象！！！

例：

建造者模式：组装

原型模式

实现深拷贝：将这个对象的属性也进行克隆

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //实现深拷贝
        Object obj = super.clone();
        Video v = (Video)obj;
        //将这个对象的属性也进行克隆
        v.createTime = (Date) this.createTime.clone();

        return obj;
    }

结构性模式：实现松耦合

适配器模式：

例：

桥接模式：

例1：

例2：

代理模式

SpringAOP的底层是代理模式！！！

分类：

1. 静态代理
2. 动态代理

静态代理：

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决  （租房）
• 真实角色：被代理的角色  （房东）
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作（中介）
• 客户：访问代理对象的人（租房子的人）

代码步骤：

• 接口

package com.ggqq.proxy.staticproxy.demo01;

//租房
public interface Rent {
    public void rent();
}

• 真实角色

package com.ggqq.proxy.staticproxy.demo01;
//房东
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

• 代理角色

package com.ggqq.proxy.staticproxy.demo01;

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
    //收中介费
    public void hetong(){
        System.out.println("签租赁合同");
    }
}

• 客户端访问代理角色

package com.ggqq.proxy.staticproxy.demo01;

public class Client {
   /* //方法一：客户直接找房东租房子
    public static void main(String[] args) {
        Host host = new Host();
        host.rent();
    }*/
   //方法二：通过代理（中介），代理一般会有一些附属操作
   public static void main(String[] args) {
       Host host = new Host();
       Proxy proxy = new Proxy(host);

       proxy.rent();
   }
}

静态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共也就交给代理角色！实现了业务的分工
• 公共业务发生扩展时，方便集中管理

缺点：

• 一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低

动态代理：

• 动态代理和静态代理的角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

1. 基于接口：JDK动态代理
2. 基于类：cglib
3. java字节码实现：javasist

需要了解两个类：Proxy 代理           InvocationHandler    调用处理程序

动态代理的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共也就交给代理角色！实现了业务的分工
• 公共业务发生扩展时，方便集中管理
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可。