设计模式

更新ing

SOLID原则

缩写	英文	中文	描述
SRP	The Single Responsibility Principle	单一责任原则	让一个类只做一种类型责任，当这个类需要承当其他类型的责任的时候，就需要分解这个类。
OCP	The Open Closed Principle	开放封闭原则	软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。
LSP	The Liskov Substitution Principle	里氏替换原则	当一个子类的实例应该能够替换任何其超类的实例时，它们之间才具有is-A关系
DIP	The Dependency Inversion Principle	依赖倒置原则	高层模块不应该依赖于低层模块，二者都应该依赖于抽象 2. 抽象不应该依赖于细节，细节应该依赖于抽象
ISP	The Interface Segregation Principle	接口分离原则	不能强迫用户去依赖那些他们不使用的接口。换句话说，使用多个专门的接口比使用单一的总接口总要好

设计模式

单例模式Singleton

定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

扩展：可以创建固定数量的对象。

本质

控制实例数目

优点

• 节约资源

缺点

• 单例是一个虚拟机范围的，因为类装载功能是虚拟机的。对于集群环境，单例模式不适用。

示例

懒汉式：时间换空间

public class Singleton {

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton (){}

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

饿汉式：空间换时间

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

最佳方案

public enum Singleton {

    instance;

    public void operation() {
        // 操作
    }
}

实际应用场景

• 读取配置文件
• 缓存

抽象工厂Abstract Factory

定义

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类

本质

选择产品簇的实现

优点

• 分离接口和实现
• 使得切换产品簇变得容易

缺点

• 不太容易扩展新的产品
• 容易造成类层次复杂

示例

• Abstract Factory:抽象工厂，定义创建一系列产品对象的操作接口
• Concrete Factory:具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建
• Abstract Product:定义一类产品对象的接口
• Concrete Product:具体的产品实现对象，通常在具体工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象
• Client:客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象的接口编程，以实现需要的功能。

抽象工厂接口

public interface AbstractFactory {
    public AbstractProductA createProductA();
    public AbstractProductB createProductB();
}

抽象产品A的接口

public interface AbstractProductA {

}

抽象产品B的接口

public interface AbstractProductB {

}

产品A具体实现

public class ProductA1 implements AbstractProductA {
}

public class ProductA2 implements AbstractProductA {
}

产品B具体实现

public class ProductB1 implements AbstractProductB {
}

public class ProductB2 implements AbstractProductB {
}

具体工厂实现

public class ConcreteFactory1 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        AbstractFactory af = new ConcreteFactory1();
        af.createProductA();
        af.createProductB();
    }
}

实际应用场景

• 电脑组装，有不同厂家的cpu和不同厂家的主板等一系列产品。
  

DAO(Data Access Object)数据访问对象

• 数据源不同，例如：数据库数据源、LDAP数据源；本地数据源，远程数据源。
• 存储类型不同，关系型数据库、面向对象数据库、纯文件、XML
• 访问方式的不同，JDBC、JPA、EntityBean、Hibernate、iBatis
• 供应商不同，oracel,mysql
• 版本不同

DAO抽象和封装所有对数据的访问。

• 底层存储方式固定可以用工厂方法
• 底层存储方式不固定可以用抽象工厂模式

工厂方法Factory Methon

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使用一个类的实例化延迟到其子类。

本质

延迟到子类来选择实现

优点

• 让父类不知道具体实现的情况下，完成自身的功能调用；而具体的实现延迟到子类来实现
• 更容易扩展对象的新版本，工厂方法给子类提供一个挂钩，使得扩展的对象版本变得非常容易
• 连接平行的类层次

缺点

• 具体产品对象和工厂方法的耦合性

示例

• Product:定义工厂方法所创建的对象的接口，也就是实际需要使用的对象的接口。
• ConcreteProduct:具体的Product接口的实现对象
• Creator:创建器，声明工厂方法，工厂方法通常会返回一个Product类型的实例对象，而且多是抽象方法。也可以在Creator里面提供工厂方法的默认实现，让工厂方法返回一个缺省的Product类型的实例对象。
• ConcreteCreator:具体的创建器对象，覆盖实现Creator定义的工厂方法，返回具体的Product实例。

Product

public interface Product {
    // 定义Product的属性和方法
}

ConcreteProduct

public class ConcreteProduct implements Product {
    // 实现Product要求的方法
}

