/**
 * 饿汉式
 * 问题: 如果只是加载本类, 而没有调用getInstance方法, 会造成资源浪费
 * Created by jifang on 15/12/4.
 */
public class HungerSingleton {
    /**
     * 类初始化时理解初始化该实例
     * 类加载时, 天然的线程安全时刻
     */
    private static final HungerSingleton instance = new HungerSingleton();
    private HungerSingleton() {
    }
    /**
     * 方法没有同步(synchronized), 调用效率高
     */
    public static HungerSingleton getInstance() {
        return instance;
    }
    @Override
    public String toString() {
        return "HungerSingleton{}";
    }
}

/**
 * 懒汉式
 * 问题: 每次调用getInstance都要同步(synchronized), 效率降低
 * Created by jifang on 15/12/4.
 */
public class LazySingleton {
    /**
     * 类加载时并没初始化, 延迟加载
     */
    private static LazySingleton instance;
    private LazySingleton() {
    }
    /**
     * 注意synchronized, 线程安全
     */
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
    @Override
    public String toString() {
        return "LazySingleton{}";
    }
}

/**
 * 双重锁定实现
 * 问题: 适用于JDK1.5之后的版本
 * Created by jifang on 15/12/4.
 */
public class DoubleCheckSingleton {
    /**
     * 需要使用volatile
     * 保证所有的写(write)都将先行发生于读(read)
     */
    private static volatile DoubleCheckSingleton instance;
    private DoubleCheckSingleton() {
    }
    public static DoubleCheckSingleton getInstance() {
        if (instance == null) {                          //Single Checked
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {                  // Double Checked
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
    @Override
    public String toString() {
        return "DoubleCheckSingleton{}";
    }
}

/**
 * 静态内部类实现Singleton
 * Created by jifang on 15/12/4.
 */
public class StaticInnerSingleton {
    /**
     * 外部类没有static属性, 因此加载本类时不会立即初始化对象
     */
    private static class InnerClassInstance {
        private static final StaticInnerSingleton instance = new StaticInnerSingleton();
    }
    private StaticInnerSingleton() {
    }
    /**
     * 只有真正调用getInstance方法时, 才会加载静态内部类(延迟加载), 而且加载类是天然的线程安全的(线程安全), 没有synchronized(调用效率高)
     *
     * @return
     */
    public static StaticInnerSingleton getInstance() {
        return InnerClassInstance.instance;
    }
    @Override
    public String toString() {
        return "StaticInnerSingleton{}";
    }
}

/**
 * 枚举实现单例
 * 基于JVM底层实现, Enum天然的单例以及线程安全
 * Created by jifang on 15/12/5.
 */
public enum EnumSingleton {
    /**
     * 构造方法默认为private
     */
    INSTANCE;
    /**
     * 可以添加其他操作
     * other operation
     */
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "EnumSingleton{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 单例破解
 * Created by jifang on 15/12/4.
 */
public class TestCase {
    @Test
    public void testBreakDoubleCheck() {
        try {
            Class<DoubleCheckSingleton> clazz = (Class<DoubleCheckSingleton>) Class.forName("com.feiqing.singleton.DoubleCheckSingleton");
            Constructor<DoubleCheckSingleton> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);
            DoubleCheckSingleton instance1 = constructor.newInstance();
            DoubleCheckSingleton instance2 = constructor.newInstance();
            System.out.println("singleton? " + (instance1 == instance2));
            System.out.println(instance1.hashCode());
            System.out.println(instance2.hashCode());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

public class LazySingleton implements Serializable{
    private static final long serialVersionUID = 8511876423469188139L;
    /**
     * 类加载时并没初始化, 延迟加载
     */
    private static LazySingleton instance;
    private LazySingleton() {
        if (instance != null){
            throw new RuntimeException();
        }
    }
    /**
     * 注意synchronized, 线程安全
     */
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
    @Override
    public String toString() {
        return "LazySingleton{}";
    }
}

public class TestCase {
    private static final String SYSTEM_FILE = "/tmp/save.txt";
    @Test
    public void testBreakLazy() {
        LazySingleton instance1 = LazySingleton.getInstance();
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(SYSTEM_FILE));
            oos.writeObject(instance1);
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(SYSTEM_FILE));
            LazySingleton instance2 = (LazySingleton) ois.readObject();
            System.out.println("singleton? " + (instance1 == instance2));
            System.out.println(instance1.hashCode());
            System.out.println(instance2.hashCode());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

/**
     * 反序列化时, 如果定义了readResolve方法, 则直接返回此方法制定的对象.
     *
     * @return
     */
    private Object readResolve() {
        return instance;
    }

/**
 * 单例性能测试
 * Created by jifang on 15/12/4.
 */
public class TestCase {
    private static final String SYSTEM_FILE = "/tmp/save.txt";
    private static final int THREAD_COUNT = 10;
    private static final int CIRCLE_COUNT = 100000;
    @Test
    public void testSingletonPerformance() throws IOException, InterruptedException {
        final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        FileWriter writer = new FileWriter(new File(SYSTEM_FILE), true);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; ++i) {
            new Thread(
                    new Runnable() {
                        @Override
                        public void run() {
                            for (int i = 0; i < CIRCLE_COUNT; ++i) {
                                Object instance = HungerSingleton.getInstance();
                            }
                            latch.countDown();
                        }
                    }
            ).start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        writer.append("HungerSingleton 共耗时: " + (end - start) + " 毫秒\n");
        writer.close();
    }
}

/**
 * 运算符接口
 * Created by jifang on 15/12/7.
 */
public interface Operator<T> {
    T getResult(T... args);
}

public class AddOperator implements Operator<Integer> {
    @Override
    public Integer getResult(Integer... args) {
        int result = 0;
        for (int arg : args) {
            result += arg;
        }
        return result;
    }
}


public class MultiOperator implements Operator<Integer> {
    @Override
    public Integer getResult(Integer... args) {
        int result = 1;
        for (int arg : args) {
            result *= arg;
        }
        return result;
    }
}

/**
 * 静态工厂(注: 只返回产品的抽象[即接口])
 * 包含两种实现策略
 * 1. 根据传入的operator名进行实例化对象
 * 2. 直接调用相应的构造实例的方法
 * Created by jifang on 15/12/7.
 */
public class OperatorFactory {
    public static Operator<Integer> createOperator(String operName) {
        Operator<Integer> operator;
        switch (operName) {
            case "+":
                operator = new AddOperator();
                break;
            case "*":
                operator = new MultiOperator();
                break;
            default:
                throw new RuntimeException("Wrong Operator Name: " + operName);
        }
        return operator;
    }
    /* ** 第二种实现策略 ** */
    public static Operator<Integer> createAddOper() {
        return new AddOperator();
    }
    public static Operator<Integer> createMultiOper() {
        return new MultiOperator();
    }
}

public class Client {
    @Test
    public void testAdd() {
        Operator<Integer> operator = OperatorFactory.createOperator("+");
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }
    @Test
    public void testMultiplication() {
        Operator<Integer> operator = OperatorFactory.createOperator("*");
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }
    @Test
    public void testAddName(){
        Operator<Integer> operator = OperatorFactory.createAddOper();
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }
    @Test
    public void testMultiplicationName() {
        Operator<Integer> operator = OperatorFactory.createMultiOper();
        System.out.println(operator.getResult(1, 2, 3, 4, 6));
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public interface Factory<T> {
    Operator<T> createOperator();
}

/**
 * 加法运算符工厂
 * Created by jifang on 15/12/7.
 */
public class AddFactory implements Factory<Integer> {
    @Override
    public Operator<Integer> createOperator() {
        return new AddOperator();
    }
}


/**
 * 乘法运算符工厂
 * Created by jifang on 15/12/7.
 */
public class MultiFactory implements Factory<Integer> {
    @Override
    public Operator<Integer> createOperator() {
        return new MultiOperator();
    }
}

/**
 * 开根运算符
 * Created by jifang on 15/12/7.
 */
public class SqrtOperator implements Operator<Double> {
    @Override
    public Double getResult(Double... args) {
        if (args != null && args.length >= 1) {
            return Math.sqrt(args[0]);
        } else {
            throw new RuntimeException("Params Number Error " + args.length);
        }
    }
}


/**
 * 开根工厂
 * Created by jifang on 15/12/7.
 */
public class SqrtFactory implements Factory<Double> {
    @Override
    public Operator<Double> createOperator() {
        return new SqrtOperator();
    }
}

public interface Engine {
    void start();
    void run();
}
class LowEngine implements Engine {
    @Override
    public void start() {
        System.out.println("启动慢 ...");
    }
    @Override
    public void run() {
        System.out.println("转速慢 ...");
    }
}
class LuxuryEngine implements Engine {
    @Override
    public void start() {
        System.out.println("启动快 ...");
    }
    @Override
    public void run() {
        System.out.println("转速快 ...");
    }
}

public interface Tyre {
    void revolve();
}
class LowTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("旋转 - 不耐磨 ...");
    }
}
class LuxuryTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("旋转 - 不磨损 ...");
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }
    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

public class LuxuryCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }
    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }
    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public class Client {
    @Test
    public void testLow(){
        CarFactory factory = new LowCarFactory();
        Engine engine = factory.createEngine();
        engine.start();
        engine.run();
        Seat seat = factory.createSeat();
        seat.massage();
        Tyre tyre = factory.createTyre();
        tyre.revolve();
    }
    @Test
    public void testLuxury(){
        CarFactory factory = new LuxuryCarFactory();
        Engine engine = factory.createEngine();
        engine.start();
        engine.run();
        Seat seat = factory.createSeat();
        seat.massage();
        Tyre tyre = factory.createTyre();
        tyre.revolve();
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public class CarCreator {
    private static final String CAR_TYPE = "low";
    private static final String CAR_TYPE_LOW = "low";
    private static final String CAR_TYPE_LUXURY = "luxury";
    public static Engine createEngine() {
        Engine engine = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                engine = new LowEngine();
                break;
            case CAR_TYPE_LUXURY:
                engine = new LuxuryEngine();
                break;
        }
        return engine;
    }
    public static Seat createSeat() {
        Seat seat = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                seat = new LowSeat();
                break;
            case CAR_TYPE_LUXURY:
                seat = new LuxurySeat();
                break;
        }
        return seat;
    }
    public static Tyre createTyre() {
        Tyre tyre = null;
        switch (CAR_TYPE) {
            case CAR_TYPE_LOW:
                tyre = new LowTyre();
                break;
            case CAR_TYPE_LUXURY:
                tyre = new LuxuryTyre();
                break;
        }
        return tyre;
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public class CarCreatorReflect {
    /**
     * 在实际开发中, 下面这些常量可以从配置文件中读取
     */
    private static final String PACKAGE = "com.feiqing.abstractfactory";
    private static final String ENGINE = "LuxuryEngine";
    private static final String TYRE = "LuxuryTyre";
    private static final String SEAT = "LuxurySeat";
    public static Engine createEngine() {
        String className = PACKAGE + "." + ENGINE;
        try {
            return (Engine) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Seat createSeat() {
        String className = PACKAGE + "." + SEAT;
        try {
            return (Seat) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static Tyre createTyre() {
        String className = PACKAGE + "." + TYRE;
        try {
            return (Tyre) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

/**
 * Created by jifang on 15/12/7.
 */
public class StaticClient {
    @Test
    public void testLow() {
        Engine engine = CarCreator.createEngine();
        engine.run();
        engine.start();
        Seat seat = CarCreator.createSeat();
        seat.massage();
        Tyre tyre = CarCreator.createTyre();
        tyre.revolve();
    }
    @Test
    public void testLuxury() {
        Engine engine = CarCreatorReflect.createEngine();
        engine.run();
        engine.start();
        Seat seat = CarCreatorReflect.createSeat();
        seat.massage();
        Tyre tyre = CarCreatorReflect.createTyre();
        tyre.revolve();
    }
}

/**
 * 该羊支持克隆
 * (浅复制)
 * Created by jifang on 15/12/9.
 */
public class Sheep implements Cloneable {
    private String name;
    private Date birthday;
    public Sheep() {
    }
    public Sheep(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                '}';
    }
    @Override
    protected Sheep clone() throws CloneNotSupportedException {
        return (Sheep) super.clone();
    }
}

public class Client {
    @Test
    public void client() throws CloneNotSupportedException {
        Date birthday = new Date();
        Sheep mother = new Sheep("多利母亲", birthday);
        System.out.println(mother);
        Sheep dolly = mother.clone();
        dolly.setName("多利");
        System.out.println(dolly);
    }
}

@Test
public void client() throws CloneNotSupportedException {
    Date birthday = new Date();
    Sheep mother = new Sheep("多利母亲", birthday);
    System.out.println(mother);
    Sheep dolly = mother.clone();
    dolly.setName("多利");
    System.out.println(dolly);
    birthday.setTime(123123123123L);
    System.out.println("dolly birthday: " + dolly.getBirthday());
}

@Override
protected Sheep clone() throws CloneNotSupportedException {
    Sheep sheep = (Sheep) super.clone();
    // 添加下面代码支持深复制
    sheep.birthday = (Date) this.birthday.clone();
    return sheep;
}

@Override
protected Sheep clone() throws CloneNotSupportedException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        return (Sheep) ois.readObject();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 模拟耗时的对象创建过程
 *
 * @param name
 * @param birthday
 */
public Sheep(String name, Date birthday) {
    try {
        Thread.sleep(10);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    this.name = name;
    this.birthday = birthday;
}

public class Client {
    private static final int OBJECT_COUNT = 1000;
    private long testNew() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < OBJECT_COUNT; ++i) {
            Sheep sheep = new Sheep("name", new Date());
        }
        return System.currentTimeMillis() - start;
    }
    private long testPrototype() throws CloneNotSupportedException {
        long start = System.currentTimeMillis();
        Sheep sheep = new Sheep("name", new Date());
        for (int i = 0; i < OBJECT_COUNT; ++i) {
            Sheep newSheep = sheep.clone();
            newSheep.setName("new name");
        }
        return System.currentTimeMillis() - start;
    }
    @Test
    public void client() throws CloneNotSupportedException {
        System.out.println(testNew());
        System.out.println(testPrototype());
    }
}

需求: 模仿宇宙飞船的建造过程
    假设宇宙飞船有很多零部件: 引擎、轨道舱、逃逸塔、各种小零件... 因此宇宙飞船的建造/装配非常复杂(需要很好的生产/装配技术),而建造者模式可以将部件的建造与装配分开:

/**
 * 目标对象 - 宇宙飞船
 * (代表复杂对象, 拥有复杂的建造过程)
 * Created by jifang on 15/12/8.
 */
public class AirShip {
    private Engine engine;
    private EscapeTower escapeTower;
    private OrbitalModule orbitalModule;
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public EscapeTower getEscapeTower() {
        return escapeTower;
    }
    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }
    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }
    @Override
    public String toString() {
        return "AirShip{" +
                "engine=" + engine +
                ", escapeTower=" + escapeTower +
                ", orbitalModule=" + orbitalModule +
                '}';
    }
}
class Engine {
    private String description;
    public Engine(String description) {
        this.description = description;
    }
    @Override
    public String toString() {
        return "Engine{" +
                "description='" + description + '\'' +
                '}';
    }
}
class EscapeTower {
    private String description;
    public EscapeTower(String description) {
        this.description = description;
    }
    @Override
    public String toString() {
        return "EscapeTower{" +
                "description='" + description + '\'' +
                '}';
    }
}
class OrbitalModule {
    private String description;
    public OrbitalModule(String description) {
        this.description = description;
    }
    @Override
    public String toString() {
        return "OrbitalModule{" +
                "description='" + description + '\'' +
                '}';
    }
}

/**
 * @author jifang
 * @since 16/8/17 下午2:13.
 */
public interface AirShipBuilder {
    void builtEngine();
    void builtEscapeTower();
    void builtOrbitalModule();
    AirShip getResult();
}

class LowerAirShipBuilder implements AirShipBuilder {
    private AirShip airShip = new AirShip();
    @Override
    public void builtEngine() {
        System.out.println("\t\t构造低端引擎");
        airShip.setEngine(new Engine("低端 - 引擎"));
    }
    @Override
    public void builtEscapeTower() {
        System.out.println("\t\t构造低端逃逸塔");
        airShip.setEscapeTower(new EscapeTower("低端 - 逃逸塔"));
    }
    @Override
    public void builtOrbitalModule() {
        System.out.println("\t\t构造低端轨道舱");
        airShip.setOrbitalModule(new OrbitalModule("低端 - 轨道舱"));
    }
    @Override
    public AirShip getResult() {
        return airShip;
    }
}
class HigherAirShipBuilder implements AirShipBuilder {
    private AirShip airShip = new AirShip();
    @Override
    public void builtEngine() {
        System.out.println("\t\t构造高端引擎");
        airShip.setEngine(new Engine("高端 - 引擎"));
    }
    @Override
    public void builtEscapeTower() {
        System.out.println("\t\t构造高端逃逸塔");
        airShip.setEscapeTower(new EscapeTower("高端 - 逃逸塔"));
    }
    @Override
    public void builtOrbitalModule() {
        System.out.println("\t\t构造高端轨道舱");
        airShip.setOrbitalModule(new OrbitalModule("高端 - 轨道舱"));
    }
    @Override
    public AirShip getResult() {
        return airShip;
    }
}

/**
 * @author jifang
 * @since 16/8/17 下午2:15.
 */
public class AirShipDirector {
    /**
     * 确定一种稳定的构造过程
     *
     * @param builder
     */
    public static void construct(AirShipBuilder builder) {
        builder.builtEngine();
        builder.builtEscapeTower();
        builder.builtOrbitalModule();
    }
}

public class Client {
    @Test
    public void client() {
        AirShipBuilder lowBuilder = new LowerAirShipBuilder();
        // 构造低端飞船
        AirShipDirector.construct(lowBuilder);
        AirShip lowShip = lowBuilder.getResult();
        System.out.println(lowShip);
        AirShipBuilder highBuilder = new HigherAirShipBuilder();
        // 相同的构造过程, 不同的Builder, 可以构造出不同的飞船
        AirShipDirector.construct(highBuilder);
        AirShip highShip = highBuilder.getResult();
        System.out.println(highShip);
    }
}

/**
 * @author Clinton Begin
 */
public class SqlSessionFactoryBuilder {
  public SqlSessionFactory build(Reader reader) {
    return build(reader, null, null);
  }
  public SqlSessionFactory build(Reader reader, String environment) {
    return build(reader, environment, null);
  }
  public SqlSessionFactory build(Reader reader, Properties properties) {
    return build(reader, null, properties);
  }
  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }
  public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }
  public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
  }
  public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
  }
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }
}

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath:mybatis/mapper/*DAO.xml"/>
    <property name="typeAliases" value="com.feiqing.domain.User"/>
    <property name="configLocation" value="classpath:mybatis/mybatis-configuration.xml"/>
</bean>

/**
 * Created by jifang on 15/12/10.
 */
public class Adaptee {
    public void specificRequest() {
        System.out.println("特殊请求");
    }
}

* 目标`接口(Target)`


public interface Target {
    void request();
}

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

public class Client {
    @Test
    public void client() {
        Target target = new Adapter(new Adaptee());
        target.request();
    }
}

/**
 * 定义真实对象和代理对象的公共接口
 * Created by jifang on 15/12/20.
 */
public interface Star {
    // 签约
    void signContract();
    // 唱歌
    void singSong();
    // 收款
    void collectMoney();
}

public class RealStar implements Star {
    /**
     * 由于这些事情都委托给代理来做了, 因此我们只是象征性实现就好了
     */
    @Override
    public void signContract() {
    }
    @Override
    public void collectMoney() {
    }
    /**
     * 但唱歌是要自己真唱的
     */
    @Override
    public void singSong() {
        System.out.println("周杰伦在唱歌");
    }
}

public class StaticProxy implements Star {
    private Star star;
    public StaticProxy(Star star) {
        this.star = star;
    }
    @Override
    public void signContract() {
        System.out.println("代理签约");
    }
    /**
     * 代理可以帮明星做任何事, 但唯独唱歌这件事必须由Star自己来完成
     */
    @Override
    public void singSong() {
        star.singSong();
    }
    @Override
    public void collectMoney() {
        System.out.println("代理收钱");
    }
}

public class Client {
    @Test
    public void client() {
        Star star = new StaticProxy(new RealStar());
        star.signContract();
        star.singSong();
        star.collectMoney();
    }
}

/**
 * Star只负责唱歌就行了
 * Created by jifang on 15/12/20.
 */
public interface Star {
    // 唱歌
    void singSong();
}

public class RealStar implements Star {
    /**
     * 唱歌是要自己真唱的
     */
    @Override
    public void singSong() {
        System.out.println("周杰伦在唱歌");
    }
}

/**
 * 相当于原先的代理需要执行的方法
 * Created by jifang on 15/12/20.
 */
public class ProxyHandler implements InvocationHandler {
    private Star star;
    public ProxyHandler(Star star) {
        this.star = star;
    }
    /**
     * 代理对象的实现的所有接口中的方法, 内容都是调用invoke方法
     *
     * @param proxy  代理对象(Proxy.newProxyInstance返回的对象)
     * @param method 当前被调的方法
     * @param args   执行当前方法的参数
     * @return 执行方法method的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("签约");
        Object result = null;
        if (method.getName().equals("singSong")) {
            result = method.invoke(star, args);
        }
        System.out.println("收款");
        return result;
    }
}

public class Client {
    @Test
    public void client() {
        /**
         * newProxyInstance方法会动态生成一个代理类, 他实现了Star接口, 然后创建该类的对象.
         *
         * 三个参数
         * 1. ClassLoader: 生成一个类, 这个类也需要加载到方法区中, 因此需要指定ClassLoader来加载该类
         * 2. Class[] interfaces: 要实现的接口
         * 3. InvocationHandler: 调用处理器
         */
        Star proxyStar = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, new ProxyHandler(new RealStar()));
        proxyStar.singSong();
    }
}

/**
 * Created by jifang on 15/12/21.
 */
public class ProxyFactory {
    private BeforeAdvice beforeAdvice;
    private Object targetObject;
    private AfterAdvice afterAdvice;
    public ProxyFactory() {
    }
    public ProxyFactory(BeforeAdvice beforeAdvice, Object targetObject, AfterAdvice afterAdvice) {
        this.beforeAdvice = beforeAdvice;
        this.targetObject = targetObject;
        this.afterAdvice = afterAdvice;
    }
    private InvocationHandler handler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if (beforeAdvice != null) {
                beforeAdvice.before();
            }
            Object result = null;
            if (targetObject != null) {
                result = method.invoke(targetObject, args);
            }
            if (afterAdvice != null) {
                afterAdvice.after();
            }
            return result;
        }
    };
    public Object createProxy() {
        return Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), targetObject.getClass().getInterfaces(), handler);
    }
}

