public class LazySingleton {
    private static volatile LazySingleton instance = null;    //保证 instance 在所有线程中同步
    private LazySingleton() {
    }    //private 避免类在外部被实例化
    public static synchronized LazySingleton getInstance() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

2.1.3饿汉式

特点：类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
}

2.2工厂模式

核心实质：

2.2.1代码演示一（普通版）

?特点：用来生产同一等级结构的任意产品（对于?? ?增加新的产品，需要球盖已有代码）

2.2.2代码演示二（升级版）

特点：用来生产同一等级结构中的固定产品(支持增加任意产品)

2.2.3代码演示三（终极版）——抽象工厂模式

特点：围绕一个超级工厂创建其他工厂

满足条件：

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。

抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

结构分析：

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

图解分析：

抽象工厂模式的结构图

2.3代理模式

定义：代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

图解分析：

代理模式的结构图

优点：

代理模式会造成系统设计中类的数量增加
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；

缺点：

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

2.3.1静态代理

角色分析：

?代码演示：

//1.接口
//租房
public interface Rent {
    public void rent();
}

//2.真实角色
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

//3.代理角色
public class Proxy implements Rent {
    private Host host;
    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }
    @Override
    public void rent() {
        seeHouse();
        host.rent();
        contract();
        fare();
    }
    //看房
    public void seeHouse() {
        System.out.println("中介带你看房");
    }
    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }
    //签合同
    public void contract() {
        System.out.println("签租赁合同");
    }
}

//4.客户端访问代理角色
public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //一般模式
        // host.rent();

        //代理，中介帮房东租房子，但是呢？代理一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可！
        proxy.rent();

    }
}

2.3.2动态代理

好处：

?代码演示：

//自动生成代理类；
public class ProxylnvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }
    //生成得到的代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
    //处理代理实例，并返回结果,
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质，就是使用反射机制实现！
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg) {
        System.out.println("执行了" + msg + "方法");
    }

public class Client {
    public static void main(String[] args) {
            //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxylnvocationHandler pih = new ProxylnvocationHandler();

        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.delete();

    }
}

2.4观察者模式

定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

角色定义图：

?代码演示：

?

?

?

2.5职责链模式

定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

优点：

降低了对象之间的耦合度
增强了系统的可扩展性。
增强了给对象指派职责的灵活性
责任链简化了对象之间的连接责任分担。

缺点：

不能保证每个请求一定被处理
对比较长的职责链，
请求的处理可能涉及多个处理对象，系统性能将受到一定影响
职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性

结构图解：

?演示代码:

public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        //组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);
        //提交请求
        handler1.handleRequest("two");
    }
}
//抽象处理者角色
abstract class Handler {
    private Handler next;
    public void setNext(Handler next) {
        this.next = next;
    }
    public Handler getNext() {
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("one")) {
            System.out.println("具体处理者1负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}
//具体处理者角色2
class ConcreteHandler2 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("two")) {
            System.out.println("具体处理者2负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}
/*
程序运行结果如下：
具体处理者2负责处理该请求！
*/

/*    
在上面代码中，我们把消息硬编码为 String 类型，而在真实业务中，消息是具备多样性的，可以是 int、String 或者自定义类型。因此，在上面代码的基础上，可以对消息类型进行抽象 Request，增强了消息的兼容性。*/

三、小结

????????设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。