创建器

public abstract class Creator {

    // 创建Product的工厂方法，一般不对外
    protected abstract Product factoryMethod();

    // 提供给外部使用的方法
    public void someOperation() {
        Product product = factoryMethod();
    }
}

创建器具体实现

public class ConcreteCreator extends Creator {
    protected Product factoryMethod() {
        return new ConcreteProduct();
    }
}

实际应用场景

• 实现一个导出数据的应用框架，来让客户选择数据的导出方式，并真正执行数据导出。各分公司在局域网独立运行自己的服务，每天业务结束将数据导出成某种格式，传送给总部，总部导入数据，核算。
  
• 如果一个类需要创建某个接口的对象，但是又不知道具体的实现，这种情况可以选用工厂方法模式，把创建对象的工作延迟到子类中去实现
• 如果一个类本身就希望由它的子类来创建所需的对象的时候

IoC/DI

Q&A

• 参与者都有谁？
  
  • 某个对象：任意的，普通的Java对象
  • Ioc/DI容器：框架程序
  • 某个对象的外部资源：对象需要的，但是从对象外部获取的，都统称为资源，比如对象需要的其他对象，或者是对象需要的文件资源等
• 依赖：谁依赖于谁？为什么需要依赖？
  
  • 某个对象依赖于IoC/DI容器
  • 对象需要IoC/DI的容器来提供对象需要的外部资源
• 注入：谁注入于谁？到底注入什么？
  
  • Ioc/DI容器注入某个对象
  • 注入某个对象所需要的外部资源
• 控制反转：谁控制谁？控制什么？为何叫反转(有反转就应该有正转了)？
  
  • IoC/DI容器来控制对象
  • 主要控制对象实例的创建
  • 反转是相对正向而言的。如果A里面使用了C,当然会直接去创建C的对象，也就是说A主动去获取外部资源C，这叫正向。反向就是A不再主动去获取外部资源C，而是被动等待，等待Ioc/DI容器获取一个C的实例，然后反向注入到A类中。
• 依赖注入和控制反转是同一概念吗？
  
  • 依赖注入和控制反转是对同一件事的不同描述。依赖注入(应用程序角度)：应用程序依赖容器创建并注入它所需要的外部资源；控制反转（容器角度）：容器控制应用程序，由容器反向地向应用程序注入其所需要的外部资源。

简单工厂Simple Factory

定义

提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口，抽象类也可以是具体类。

本质

选择实现

优点

• 帮助封装，让组件外部能真正面向接口编程
• 解耦，通过简单工厂，实现客户端和具体实现类解耦

缺点

• 使用时，必须对配置非常熟悉
• 静态方法创建接口，不方便扩展子工厂（通常也不需要扩展，所以不算一个严重的缺点）

示例

• Api:定义客户所需要的功能接口
• Impl:具体实现Api的实现类，可能会有多个
• Factory:工厂，选择合适的实现类来创建Api接口对象
• Client:客户端，通过Factory来获取Api接口对象，然后面向Api接口编程

API定义

