Java基础-Java中23种设计模式之常用的设计模式

　　　　　　　　　　　　　　　　Java基础-Java中23种设计模式之常用的设计模式

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

一.设计模式分类

　　设计模式是针对特定场景给出的专家级的解决方案。总的来说设计模式分为以下三大类：

1>.创建型模式

　　答：共五种，即工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

2>.结构型模式

　　答：共七种，即适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

3>.行为型模式

　　答：共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

　　其实还有两类，并发型模式和线程池模式。用一个图片来整体描述一下：（下图引用自：https://blog.csdn.net/doymm2008/article/details/13288067）

二.设计模式的六大原则

1>.开闭原则（Open Close Principle）

　　答：开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

2>.里氏代换原则（Liskov Substitution Principle）

　　答：里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3>.依赖倒转原则（Dependence Inversion Principle）

　　答：这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4>.接口隔离原则（Interface Segregation Principle）

　　答：这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5>.迪米特法则（最少知道原则）（Demeter Principle）

　　答：为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6>.合成复用原则（Composite Reuse Principle）

　　答：原则是尽量使用合成/聚合的方式，而不是使用继承。

三.单例模式（Singleton）

 1>.什么是单例模式

　　单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

　　　　第一：某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

　　　　第二：省去了new操作符，降低了系统内存的使用频率，减轻垃圾回收(GC)机制压力。

　　　　第三：有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

　　单利模式是非常简单的一种设计模式，它大致分为两种：即懒汉式和饿汉式。

