7种结构型模式之:享元模式(Flyweight)与数据库连接池的原理

解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象。比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象。如果有一个1M的文本,那么字母是何其的多,如果每个字母都定义一个对象那么内存早就爆了。那么如果要是每个字母都共享一个对象,那么就大大节约了资源。
  在Flyweight模式中,由于要产生各种各样的对象,所以在Flyweight(享元)模式中常出现Factory模式。Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个对象存储池(Flyweight Pool)来存放内部状态的对象。Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多,下面举个例子:
  先定义一个抽象的Flyweight类:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package Flyweight;  
  2. public abstract class Flyweight{  
  3.  public abstract void operation();  
  4. }  

实现一个具体类:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package Flyweight;  
  2. public class ConcreteFlyweight extends Flyweight{  
  3.  private String string;  
  4.  public ConcreteFlyweight(String str){  
  5.   string = str;  
  6.  }  
  7.  public void operation()  
  8.  {  
  9.   System.out.println("Concrete---Flyweight : " + string);  
  10.  }  
  11. }  

实现一个工厂方法类:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package Flyweight;  
  2. import java.util.Hashtable;  
  3. public class FlyweightFactory{  
  4.  private Hashtable flyweights = new Hashtable();//----------------------------1  
  5.  public FlyweightFactory(){}  
  6.  public Flyweight getFlyWeight(Object obj){  
  7.   Flyweight flyweight = (Flyweight) flyweights.get(obj);//----------------2  
  8.   if(flyweight == null){//---------------------------------------------------3  
  9.    //产生新的ConcreteFlyweight  
  10.    flyweight = new ConcreteFlyweight((String)obj);  
  11.    flyweights.put(obj, flyweight);//--------------------------------------5  
  12.   }  
  13.   return flyweight;//---------------------------------------------------------6  
  14.  }  
  15.  public int getFlyweightSize(){  
  16.   return flyweights.size();  
  17.  }  
  18. }  

这个工厂方法类非常关键,这里详细解释一下:
  在1处定义了一个Hashtable用来存储各个对象;在2处选出要实例化的对象,在6处将该对象返回,如果在Hashtable中没有要选择的对象,此时变量flyweight为null,产生一个新的flyweight存储在Hashtable中,并将该对象返回。
  最后看看Flyweight的调用:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. package Flyweight;  
  2. import java.util.Hashtable;  
  3. public class FlyweightPattern{  
  4.  FlyweightFactory factory = new FlyweightFactory();   
  5.  Flyweight fly1;  
  6.  Flyweight fly2;  
  7.  Flyweight fly3;  
  8.  Flyweight fly4;  
  9.  Flyweight fly5;  
  10.  Flyweight fly6;  
  11.  /** *//** Creates a new instance of FlyweightPattern */  
  12.  public FlyweightPattern(){  
  13.   fly1 = factory.getFlyWeight("Google");  
  14.   fly2 = factory.getFlyWeight("Qutr");  
  15.   fly3 = factory.getFlyWeight("Google");  
  16.   fly4 = factory.getFlyWeight("Google");  
  17.   fly5 = factory.getFlyWeight("Google");  
  18.   fly6 = factory.getFlyWeight("Google");  
  19.  }  
  20.  public void showFlyweight(){  
  21.   fly1.operation();  
  22.   fly2.operation();  
  23.   fly3.operation();  
  24.   fly4.operation();  
  25.   fly5.operation();  
  26.   fly6.operation();  
  27.   int objSize = factory.getFlyweightSize();  
  28.   System.out.println("objSize = " + objSize);  
  29.  }  
  30.  public static void main(String[] args){  
  31.   System.out.println("The FlyWeight Pattern!");  
  32.   FlyweightPattern fp = new FlyweightPattern();  
  33.   fp.showFlyweight();  
  34.  }  
  35. }  


下面是运行结果:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. Concrete---Flyweight : Google  
  2. Concrete---Flyweight : Qutr  
  3. Concrete---Flyweight : Google  
  4. Concrete---Flyweight : Google  
  5. Concrete---Flyweight : Google  
  6. Concrete---Flyweight : Google  
  7. objSize = 2  


 我们定义了6个对象,其中有5个是相同的,按照Flyweight模式的定义“Google”应该共享一个对象,在实际的对象数中我们可以看出实际的对象却是只有2个。

总结:
  Flyweight(享元)模式是如此的重要,因为它能帮你在一个复杂的系统中大量的节省内存空间。在Java语言中,String类型就是使用了享元模式。String对象是final类型,对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的,JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a="abc",其中"abc"就是一个字符串常量。

熟悉java的应该知道下面这个例子:

