设计模式之-单例，工厂，模板，建造者，代理

【示例代码地址 https://github.com/yuankai2calm/design-pattern】

1. 单例模式

定义: 确保某个类只有一个实例，并且自行实例化，并向整个系统提供这个实例。

• 单例模式优点:

1. 单例模式能减少频繁创建和销毁实例对象带来的性能开销。
2. 单例模式允许系统通过全局访问点，优化对共享资源的访问和占用。

• 使用场景:

1. 要求生成唯一序列号的环境
2. 整个项目需要一个共享访问点和共享数据。
   3.创建一个对象需要消耗的数据量多，如IO和数据库操作
   4.需要定义大量的静态常量和和静态方法(如：工具类)
   在以上环境中可以使用单例模式

• 线程安全的单例模式示例:

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

2. 工厂模式

定义: 工厂模式是开发中常用的一种模式。定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

• 工厂模式优点:

1. 工厂模式有良好的封装性，代码结构清晰。
2. 降低模块间的耦合，方便扩展。

• 工厂模式类结构图:

  
  
  工厂模式-来源设计模式之禅

• 工厂模式可以进行简化，为简单工厂模式，也称为静态工厂模式。

  
  
  简单工厂-来源设计模式之禅

• 工厂模式还可以扩展为多个工厂类

  
  
  多工厂类-来源设计模式之禅

示例代码将在文章末尾给出仓库地址

3. 模板方法设计模式

定义: 定义个操作中国年的算法的框架，而将一些步骤延迟到子类中。可以使得子类不改变一个算法的机构即可重定义该算法的某些特定步骤。

• 模板方法优点:

1. 封装不变部分，扩展可变部分

2. 提取公共部分代码，便于维护

3. 行为由父类控制，子类实现

• 模板方法使用的场景:

1. 多个子类有公有的方法，并且逻辑基本相同时。可以将相同的公共有方法，提取到父类中，确定为模板方法。
2. 重要、复杂的算法，可以把核心算法设计为模板方法。周边的细节方法，则可以由子类实现
3. 重构时，模板方法模式是一个经常使用的模式，把相同而代码抽取到父类中，然后通过钩子函数约束其行为。

• 模板方法的简单示例:
  抽象父类：

public abstract class AbstractClass {
    /**
     * 基本方法
     */
    protected abstract void doAnything();

    /**
     * 基本方法
     */
    protected abstract void doSomething();

    /**
     * 模板方法，调用基本方法，完成相关逻辑
     */
    public void templateMethod() {
        doAnything();
        doSomething();
    }
}

实现子类：

public class ConcreteFirst extends AbstractClass {
    @Override
    protected void doAnything() {
        System.out.println("ConcreteFirst doAnything......");
    }

    @Override
    protected void doSomething() {
        System.out.println("ConcreteFirst doSomething......");
    }
} 

public class ConcreteSecond extends AbstractClass {
    @Override
    protected void doAnything() {
        System.out.println("ConcreteSecond doAnything......");
    }

    @Override
    protected void doSomething() {
        System.out.println("ConcreteSecond doSomething......");
    }
}

4. 建造者模式

定义: 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

• 建造者模式类图:

  
  
  建造者模式通用类图

• 建造者模式优点：

1. 使用建造者模式可以使客户端不必知道产品内部组成的细节，不需要关心每一个具体的模型内部是如何实现的。
2. 建造者独立，容易扩展
3. 便于控制细节风险

• 建造者模式的应用场景

1. 产品类非常复杂， 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时

具体示例代码参看代码仓库

5. 代理模式

定义: 代理模式是为其他对象提供一种代理以控制对这个对象的访问。代理模式也称为委托模式。

• 代理模式的优点

1. 职责清晰
   真实的角色就是实现实际的业务逻辑，不用关心其他非本职的事物，通过后期的代理完成一件事务，附带的结构就是编程简洁清晰。
2. 高扩展性
   只要主题类实现来接口， 无论主题类如何变化，代理类都能正常使用。

代理类不仅仅可以实现主题接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上做增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤。

• 动态代理和静态代理区别:

都是实现一个代理类，动态代理的是横切面编程，在不改变我们已有代码结构的情况下增强或控制对象的行为。

• 基于Java的动态代理实现的首要条件是:被代理对象必须要实现一个接口。
  CGLIB不需要接口也可以实现动态代理。

• 动态代理示例:
  主题接口

/**
 * 动态代理抽象主题
 */
public interface Subject {

    void doSomething();
}

逻辑代理增强

/**
 * 动态代理增强类
 * 在这里进行增强逻辑
 */
public class MyInvocationHandler implements InvocationHandler {
    private Subject subject = null;
    public MyInvokeHandler(Subject subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //执行被代理的方法
        System.out.println("被代理的方法名称: " + method.getName());
        Object result = method.invoke(subject, args);//proxy是代理类对象， subject是被代理类对象
        return result;
    }
}

使用动态代理

public class DynamicProxyTest {

    public static void main(String[] args) {
        Subject subject = new RealSubject();

        MyInvocationHandler invocationHandler = new MyInvokeHandler(subject);

        Subject subjectProxy = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), invocationHandler);
        subjectProxy.doSomething();

    }
}

输出：

被代理的方法名称: doSomething
this is RealSubject do something

【示例代码地址 https://github.com/yuankai2calm/design-pattern】