2>.懒汉式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.singletonMode;

 public class GarbageBox {

     //定义一个GarbageBox的引用变量
     private static GarbageBox instance = null ;

     //私有构造方法，防止被实例化
     private GarbageBox(){
     }

     //定义获取实例的方法
     public static GarbageBox getInstance(){
         //先判断instance是否为空，如果不为空就直接返回instance对象
         if(instance != null){
             return instance ;
         }
         //通过同步代码块的方式进行加锁
         synchronized (GarbageBox.class){
             //仍需要判断instance是否为空，目的是为了防止多个线程产生不同的对象！
             if(instance == null){
                 instance = new GarbageBox() ;
             }
         }
         return instance;
     }

     public void sayHello(){
         System.out.println("Hello Wold,My name is yinzhengjie !");
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.singletonMode;

 public class Demo {
     public static void main(String[] args) {
         GarbageBox instance = GarbageBox.getInstance();
         instance.sayHello();
     }
 }

 /*
 以上代码输出结果如下：
 Hello Wold,My name is yinzhengjie !
  */

调用方式（Demo.java 文件内容）

3>.饿汉式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.singletonMode;

 public class GarbageBox {
     //直接在成员变量中定义GarbageBox对象
     private static GarbageBox instance = new GarbageBox();

     //直接就将该对象返回给调用者
     public static GarbageBox getInstance() {
         return instance;
     }

     public void sayHello() {
         System.out.println("Hello Wold,My name is yinzhengjie !");
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.singletonMode;

 public class Demo {
     public static void main(String[] args) {
         GarbageBox instance = GarbageBox.getInstance();
         instance.sayHello();
     }
 }

 /*
 以上代码输出结果如下：
 Hello Wold,My name is yinzhengjie !
  */

调用方式（Demo.java 文件内容）

四.装饰者模式

1>.什么是装饰者模式

　　答：顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

2>.装饰器模式的应用场景

　　第一：需要扩展一个类的功能。

　　第二：动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

　　装饰者模式在Java中的I/O流中应用的非常广泛！缺点：产生过多相似的对象，不易排错！

3>.实现代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.decorativePattern;

 public class Worker {
     String Name;
     int Age ;

     public Worker(String name, int age) {
         Name = name;
         Age = age;
     }

     public Worker() { }

     public void EarnMoney() {
         System.out.printf("%s 开始挣钱啦！",this.Name);
         try {
             Thread.sleep(5000);     //此处模拟挣钱需要花费的时间
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("打工完毕");
     }

     public String getName() {
         return Name;
     }

     public void setName(String name) {
         Name = name;
     }

     public int getAge() {
         return Age;
     }

     public void setAge(int age) {
         Age = age;
     }
 }

被装饰者（Worker.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.decorativePattern;

 public class WrappedWorker extends Worker {
     private Worker worker;

     public WrappedWorker( Worker worker) {
         this.worker = worker;
     }

     //新增功能，给Worker的EarnMoney方法添加计时功能！
     public void EarnMoney() {
         long start = System.currentTimeMillis();
         worker.EarnMoney();
         long end = System.currentTimeMillis();
         System.out.printf("调用Worker的EarnMoney方法共计用时为:%d\n",(end - start));
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.decorativePattern;

 public class Demo {
     public static void main(String[] args) {
         Worker yinzhengjie = new Worker("yinzhengjie", 18);
         WrappedWorker yzj = new WrappedWorker(yinzhengjie);
         yzj.EarnMoney();
     }
 }

调用方式（Demo.java 文件内容）

五.工厂（factory）模式

1>.什么是工厂模式

　　工厂方法模式分为以下三种：

　　　　第一：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

　　　　第二：多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，

　　　　第三：静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

2>.普通工厂模式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public interface Animal {
     public void eat();
 }

接口类（Animal.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Cat implements Animal {
     public void eat() {
         System.out.println("猫吃鱼！");
     }
 }

实现接口类(Cat.java 文件内容)

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Dog implements Animal {
     public void eat() {
         System.out.println("狗吃肉！");
     }
 }

实现接口类（Dog.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class AnimalFactory {
     public Animal produce(String type){
         if (type.equals("cat")){
             return new Cat();
         }else if (type.equals("dog")){
             return new Dog();
         }else {
             System.out.println("输入的类型不匹配");
             return null;
         }
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Demo {
     public static void main(String[] args) {
         AnimalFactory animal = new AnimalFactory();
         Animal cat = animal.produce("cat");
         Animal dog = animal.produce("dog");
         cat.eat();
         dog.eat();
     }
 }

调试方式（Demo.java 文件内容）

3>.多个工厂方法模式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public interface Animal {
     public void eat();
 }

接口类（Animal.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Cat implements Animal {
     public void eat() {
         System.out.println("猫吃鱼！");
     }
 }

实现接口类(Cat.java 文件内容)

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Dog implements Animal {
     public void eat() {
         System.out.println("狗吃肉！");
     }
 }

实现接口类（Dog.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 /**
  *      多个工厂方法模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工
  * 厂方法模式是提供多个工厂方法，分别创建对象。
  */
 public class AnimalFactory {
     public Animal produceCat(){
         return new Cat();
     }

     public Animal produceDog(){
         return new Dog();
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Demo {
     public static void main(String[] args) {
         AnimalFactory animal = new AnimalFactory();
         Animal cat = animal.produceCat();
         Animal dog = animal.produceDog();
         cat.eat();
         dog.eat();
     }
 }

 /*
 以上代码执行结果如下：
     猫吃鱼！
     狗吃肉！
  */

调试方式（Demo.java 文件内容）

4>.静态工厂方法模式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public interface Animal {
     public void eat();
 }

接口类（Animal.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Cat implements Animal {
     public void eat() {
         System.out.println("猫吃鱼！");
     }
 }

实现接口类(Cat.java 文件内容)

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Dog implements Animal {
     public void eat() {
         System.out.println("狗吃肉！");
     }
 }

实现接口类（Dog.java 文件内容）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 /**
  * 静态工厂方法模式是将的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
  */
 public class AnimalFactory {
     public static Animal produceCat(){
         return new Cat();
     }

     public static Animal produceDog(){
         return new Dog();
     }
 }

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.java.factory;

 public class Demo {
     public static void main(String[] args) {
         Animal cat = AnimalFactory.produceCat();
         Animal dog = AnimalFactory.produceDog();

         cat.eat();
         dog.eat();
     }
 }

 /*
 以上代码执行结果如下：
     猫吃鱼！
     狗吃肉！
  */

调试方式（Demo.java 文件内容）

　　总体来说，凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

 六.适配器

1>.什么是适配器

2>.

3>.

七.动态代理模式

1>.什么是动态代理模式

　　我们知道装饰者模式可以静态装饰一个类，通过装饰者模式可以给被装饰者添加附加功能，但是如果添加的功能特别多，你需要不断的继承这个类，这样可能会导致类的暴增！为了解决这个问题，引入了与装饰者类功能相似的动态代理模式。动态代理模式的核心就是代理器实现接口的方法，实现类也实现接口的方法。用户在调用接口的功能时，是通过代理器来访问的，而代理器则只需要调用实现目标类对象即可，并在代理器的invoke方法中添加相应的业务逻辑即可！画了一个草图如下：

2>.动态代理的应用场景

　　如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

　　　　第一：修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

　　　　第二：就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

　　使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

3>.动态代理案例展示

　　假设有两个接口，分别为WelcomeService和WelcomeService2，有一个实现类WelcomeServiceImpl，它实现了WelcomeService和WelcomeService2这两个接口。现在我们需要通过动态代理模式来统计实现这两个接口中每个方法的执行时间。具体代码如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.proxy;

 /**
  * 代理接口
  */
 public interface WelcomeService {
     public void sayHell();
 }

WelcomeService.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.proxy;

 public interface WelcomeService2 {
     public abstract void eat();
     public abstract void work();
 }

WelcomeService2.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.proxy;

 /**
  * 目标类
  */
 public class WelcomeServiceImpl implements WelcomeService,WelcomeService2{
     public void sayHell() {
         System.out.println("hi ,I'm Yinzhengjie !!!");
     }

     public void eat() {
         System.out.println("I like food !");
     }

     public void work() {
         System.out.println("I'm a programmer");
     }
 }

WelcomeServiceImpl.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.proxy;

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

 public class ProxyDemo {
     public static void main(String[] args) {

         //目标对象
         final WelcomeServiceImpl target = new WelcomeServiceImpl() ;

         //系统类加载器
         ClassLoader loader = ClassLoader.getSystemClassLoader() ;

         //代理接口集合
         Class[] inters = {
                 WelcomeService.class,
                 WelcomeService2.class
         } ;

         //处理器
         InvocationHandler h =  new InvocationHandler() {
             //proxy表示被代理的对象，method表示被代理对象的方法，args表示被代理对象的方法中的参数
             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                 //附加行为，即统计每个方法的执行时间！
                 long start = System.nanoTime();
                 //调用目标对象的方法，
                 Object ret = method.invoke(target , args) ;
                 long end = System.nanoTime();
                 System.out.printf("执行该方法用时为:[%d]纳秒\n",(end-start));
                 //返回目标对象方法的返回值
                 return ret;
             }
         } ;

         //得到代理对象obj
         Object obj = Proxy.newProxyInstance(loader, inters, h);
         //由于代理对象也实现了WelcomeService和WelcomeService2接口，因此我们只需要向下转型就可以调用各个接口对应的方法！同时也会触发附加计时功能！
         WelcomeService ws = (WelcomeService)obj;
         WelcomeService2 ws2 = (WelcomeService2)obj;
         //调用各个接口的方法
         ws.sayHell();
         ws2.work();
         ws2.eat();
     }
 }

 /*
 以上代码执行结果如下：
 hi ,I'm Yinzhengjie !!!
 执行该方法用时为:[188156]纳秒
 I'm a programmer
 执行该方法用时为:[30720]纳秒
 I like food !
 执行该方法用时为:[25920]纳秒
  */

八.池化模式

九.

十.

　　Java中的设计模式有很多种，我就举例十中装饰者模式，在多的我也用不到了。如果你觉得上面的几种设计模式很简单，并且对其它的设计模式很感兴趣，可参考：https://blog.csdn.net/doymm2008/article/details/13288067。接下来我们利用上面已经学到的模式编写我们自己的数据源吧（DataSource）。

 1>.实验环境（新建表）

2>.Java代码如下

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import java.sql.*;
 import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.Executor;

 /**
  * 连接适配器
  */
 public abstract class MyConnectionAdaptor implements Connection{
     public Statement createStatement() throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql) throws SQLException {
         return null;
     }

     public CallableStatement prepareCall(String sql) throws SQLException {
         return null;
     }

     public String nativeSQL(String sql) throws SQLException {
         return null;
     }

     public void setAutoCommit(boolean autoCommit) throws SQLException {

     }

     public boolean getAutoCommit() throws SQLException {
         return false;
     }

     public void commit() throws SQLException {

     }

     public void rollback() throws SQLException {

     }

     public void close() throws SQLException {

     }

     public boolean isClosed() throws SQLException {
         return false;
     }

     public DatabaseMetaData getMetaData() throws SQLException {
         return null;
     }

     public void setReadOnly(boolean readOnly) throws SQLException {

     }

     public boolean isReadOnly() throws SQLException {
         return false;
     }

     public void setCatalog(String catalog) throws SQLException {

     }

     public String getCatalog() throws SQLException {
         return null;
     }

     public void setTransactionIsolation(int level) throws SQLException {

     }

     public int getTransactionIsolation() throws SQLException {
         return 0;
     }

     public SQLWarning getWarnings() throws SQLException {
         return null;
     }

     public void clearWarnings() throws SQLException {

     }

     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
         return null;
     }

     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
         return null;
     }

     public Map<String, Class<?>> getTypeMap() throws SQLException {
         return null;
     }

     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {

     }

     public void setHoldability(int holdability) throws SQLException {

     }

     public int getHoldability() throws SQLException {
         return 0;
     }

     public Savepoint setSavepoint() throws SQLException {
         return null;
     }

     public Savepoint setSavepoint(String name) throws SQLException {
         return null;
     }

     public void rollback(Savepoint savepoint) throws SQLException {

     }

     public void releaseSavepoint(Savepoint savepoint) throws SQLException {

     }

     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
         return null;
     }

     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
         return null;
     }

     public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
         return null;
     }

     public Clob createClob() throws SQLException {
         return null;
     }

     public Blob createBlob() throws SQLException {
         return null;
     }

     public NClob createNClob() throws SQLException {
         return null;
     }

     public SQLXML createSQLXML() throws SQLException {
         return null;
     }

     public boolean isValid(int timeout) throws SQLException {
         return false;
     }

     public void setClientInfo(String name, String value) throws SQLClientInfoException {

     }

     public void setClientInfo(Properties properties) throws SQLClientInfoException {

     }

     public String getClientInfo(String name) throws SQLException {
         return null;
     }

     public Properties getClientInfo() throws SQLException {
         return null;
     }

     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
         return null;
     }

     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
         return null;
     }

     public void setSchema(String schema) throws SQLException {

     }

     public String getSchema() throws SQLException {
         return null;
     }

     public void abort(Executor executor) throws SQLException {

     }

     public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {

     }

     public int getNetworkTimeout() throws SQLException {
         return 0;
     }

     public <T> T unwrap(Class<T> iface) throws SQLException {
         return null;
     }

     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return false;
     }
 }

MyConnectionAdaptor.java（连接适配器模式）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import javax.sql.DataSource;
 import java.io.PrintWriter;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.util.logging.Logger;

 /**
  *  数据源适配器
  */
 public abstract class MyDataSourceAdaptor implements DataSource {
     public Connection getConnection() throws SQLException {
         return null;
     }

     public Connection getConnection(String username, String password) throws SQLException {
         return null;
     }

     public <T> T unwrap(Class<T> iface) throws SQLException {
         return null;
     }

     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return false;
     }

     public PrintWriter getLogWriter() throws SQLException {
         return null;
     }

     public void setLogWriter(PrintWriter out) throws SQLException {

     }

     public void setLoginTimeout(int seconds) throws SQLException {

     }

     public int getLoginTimeout() throws SQLException {
         return 0;
     }

     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
         return null;
     }
 }

