设计模式

单例（SingleTon）：类的对象在内存中有且只有一个，类只有一个实例。懒汉式，饿汉式

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * （话说你不用的，你装载它干啥）
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

策略（Strategy）：多态，不同的策略实现，分配策略，比较策略。Comparable,Comparator 比较器

工厂（factory）：简单工厂，静态工厂，工厂方法，抽象工厂（产品一族）。任何可以产生对象的方法和类都可以称之为工厂，单例也是一种工厂

调停者模式（Madiator）：门面：访问门面Facade，由门面来协调内部的关系（MVC），对外（门面）对内（调停者rabbitmq）

观察者模式（Observer）：事件源对象source 被观察者，观察者Observer（多个），Event事件本身。没有观察者面向对象傻等。事件产生了，进入事件队列。观察者观察事件队列是否有事件（队列是否有元素），如果有则处理事件。不同的事件不同的处理方案( Observer,Listener,Callback)

组合模式(Composite)：一个类还包含其他的类，形成组合

享元模式（Flyway）: 重复利用对象，Druid连接池，线程池

builder：链式编程，返回this,本身

Iterator模式：迭代器模式，每个容器都实现Iterator接口，重写hasNext,next 来迭代容器元素

Adapter（wrapper）：适配器：IO（InputstreamReader）电压转接器，jdbc-odbc-bridge,（常见的Adapter反而不是Adapter）

代理模式（Proxy）：静态代理和动态代理

​ 静态代理：一个类实现了一个接口，对方法重写，这个类是代理类。其它方法去调用这个代理类的方法

​ 动态代理：jdk(看是否实现接口): Proxy.newInstanceProxy(). 实现InvocationHandler接口，重写invoke方法

​

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Random;

public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        Movable m = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new TimeProxy(tank)
        );

        m.move();

    }
}

class TimeProxy implements InvocationHandler {
    Movable m;

    public TimeProxy(Movable m) {
        this.m = m;
    }

    public void before() {
        System.out.println("method start..");
    }

    public void after() {
        System.out.println("method stop..");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object o = method.invoke(m, args);
        after();
        return o;
    }

}

interface Movable {
    void move();
}

​ cglib:

Visitor模式：在结构不变的情况下动态改变元素的动作（打折销售）

责任链模式：servlet的filter spring的intercepter

装饰器模式（Decorator）:InputStream Reader OutputStream Writer.一个类不断添加东西->改进