常用的设计模式

一、单例模式

一个类只有唯一一个实例，由自己创建并且提供给整个系统。例如缓存、线程池、打印机、显卡驱动程序都是设计成单例模式，避免一个端口同时被两个请求调用，出现状态的不一致性

1. 饿汉式（立即加载）

2. 懒汉式（延迟加载）容易出现线程安全的问题

3. 同步锁，在方法上加上synchronized关键字 效率低，一个线程要获取对象就要等待上个线程先释放锁

4. 双重检查锁，解决了效率问题

5. 静态内部类，将对象的创建放到静态内部类中，只用被调用的时候才会创建对象，既解决了线程安全问题，也解决了效率问题。但是反序列化时，默认的运行方式还是会创建多个实例

6. 内部枚举类，可以避免反射和反序列化的攻击

二、工厂模式

java中万物皆对象，如果所有的对象都需要我们去new，那么与对象的耦合就很严重。如果需要修改对象，那么就要到每个创建对象的地方去修改，违反了开闭原则（开放扩展，避免修改）。所以使用工厂模式就可以解决，需要修改对象，就直接到工厂里面去修改。工厂模式主要作用就是 解耦

1. 简单工厂：根据传入的参数，创建相应的产品对象。适合数量比较少，产品需求相对固定的对象。弊端是，如果需要添加或者修改，那么就要去到工厂类里面修改。也违反了开闭原则

2. 工厂方法：将工厂类抽象成一个接口或者抽象类，具体生产什么产品由子类去决定。如果产品类型比较多，那么就要创建很多的工厂。弊端显而易见

3. 抽象工厂：为创建一组或者相互依赖的产品提供一个接口，而不指定具体的一个类。

抽象工厂和工厂方法区别在于，工厂方法是创建一个具体的产品，而工厂方法可以用来生产一组或是有相对关系的产品，重点是一组、一批、一系列

简单工厂和工厂方法使用比较类似，如果是产品数量一定，需求固定，类型比较少就使用简单工厂

抽象工厂适合解决复杂的问题，适合批量的生产

三、代理模式

代理模式就是给对象创建一个代理对象，通过代理对象控制对原对象的引用

代理模式的作用：

1. 起到中介的作用，如果客户类不想或者不能直接引用委托类，那么代理类就可以在客户类和委托类中间起到一个中介的作用。特点就是代理类要和委托类实现相同的接口

2. 遵循开闭原则，扩展功能：代理类除了可以作为中介，如果需要添加功能，我们可以直接修改代理类，而不需要修改委托类。符合开闭原则。代理类主要负责接收消息，处理消息，将消息传递给委托类以及对委托类返回结果的处理。我们也可以在业务功能的前后加上一些公众的服务，例如日志缓存功能。

按照代理创建的时期可以分为：静态代理和动态代理

静态代理：就是程序员创建或者通过特定的工具生成源代码，再对其进行编译，在程序员行之前就已经创建了代理类的.class文件

静态代理可以在符合开闭原则的前提下对目标对象进行扩展，但是为每一个服务都创建代理对象，工作量巨大，并且一旦修改了接口，那么代理类也要做相应的修改。

动态代理：就是通过java的反射机制，在程序运行时创建的

jdk动态代理类（Dynamic Proxy）:我们只需要创建一个动态处理器，实现InvocationHandler就可以，真正的代理对象在程序运行时jdk为我们创建

1.public class DynamicProxyHandler implements InvocationHandler {  
2.  
3.    private Object object;  
5.public DynamicProxyHandler(final Object object) {  
6.        this.object = object;  
7.    }  
8.  
9.    @Override  
10.    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
11.        System.out.println("买房前准备");  
12.        Object result = method.invoke(object, args);  
13.        System.out.println("买房后装修");  
14.        return result;  
15.    }  
16.}  

Proxy是所有动态生成的代理的共同的父类，这个类有一个静态方法Proxy.newProxyInstance()，接收三个参数：

• ClassLoader loader：指定当前目标对象使用的类加载器,获取加载器的方法是固定的

• Class<?>[] interfaces：指定目标对象实现的接口的类型,使用泛型方式确认类型

• InvocationHandler：指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法

jdk动态代理类相对于静态代理大大提高了开发效率，也减少了对服务类接口的依赖，减少了耦合

但是，Proxy是所有代理类的公众父类，要求服务类必须是接口类型，因为java无法实现多继承

CGLib动态代理：对于不是接口类型的服务类我们可以使用CGLib动态代理，原理是底层通过字节码技术为一个类创建子类。服务类不能被final修饰因为采用的是继承。方法也不能被static和final修饰。JDK动态代理和CGLib动态代理均是实现SpringAOP的基础。

1.public class CglibProxy implements MethodInterceptor {  
2.  
3.    private Object target;  
4.  
5.    public CglibProxy(Object target) {  
6.        this.target = target;  
7.    }  
8.  
9.    /** 
10.     *  给目标对象创建一个代理对象 
11.     * @return 代理对象 
12.     */  
13.    public Object getProxyInstance() {  
14.        //1.工具类  
15.        Enhancer enhancer = new Enhancer();  
16.        //2.设置父类  
17.        enhancer.setSuperclass(target.getClass());  
18.        //3.设置回调函数  
19.        enhancer.setCallback(this);  
20.        //4.创建子类(代理对象)  
21.        return enhancer.create();  
22.  
23.    }  
24.  
25.    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
26.        System.out.println("买房前准备");  
27.        //执行目标对象的方法  
28.        Object result = method.invoke(target, args);  
29.        System.out.println("买房后装修");  
30.        return result;  
31.    }  
32.}  

CGLib创建动态代理的性能更高，但花费时间也越长。因此对于单例模式，无需频繁的创建对象使用CGLib创建更为合适，反之使用JDK动态代理创建。CGLib是采用继承的方式，所有被代理的类不能被final修饰

动态代理的原理：

通过一个代理将对象包裹起来，任何对原始对象的调用都要经过代理对象，代理对象可以决定何时将调用方法转移到原始对象上

动态代理的方式：

基于接口实现的代理：JDK动态代理

基于继承实现的代理：CGLib动态代理