MyDataSourceAdaptor.java（数据源适配器模式）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.util.LinkedList;

 /**
  * 单模模式实现连接池
  */
 public class ConnectionPool {

     private static ConnectionPool instance ;

     private LinkedList<Connection> idles = new LinkedList<Connection>() ;

     private LinkedList<Connection> busies = new LinkedList<Connection>() ;

     //最大连接数
     private static int MAX = 3 ;

     //最小连接数
     private static int MIN = 2 ;

     private String user = "root" ;
     private String pass = "yinzhengjie" ;
     private String url = "jdbc:mysql://localhost:5200/yinzhengjie" ;

     private ConnectionPool(){
         try {
             Class.forName("com.mysql.jdbc.Driver");
             initPool() ;
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }

     /**
      * 初始化连接池 , 开启min连接数
      */
     private void initPool() {
         for(int i = 0 ; i < MIN ; i ++){
             Connection conn = openNewConnection() ;
             idles.add(conn) ;
         }
     }

     /**
      *
      */
     public static ConnectionPool getInstance(){
         if(instance != null){
             return instance ;
         }

         synchronized (ConnectionPool.class){
             if(instance == null){
                 instance = new ConnectionPool() ;
             }
         }
         return instance ;
     }

     /**
      * 开启新连接
      */
     private Connection openNewConnection(){
         try {
             Connection conn = DriverManager.getConnection(url , user ,pass) ;
             return new MyConnection(conn , this) ;
         } catch (SQLException e) {
             e.printStackTrace();
         }
         return null ;
     }

     /**
      * 将连接释放回池子中
      */
     public synchronized void backToPool(MyConnection myConnection) {
         busies.remove(myConnection) ;
         idles.add(myConnection) ;
         this.notifyAll();
     }

     /**
      * 从连接池中获取连接
      */
     public synchronized Connection getConnection() {
         //有可用连接
         if(!idles.isEmpty()){
             Connection conn = idles.remove(0) ;
             busies.add(conn) ;
             return conn ;
         }
         //没有到达最大值
         if(busies.size() < MAX){
             Connection conn = openNewConnection();
             busies.add(conn) ;
             return conn ;
         }

         while(idles.isEmpty()){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         Connection conn = idles.remove(0);
         busies.add(conn);
         return conn;
     }
 }

ConnectionPool.java（单模模式实现连接池）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;

 /**
  * 连接使用适配器和装饰模式
  */
 public class MyConnection  extends MyConnectionAdaptor{

     private Connection conn ;

     private ConnectionPool pool ;

     public MyConnection(Connection conn , ConnectionPool pool ){
         this.conn = conn ;
         this.pool = pool ;
     }

     public PreparedStatement prepareStatement(String sql) throws SQLException {
         return conn.prepareStatement(sql);
     }

     public void setAutoCommit(boolean autoCommit) throws SQLException {
         conn.setAutoCommit(autoCommit);
     }

     public void commit() throws SQLException {
         conn.commit();
     }

     public void rollback() throws SQLException {
         conn.rollback();
     }

     public void close() throws SQLException {
         pool.backToPool(this) ;
     }

     public void setTransactionIsolation(int level) throws SQLException {
         conn.setTransactionIsolation(level);
     }
 }

MyConnection.java（连接使用适配器和装饰模式）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import java.sql.Connection;
 import java.sql.SQLException;

 /**
  * 自定义数据源
  */
 public class MyDataSource extends MyDataSourceAdaptor{
     private ConnectionPool pool ;

     public MyDataSource(){
         pool = ConnectionPool.getInstance() ;
     }

     public Connection getConnection() throws SQLException {
         return pool.getConnection() ;
     }

 }

MyDataSource.java（自定义数据源）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.datasource;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;

 /**
  * 执行以下代码之前，需要启动MySQL，并在yinzhengjie数据下创建user表，否则会抛异常哟！创建表的SQL语句如下:
  * create table if not exists users(id int primary key auto_increment,name varchar(20) , age int) ;
  */
 public class MyDataSoureApp {
     static int i = 0 ;
     public static void main(String[] args) throws SQLException {
         final MyDataSource ds = new MyDataSource();

         for(i = 0 ; i < 10 ; i ++){
             new Thread(){
                 public void run() {
                     try {
                         Connection conn = ds.getConnection();
                         String sql = "insert into users(name ,age) values(?,?)";
                         PreparedStatement ppst = conn.prepareStatement(sql);
                         ppst.setString(1, "yinzhengjie" + i);
                         ppst.setInt(2, i + 10);
                         ppst.executeUpdate();
                         ppst.close();
                         conn.close();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }

                 }
             }.start();

         }
     }
 }

3>.测试结果