[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. String a = "hello";  
  2. String b = "hello";  
  3. if(a == b)  
  4.  System.out.println("OK");  
  5. else  
  6.  System.out.println("Error");  

输出结果是:OK。可以看出if条件比较的是两a和b的地址,也可以说是内存空间
核心总结,可以共享的对象,也就是说返回的同一类型的对象其实是同一实例,当客户端要求生成一个对象时,工厂会检测是否存在此对象的实例,如果存在那么直接返回此对象实例,如果不存在就创建一个并保存起来,这点有些单例模式的意思。通常工厂类会有一个集合类型的成员变量来用以保存对象,如hashtable,vector等。在java中,数据库连接池,线程池等即是用享元模式的应用。


----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

数据库连接池的原理

                                                                                                                                                                         

     这次我们采取技术演进的方式来谈谈数据库连接池的技术出现过程及其原理,以及当下最流行的开源数据库连接池jar包。

一.早期我们怎么进行数据库操作

       1.原理:一般来说,Java应用程序访问数据库的过程是:

   ①装载数据库驱动程序;

   ②通过jdbc建立数据库连接;

   ③访问数据库,执行sql语句;

   ④断开数据库连接。

       2.代码 

       // 查询所有用户

[java] view plain copy
 print?
  1. Public void FindAllUsers(){  
  2.        //1、装载sqlserver驱动对象  
  3.        DriverManager.registerDriver(new SQLServerDriver());               
  4.        //2、通过JDBC建立数据库连接  
  5.        Connection con =DriverManager.getConnection("jdbc:sqlserver://192.168.2.6:1433;DatabaseName=customer""sa""123");              
  6.        //3、创建状态  
  7.        Statement state =con.createStatement();             
  8.        //4、查询数据库并返回结果  
  9.        ResultSet result =state.executeQuery("select * from users");             
  10.        //5、输出查询结果  
  11.        while(result.next()){  
  12.               System.out.println(result.getString("email"));  
  13.        }              
  14.        //6、断开数据库连接  
  15.        result.close();  
  16.        state.close();  
  17.        con.close();  
  18.  }  

3.分析

       程序开发过程中,存在很多问题:首先,每一次web请求都要建立一次数据库连接。建立连接是一个费时的活动,每次都得花费0.05s1s的时间,而且系统还要分配内存资源。这个时间对于一次或几次数据库操作,或许感觉不出系统有多大的开销。可是对于现在的web应用,尤其是大型电子商务网站,同时有几百人甚至几千人在线是很正常的事。在这种情况下,频繁的进行数据库连接操作势必占用很多的系统资源,网站的响应速度必定下降,严重的甚至会造成服务器的崩溃。不是危言耸听,这就是制约某些电子商务网站发展的技术瓶颈问题。其次,对于每一次数据库连接,使用完后都得断开。否则,如果程序出现异常而未能关闭,将会导致数据库系统中的内存泄漏,最终将不得不重启数据库。还有,这种开发不能控制被创建的连接对象数,系统资源会被毫无顾及的分配出去,如连接过多,也可能导致内存泄漏,服务器崩溃。

       上述的用户查询案例,如果同时有1000人访问,就会不断的有数据库连接、断开操作:

 

       通过上面的分析,我们可以看出来,“数据库连接”是一种稀缺的资源,为了保障网站的正常使用,应该对其进行妥善管理。其实我们查询完数据库后,如果不关闭连接,而是暂时存放起来,当别人使用时,把这个连接给他们使用。就避免了一次建立数据库连接和断开的操作时间消耗。原理如下:

二. 技术演进出来的数据库连接池

       由上面的分析可以看出,问题的根源就在于对数据库连接资源的低效管理。我们知道,对于共享资源,有一个很著名的设计模式:资源池(resource pool)。该模式正是为了解决资源的频繁分配﹑释放所造成的问题。为解决上述问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况,为系统开发﹑测试及性能调整提供依据。

       我们自己尝试开发一个连接池,来为上面的查询业务提供数据库连接服务:

       ①   编写class 实现DataSource 接口

       ②   class构造器一次性创建10个连接,将连接保存LinkedList

       ③   实现getConnection   LinkedList返回一个连接

       ④   提供将连接放回连接池中方法

 

       1、连接池代码       

[java] view plain copy
 print?
  1. public class MyDataSource implements DataSource {  
  2.           //链表 --- 实现栈结构  
  3.           privateLinkedList<Connection> dataSources = new LinkedList<Connection>();  
  4.   
  5.           //初始化连接数量  
  6.           publicMyDataSource() {  
  7.                  //一次性创建10个连接  
  8.                  for(int i = 0; i < 10; i++) {  
  9.                         try {  
  10.                            //1、装载sqlserver驱动对象  
  11.                            DriverManager.registerDriver(new SQLServerDriver());  
  12.                            //2、通过JDBC建立数据库连接  
  13.                            Connection con =DriverManager.getConnection(  
  14.                               "jdbc:sqlserver://192.168.2.6:1433;DatabaseName=customer""sa""123");  
  15.                            //3、将连接加入连接池中  
  16.                            dataSources.add(con);  
  17.                         } catch (Exception e) {  
  18.                            e.printStackTrace();  
  19.                         }  
  20.                  }  
  21.           }  
  22.   
  23.           @Override  
  24.           publicConnection getConnection() throws SQLException {  
  25.                  //取出连接池中一个连接  
  26.                  finalConnection conn = dataSources.removeFirst(); // 删除第一个连接返回  
  27.                  returnconn;  
  28.           }  
  29.   
  30.           //将连接放回连接池  
  31.           publicvoid releaseConnection(Connection conn) {  
  32.                  dataSources.add(conn);  
  33.                  }  
  34.    }  


       2、使用连接池重构我们的用户查询函数       

[java] view plain copy
 print?
  1. //查询所有用户  
  2. Public void FindAllUsers(){  
  3.        //1、使用连接池建立数据库连接  
  4.        MyDataSource dataSource = new MyDataSource();  
  5.        Connection conn =dataSource.getConnection();          
  6.        //2、创建状态  
  7.        Statement state =con.createStatement();             
  8.        //3、查询数据库并返回结果  
  9.        ResultSet result =state.executeQuery("select * from users");             
  10.        //4、输出查询结果  
  11.        while(result.next()){  
  12.               System.out.println(result.getString("email"));  
  13.        }              
  14.        //5、断开数据库连接  
  15.        result.close();  
  16.        state.close();  
  17.        //6、归还数据库连接给连接池  
  18.        dataSource.releaseConnection(conn);  
  19.  }  

       这就是数据库连接池的原理,它大大提供了数据库连接的利用率,减小了内存吞吐的开销。我们在开发过程中,就不需要再关心数据库连接的问题,自然有数据库连接池帮助我们处理,这回放心了吧。但连接池需要考虑的问题不仅仅如此,下面我们就看看还有哪些问题需要考虑。

三.连接池还要考虑更多的问题

       1、并发问题

       为了使连接管理服务具有最大的通用性,必须考虑多线程环境,即并发问题。这个问题相对比较好解决,因为java语言自身提供了对并发管理的支持,使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字,如:

      publicsynchronized connection getconnection()

 

       2、多数据库服务器和多用户

       对于大型的企业级应用,常常需要同时连接不同的数据库(如连接Oraclesybase)。如何连接不同的数据库呢?我们采用的策略是:设计一个符合单例模式的连接池管理类,在连接池管理类的唯一实例被创建时读取一个资源文件,其中资源文件中存放着多个数据库的url地址等信息。根据资源文件提供的信息,创建多个连接池类的实例,每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字,通过不同的名字来管理不同的连接池。

       对于同一个数据库有多个用户使用不同的名称和密码访问的情况,也可以通过资源文件处理,即在资源文件中设置多个具有相同url地址,但具有不同用户名和密码的数据库连接信息。

 

       3、事务处理

       我们知道,事务具有原子性,此时要求对数据库的操作符合“all-all-nothing”原则即对于一组sql语句要么全做,要么全不做。

       java语言中,connection类本身提供了对事务的支持,可以通过设置connectionautocommit属性为false 然后显式的调用commitrollback方法来实现。但要高效的进行connection复用,就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现,这种方法可以大大降低事务管理的复杂性。

 

       4、连接池的分配与释放

       连接池的分配与释放,对系统的性能有很大的影响。合理的分配与释放,可以提高连接的复用度,从而降低建立新连接的开销,同时还可以加快用户的访问速度。

       对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时,系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长(通过容器的顺序存放实现)的那个连接分配给他(实际是先做连接是否有效的判断,如果可用就分配给用户,如不可用就把这个连接从空闲池删掉,重新检测空闲池是否还有连接);如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数(maxconn如果没有达到,就新建一个连接,如果已经达到,就等待一定的时间(timeout)。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户,如果等待时间超过预定时间timeout 则返回空值(null)。系统对已经分配出去正在使用的连接只做计数,当使用完后再返还给空闲池。对于空闲连接的状态,可开辟专门的线程定时检测,这样会花费一定的系统开销,但可以保证较快的响应速度。也可采取不开辟专门线程,只是在分配前检测的方法。

 

       5、连接池的配置与维护

       连接池中到底应该放置多少连接,才能使系统的性能最佳?系统可采取设置最小连接数(minconn)和最大连接数(maxconn)来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多,则系统启动就慢,但创建后系统的响应速度会很快;如果创建过少,则系统启动的很快,响应起来却慢。这样,可以在开发时,设置较小的最小连接数,开发起来会快,而在系统实际使用时设置较大的,因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目,具体设置多少,要看系统的访问量,可通过反复测试,找到最佳点。

       如何确保连接池中的最小连接数呢?有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测,如果发现连接数量小于最小连接数,则补充相应数量的新连接以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。

四.实际开发中有成熟的开源连接池供我们使用

       理解了连接池的原理就可以了,没有必要什么都从头写一遍,那样会花费很多时间,并且性能及稳定性也不一定满足要求。事实上,已经存在很多流行的性能优良的第三方数据库连接池jar包供我们使用。如:

       1.Apache commons-dbcp 连接池

        下载:http://commons.apache.org/proper/commons-dbcp/

 

       2.c3p0 数据库连接池

        下载:http://sourceforge.net/projects/c3p0/



阅读更多
换一批

没有更多推荐了,返回首页