/**
 * Created by jifang on 15/12/20.
 */
public class Client {
    @Test
    public void client() {
        Star star = (Star) new ProxyFactory(new StarBeforeAdvice(), new RealStar(), new StarAfterAdvice()).createProxy();
        star.singSong();
    }
    /**
     * BeforeAdvice实现可定制化
     */
    private static class StarBeforeAdvice implements BeforeAdvice {
        @Override
        public void before() {
            System.out.println("签合约");
        }
    }
    /**
     * AfterAdvice实现可定制化
     */
    private static class StarAfterAdvice implements AfterAdvice {
        @Override
        public void after() {
            System.out.println("收款");
        }
    }
}

public interface Star {
    // 唱歌
    void singSong();
    // 跳舞
    void dancing();
}


public class RealStar implements Star {
    //...
    @Override
    public void dancing() {
        System.out.println("周杰伦在跳舞...");
    }
}

public class Client {
    @Test
    public void client() {
        Star star = (Star) new ProxyFactory(new StarBeforeAdvice(), new RealStar(), new StarAfterAdvice()).createProxy();
        star.singSong();
        star.dancing();
    }
    // ...
}

/**
 * @author jifang
 * @since 16/1/3下午6:25.
 */
public interface Brand {
    String brand();
}
class Lenovo implements Brand {
    @Override
    public String brand() {
        return "联想";
    }
}
class Dell implements Brand {
    @Override
    public String brand() {
        return "戴尔";
    }
}
class Hasee implements Brand {
    @Override
    public String brand() {
        return "神州";
    }
}