/**
 * 接口定义
 * /
public interface Api {
    public void operation(String s);
}

实现A

/**
 * 接口的具体实现A
 * /
public class ImplA implements Api {
    public void operation(String s) {
        System.out.println("ImplA s==" + s);
    }
}

实现B

/**
 * 接口的具体实现B
 * /
public class ImplB implements Api {
    public void operation(String s) {
        System.out.println("ImplB s==" + s);
    }
}

工厂类

public class Factory {
    public static Api createApi(int condition) {
        Api api = null;
        if(condition == 1) {
            api = new ImplA();
        } else if(condition == 2) {
            api = new ImplB();
        }
        return api;
    }
}

配置版工厂类(反射，可考虑用NIO优化)

public class FactoryTest {

    public static Api createApi() {
        Properties p = new Properties();
        InputStream in = null;
        try {
            in = FactoryTest.class.getResourceAsStream("FactoryTest.properties");
            p.load(in);
        } catch (IOException e) {
            System.out.println("");
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Api api = null;
        try {
            api = (Api) Class.forName(p.getProperty("implClass")).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return api;
    }
}

客户端

public class Client {
    public static void main(String [] args) {
        Api api = Factory.createApi(1);
        api.operation("正在使用简单工厂");
    }
}

配置版客户端

public class Client {
    public static void main(String [] args) {
        Api api = Factory.createApi();
        api.operation("正在使用简单工厂");
    }
}

实际应用场景

• 如果想要完全封装隔离具体实现，让外部只能通过接口来操作封装体
• 如果想要把创建对象的职责集中管理和控制

建造模式Builder

定义

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

本质

分离整体构建算法和部件构造

优点

• 松散耦合
• 可以很容易地改变产品的内部表示。
• 更好的复用性，很好的实现了构建算法和具体产品实现的分离。

缺点

未总结

示例

• Builder:生成器接口，定义创建一个Product对象所需的各个部件的操作。
• ConcreteBuilder:具体的生成器实现，实现各个部件的创建，并负责组装Product对象的各个部件，同时还提供一个让用户获取组装完成后的产品对象的方法
• Director:指导者，主要用来使用Builder接口，以一个统一的过程来构建所需要的Product对象
• Product:产品，表示被生成器构建的复杂对象，包含多个部件

生成器接口

public interface Builder {
    public void buildPart();
}

具体生成器的实现

public class ConcreteBuilder implements Builder {
    // 生成器最终构建的产品对象
    private Product resultProduct;

    // 获取最终构建的产品对象
    public Product getResult() {
    }s

    public void buildPart() {
        // 构建某个部件
    }
}

相应的产品对象接口

public interface Product {

}

指导者

public class Director {
    // 持有当前需要使用的生成器对象
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    // 指导生成器构建最终的产品对象
    public void construct() {
        // 通过使用生成器接口来构建最终的产品对象
        builder.buildPart();
    }
}

实际应用场景

• 一部分是部件构造和产品装配，另一部分是整体构建的算法
• 如果创建对象的算法，应该独立于该对象的组成部分以及它们的装配方式时
• 如果同一个构建过程有着不同的表示时

原型模式Prototype

定义

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

本质

优点

缺点

示例

• Prototype:声明一个克隆自身的接口，用来约束想要克隆自己的类，要求它们都要实现这里定义的克隆方法。
• ConcretePrototype:实现Prototype接口的类，这些类真正实现了克隆自身的功能。
• Client:使用原型客户端，首先要获取到原型实例对象，然后通过原型实例克隆自身来创建新的对象实例

原型接口

public interface Prototype {
    public Prototype clone();
}

克隆具体实现

public class ConcretePrototype1 implements Prototype {
    private String field1;

    private Product product1;

    public String getProduct1() {
        return this.product1;
    }
    pubilc void setProduct1(String product1) {
        this.product1 = product1;
    }

    public String getField1() {
        return this.field1;
    }
    pubilc void setField1(String field1) {
        this.field1 = field1;
    }

    public Prototype clone() {
        Prototype prototype = new ConcretePrototype1();
        prototype.setField1(this.field1);
        prototype.setProduct1((Product) this.product1.cloneProduct());
        return prototype;
    }
}

public class ConcretePrototype2 implements Prototype {
    private String field2;

    private Product product2;

    public String getProduct2() {
        return this.product2;
    }
    pubilc void setProduct2(String product2) {
        this.product2 = product2;
    }

    public String getField2() {
        return this.field2;
    }
    pubilc void setField2(String field2) {
        this.field2 = field2;
    }

    public Prototype clone() {
        Prototype prototype = new ConcretePrototype2();
        prototype.setField1(this.field2);
        prototype.setProduct2((Product) this.product2.cloneProduct());
        return prototype;
    }
}

原型管理器

public class PrototypeManager {
    private static Map map = new HashMap();

    private PrototypeManager() {
    }

    public synchronized static void setPrototype(String prototypeId, Prototype prototype) {
        map.put(prototypeId, prototype);
    }

    public synchronized static void removePrototype(String prototypeId) {
        map.remove(prototypeId);
    }

    public synchronized static Prototype getPrototype(String prototypeId) throws Exception {
        Prototype prototype = map.get(prototypeId);
        if(prototype == null) {
            throw new Exception("您希望获取的原型还没有注册或已被销毁");
        }
        return prototype;
    }
}

客户端

public class Client {
    private Prototype prototype;
    public Client(Prototype prototype) {
        this.prototype = prototype;
    }
    public void operation() {
        Prototype newPrototype = prototype.clone();
    }
}

实际应用场景

观察者模式Observer

定义

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

本质

触发联动

优点

• 观察者模式实现了观察者和目标之间的抽象耦合
• 观察者模式实现了动态联动
• 观察者模式支持广播通信

缺点

• 可能会引起无谓的操作

示例

• Subject:目标对象，通常具有如下功能
  
  • 一个目标可以被多个观察者观察
  • 目标提供对观察者注册和退订的维护
  • 当目标的状态发生变化时，目标负责通知所有注册的，有效的观察者
• Observer:定义观察者的接口，提供目标通知时对应的更新方法，这个更新方法进行相应的业务处理，可以在这个方法里面回调目标对象，以获取目标对象的数据
• ConcreteSubject:具体的目标实现对象，用来维护目标状态，当目标对象的状态发生变化，通知所有注册的，有效的观察者，让观察者执行相应的处理。
• ConcreteObserver:观察者的具体实现对象，用来接收目标的通知，并进行相应的后续处理，比如更新自身的状态以保持和目标的相应状态一致。

目标对象

public class Subject {
    private List observers = new ArrayList();

    // 注册观察者对象
    public void attach(Observer observer) {
        observers.add(observer);
    }

    // 删除观察者对象
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    // 通知所有注册的观察者对象
    protected void notifyObservers() {
        for(Observer observer： observers) {
            observer.update(this);
        }
    }
}

具体的目标对象

public class ConcreteSubject extends Subject {
    private String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String sunjectState) {
        this.subjectState = subjectState;
        this.notifyObservers();
    }
}

观察者接口

public interface Observer {
    public void update(Subject subject);
}

具体观察者

public class ConcreteObserver implements Observer {
    private String observerState;

    public void update(Subject subject) {
        observerState = ((ConcreteSubject) subject).getSubjectState();
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        NewsPaper subject = new NewsPaper();
        Reader reader1 = new Reader();
        reader1.setName("张三");

        Reader reader2 = new Reader();
        reader2.setName("李四");

        Reader reader3 = new Reader();
        reader3.setName("李四");

        subject.attach(reader1);
        subject.attach(reader2);
        subject.attach(reader3);

        subject.setContent("本期内容是观察者模式");
    }
}

实际应用场景

• 推模式：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的消息通常是目标对象的全部或部分数据，相当于是在广播通信。适用于目标对象知道观察者需要什么数据。
• 拉模式：目标对象在通知观察者的时候，只传递少量信息。如果观察者需要具体的信息，由观察者主动到目标对象中获取，相当于是观察者从目标对象中拉数据，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。适用于目标对象不知道观察者需要什么数据，将自己的引用传给观察者，让观察者按需取值。这个更加通用。

策略模式Strategy

定义

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

本质

分离算法，选择实现

优点

• 定义一系列算法
• 避免多重条件语句
• 更好的扩展性

缺点

• 客户必须了解每种策略的不同
• 增加了对象数目
• 只合适扁平的算法结构

示例

• Strategy:策略接口，用来约束一系列具体的策略算法。Context使用这个接口来调用具体的策略实现定义的算法
• ConcreteStrategy:具体的策略实现，也就是具体的算法实现
• Context:上下文，负责和具体的策略类交互。通常上下文会持有一个真正的策略实现，上下文还可以让具体的策略类来获取上下文的数据，甚至让具体的策略类来回调上下文的方法。

策略接口

public interface Strategy {
    public void algorithmInterface();
}

具体策略

public interface ConcreteStrategyA implements Strategy {
    public void algorithmInterface() {
    }
}

public interface ConcreteStrategyB implements Strategy {
    public void algorithmInterface() {
    }
}

上下文

public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void contextInterface() {
        strategy.algorithmInterface();
    }
}

实际应用场景

责任链模式China of Responsibility

定义

使用多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到一个对象处理它为止。

本质

分离职责，动态组合

优点

• 请求者和接收者松散耦合
• 动态组合职责

缺点

• 产生很多细粒度对象
• 不一定能被处理。传递完都没被处理，需要提供默认的处理。

示例

• Handler：定义职责的接口
• ConcreteHandler:实现职责的类。在这个类中，实现对在它职责范围内请求的处理，如果不处理，就继续转发请求给后继者。
• Client:职责链客户端

职责的接口

public abstract class Handler {
    protected Handler successor;
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest();
}

通用的请求对象

public class RequestModel {
    private String type;
    public RequestModel(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

具体的请求对象

public class ConcreteRequestModel extends RequestModel {
    public final static String A_TYPE = "A";
    public ConcreteRequestModel() {
        super(A_TYPE);
    }
    private String field1;
    ...
}

具体的职责对象

public class ConcreteHandler1 extends Handler {
    public Object handleRequest(RequestModel rm) {
        // 根据某些条件判断是否属于自己处理的职责范围
        boolean someCondition = false;
        Object result;
        if(someCondition) {
            // 处理
            return result;
        } else {
            // 不处理，转发请求给后继职责对象
            if(this.successor != null) {
                return this.successor.handleRequest(rm);
            } else {
                return result;
            }
        }
    }
}

客户端（可采用链表改进客户端）

public class Client {
    public static void main(String[] args) {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        h1.setSuccessor(h2);
        h1.handleRequest();
    }
}

实际应用场景

• 权限检查
• 通用数据校验
• 数据逻辑校验
• 过滤器
• 可以和组合模式一起使用，通过组合模式将责任组合起来

中介者模式Mediator

定义

本质

封装隔离

优点

• 松散耦合
• 集中控制交互
• 多对多变成一对多

缺点

• 过度集中化。中介者对象十分复杂，难于管理和维护。

示例

• Mediator:中介者接口，在里面定义各个同事之间交互需要的方法，可以是公共的通信方法，比如changed方法，大家都用，也可以是小范围的交互方法。
• ConcreteMediator:具体中介者实现对象。它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系。
• Colleague:同事类的定义，通常实现成抽象类，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能。
• ConcreteColleague:具体的同事类，实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同事交互。

同事类的抽象父类

public abstract class Colleague {

    private Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public Mediator getMediator() {
        return mediator;
    }
}

同事类A

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    public void someOperation() {
        // 需要跟其他同事通信的时候，通知中介者对象
        getMediator().changed(this);
    }
}

同事类B

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    public void someOperation() {
        // 需要跟其他同事通信的时候，通知中介者对象
        getMediator().changed(this);
    }
}

中介者接口
public interface Mediator {

    public void changed(Colleague colleague);
}

中介者实现

public class ConcreateMediator implements Mediator {
    private ConcreteColleagueA colleagueA;

    private ConcreteColleagueB colleagueB;

    public void setConcreteColleagueA(ConcreteColleagueA colleague) {
        colleagueA = colleague;
    }

    public void setConcreteColleagueB(ConcreteColleagueB colleague) {
        colleagueB = colleague;
    }

    public void changed(Colleague colleague) {
        // 某个同事类发生了变化，通常需要与其他同事交互
        // 具体协调相应的同事对象来实现协作行为
    }
}

客户端

public class Client {

}

实际应用场景

• 如果一组对象之间的通信方式比较复杂，导致相互依赖，结构混乱，可以采用中介者模式
• 如果一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象

外观模式Facade

定义

为子系统中的一组接口提供一个一致的界面，也就是一个高层接口。

本质

为多模块提供统一接口，封装交互，简化调用

优点

• 减少外部与子系统内多模块的交互，松散耦合
• 出现变化时，只需修改Facade的实现就好，只需改这一个地方，由于很多客户端都会用这个外观模式，无需修改所有的客户端。从而达到一改全改。
• 调用多个模块在外观模式调用一次就好了，无需所有客户端都调用一次，减少重复调用
• 客户端无需了解系统的内部实现，无需了解每个模块的细节，也不需要去和多个模块交互，节省了学习成本。
• 将外部接口和外部接口分开。封装更好

缺点

• 过多或者不合理的Facade容易让人迷惑，到底是调用Facade好，还是直接调用模块好。

示例

A模块Api

public interface AModuleApi {
    public void testA1(); //系统外部使用
    public void testA2(); //系统内部使用
    public void testA3(); //系统内部使用
}

实现A模块

public class AModuleImpl implements AModuleApi {
    public void testA1() {
        System.out.println("现在在A模块里面操作testA1方法");
    }
    public void testA2() {
        System.out.println("现在在A模块里面操作testA2方法");
    }
    public void testA3() {
        System.out.println("现在在A模块里面操作testA3方法");
    }
}

B模块Api

public interface BModuleApi {
    public void testB1(); //系统外部使用
    public void testB2(); //系统内部使用
    public void testB3(); //系统内部使用
}

实现B模块

public class BModuleImpl implements BModuleApi {
    public void testB1() {
        System.out.println("现在在B模块里面操作testB1方法");
    }
    public void testB2() {
        System.out.println("现在在B模块里面操作testB2方法");
    }
    public void testB3() {
        System.out.println("现在在B模块里面操作testB3方法");
    }
}

C模块Api

public interface CModuleApi {
    public void testC1(); //系统外部使用
    public void testC2(); //系统内部使用
    public void testC3(); //系统内部使用
}

实现B模块

public class CModuleImpl implements CModuleApi {
    public void testC1() {
        System.out.println("现在在C模块里面操作testC1方法");
    }
    public void testC2() {
        System.out.println("现在在C模块里面操作testC2方法");
    }
    public void testC3() {
        System.out.println("现在在C模块里面操作testC3方法");
    }
}

外观接口

public interface FacadeApi {
    // 只暴露对外部调用的接口
    public void testA1();
    public void testB1();
    public void testC1();
    public void test();
}

外观类

public class Facade {
    public void test() {
        AModuleApi a = new AModuleImpl()；
        a.testA1();
        BModuleApi b = new BModuleApi()；
        b.testB1();
        CModuleApi c = new CModuleImpl()；
        c.testC1();
    }
}

客户端

public class Client {
    public static void main(String [] args) {
        Facade facade = new Facade();
        facade.test();
    }
}

实际应用场景

代理模式Proxy

定义

为其他对象提供一种代理以控制对这个对象的访问。

本质

控制对象访问

优点

缺点

示例

• Proxy:代理对象。实现与具体的目标对象一样的接口，这样就可以使用代理来代替具体的目标对象。保存一个指向具体目标对象的引用，可以在需要的时候调用具体的目标对象。可以控制对具体目标对象的访问，并可以负责创建和删除它。
• Subject:目标接口，定义代理和具体目标对象的接口，这样就可以在任何使用具体目标对象的地方使用代理对象。
• RealSubject:具体的目标对象，真正实现目标接口要求的功能。

抽象的目标接口

public interface Subject {
    public void request();
}

具体的目标对象，是真正被代理的对象

public class RealSubject implements Subject {
    public void request() {
    }
}

代理对象的实现示意

public class Proxy implements Subject {
    private RealSubject realSubject = null;
    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
    public void request() {
        // 在转调具体的目标对象前，可以执行一些功能处理

        // 转调具体的目标对象的方法
        realSubject.requst();

        // 在转调具体的目标对象后，可以执行一些功能处理
    }
}

实际应用场景

• 一次性访问多条数据。当选择一个部门或者分公司时，要把这个部门或者分公司下的所有员工都显示出来，而且不要翻页，方便进行业务处理。

定义用户数据对象

public interface UserModelApi {

    public String getUserId();
    public void setUserId(String userId);
    public String getName();
    public void setName(String name);
    public String getDepId();
    public void setDepId(String depId);
    public void String getSex();
    public void setSex(String sex);
}

代理类

public class Proxy implements UserModelApi {
    private UserModel realSubject = null;
    public Proxy(UserModel realSubject){
        this.realSubject = realSubject;
    }

    // 标识是否已经重新装载过数据
    private boolean loaded = false;
    public String getUserId() {
        return realSubject.getUserId();
    }

    public void setUserId(String userId) {
        realSubject.setUserId(userId);
    }

    public String getName() {
        return realSubject.getName();
    }

    public void setName(String name) {
        realSubject.setName(name);
    }

    public void setDepId(String depId) {
        realSubject.setDepId(depId);
    }

    public void setSex(String sex) {
        realSubject.setSex(sex);
    }

    public String getDepId() {
        // 需要判读是否已经装载过了
        if(!this.loaded) {
            reload();
            // 设置重新装载的标志为true
            this.loaded = true;
        }
        return realSubject.getDepId();
    }

    public String getSex() {
        // 需要判读是否已经装载过了
        if(!this.loaded) {
            reload();
            // 设置重新装载的标志为true
            this.loaded = true;
        }
        return realSubject.getSex();
    }

    private void reload() {
        Connection conn = null;
        try {
            conn = this.getConnection();
            String sql = "select * from tbl_user where userId = ?";
            PreparedStatement pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, realSubject.getUserId());
            if(re.next()) {
                realSubject.setDepId(rs.getString("depId"));
                realSubject.setSex(rs.getString("sex"));
            }
            rs.close();
            pstmt.close();
        } catch (Exception err) {
            err.printStackTrace();
        } finally {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

• 动态代理AOP

代理分类

• 虚代理：根据需要来创建开销很大的对象，该对象只有在需要的时候才会被真正创建
• 远程代理：用来在不同的地址空间上代表同一个对象，这个不同的地址空间可以是在本机，也可以在其他机器上。在Java里面最典型的就是RMI技术
• copy-on-write代理：在客户端操作的时候，只有对象确实改变了，才会真的拷贝或者克隆一个目标对象，算是虚代理的一个分支
• 保护代理：控制对原始对象的访问，如果有需要，可以给不同的用户提供不同的访问权限，以控制他们对原始对象的访问。
• Cache代理：为那些昂贵操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果
• 防火墙代理：保护对象不被恶意用户访问和操作。
• 同步代理：使多个用户能够同时访问，目标对象而没有冲突。
• 智能指引：在访问对象时执行一些附加操作，比如，对指向实际对象的引用计数、第一次引用一个持久对象时，将它装入内存等。

适配器模式Adapter

定义

把不兼容的接口转换匹配成客户需要的接口，复用已有的功能

本质

转换匹配，复用功能。

优点

• 兼容老接口，更好的复用。
• 更好的扩展

缺点

• 过多使用适配器，会让系统非常零乱，不容易整体进行把握。

示例

• Client:客户端，调用自己需要的领域接口Target
• Traget:定义客户端需要的跟特定领域相关的接口
• Adaptee:已经存在的接口，通常能满足客户端的功能要求，但是接口与客户端要求的特定领域接口不一致，需要被适配
• Adapter:适配器，把Adaptee适配成为Client需要的Target

Target Api

public interface Target {
    public void request();
}

被适配的类

public class Adaptee {
    public void specificRequest() {
        //具体功能
    }
}

适配器

public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    public void request() {
    }
}

客户端

public class Client {
    public static void main(String [] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}

实际应用场景

• 如果想要使用一个已经存在的类，但是它的接口不符合你的需求
• 如果想创建一个可以复用的类，这个类可能和一些不兼容的类一起工作
• 如果想使用一些已经存在的子类，但是不可能对每一个子类都进行适配，这种情况可以选用对象适配器，直接适配这些子类的父类就可以了

装饰模式Decrator

定义

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更为灵活。

本质

动态组合

优点

• 比继承更灵活。继承是静态的，装饰器采用把功能分离到每个装饰器中，通过对象组合动态使用。
• 更容易复用功能。
• 简化高层定义。

缺点

• 会产生很多细粒度的对象

示例

• Component:组件对象的接口，可以给这些对象动态地添加职责
• ConcreteComponent:具体的组件对象，实现组件对象接口，通常就是被装饰器装饰的原始对象，也就是可以给这个对象添加职责。
• Decorator:所有装饰器的抽象父类，需要定义一个与组件接口一致的接口，并持有一个Component对象，其实就是持有一个被装饰的对象。
• ConcreteDecorator:实际的装饰器对象，实现具体要向被装饰对象添加的功能

组件对象的接口

public abstract class Component {
    public abstract void operation();
}

具体实现组件对象

public class ConcreteComponent extends Component {
    public void operation() {
    }
}

装饰器的抽象父类

public abstract class Decorator extends Component {
    protected Component component;
    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        // 转发请求给组件对象，可以在转发前后执行一些附加动作
        component.operation();
    }
}

装饰器的具体实现A

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    // 添加的状态
    private String addedState;
    public String getAddedState() {
        return addedState;
    }

    public void setAddedState(String addedState) {
        this.addedState = addedState;
    }

    public void operation() {
        // 调用父类的方法，可以在调用前后执行一些附加动作
        super.operation();
        // ...
        String useAddedState = addedState;
    }
}

装饰器的具体实现B

public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    // 添加的职责
    private void addedBehavior() {
        // 需要添加的职责实现
    }

    public void operation() {
        // 调用父类的方法，可以在调用前后执行一些附加动作
        super.operation();
        // ...
        addedBehavior();
    }
}

实际应用场景

• 灵活的奖金计算
• I/O流