反向控制：協調以來對象之間合作的責任從對象自身中轉移出來，這就是像Spring這樣的輕量級框架所起的作用。
創建系統組件之間關聯的動作叫做裝配。在Spring應用系統中，BeanFactory負責裝載Bean的定義并把它們裝配起來。
IOC使軟件組件松散連接成為可能，AOP讓你能夠捕捉系統中經常使用的功能，把它轉化為組件。
系統由很多組件組成，每個組件負責一部分功能，然而，這些組件也經常帶有一些除了核心功能之外的附帶功能。系統服務如日志、事務管理和安全經常融入到一些其他功能模塊中。這些系統服務通常叫做交叉業務，這是因為它們總是分布在系統的很多組件中。通過將這些業務分布在多個組件中，給你的代碼引入了雙重復雜性。
ProxyFactoryBean當需要容器提供一個對象時，它返回一個針對這個對象所有調用的攔截器對象，在調用目標對象方法之前給AOP對象一個先執行的機會。AOP對象執行完畢后，控制權轉回給這個對象，由它執行自己的任務。
盡管Spring的AOP支持可以被用于從系統核心羅集中分離交叉任務，但是它的主要任務是作為Spring對聲明式事務支持的基礎，Spring帶有很多為JavaBean提供聲明式事務策略的切面。Acegi安全系統為JavaBean提供了聲明式安全服務。
posted @
2009-10-14 10:48 王永慶 閱讀(186) |
評論 (0) |
編輯 收藏
Spring的所有模塊都是建立在核心容器之上的。容器規定如何創建和配置Bean，以及很多Spring的具體細節。
核心容器：Spring核心容器為Spring框架提供了基礎功能。在這個模塊中你會找到BeanFactory,它是所有基于Spring框架系統的核心。BeanFactory采用工廠模式來實現IOC,它將系統的配置和依賴關系從代碼中獨立出來。
Application Context模塊
上下文模塊是使Spring成為框架的原因。這個模塊擴展了BeanFactory.這個模塊提供了很多企業級服務如電子郵件服務、JNDI訪問、EJB繼承、遠程調用以及定時服務，并且支持與模板框架的集成。
Spring的AOP模塊
在AOP模塊中，Spring對面向切面提供了豐富的支持。這個模塊是為Spring應用系統開發切面的基礎。
JDBC抽象及DAO模塊
Spring的JDBC和DAO模塊把這些樣板式的代碼抽象出來，讓你的數據庫代碼變得簡單明了。
O/R映射集成模塊
Spring不想實現自己的ORM解決方案，但是它為許多流行的ORM框架做了鉤子程序，包括Hibernate、JDO和iBatis映射，Spring的事務管理支持所有這些ORM框架以及JDBC.
Spring的web模塊
web上下文模塊建立在應用上下文模塊的基礎之上，提供了適合web系統的上下文。
Spring MVC框架
Spring為web系統提供了全功能的MVC框架。
應用：
使用<property>元素表示設置屬性值。使用<constructor-arg>元素表示通過構造方法設置參數
public class HelloApp{
public static void main(String[] args)throws Exception{
BeanFactory factory = new XmlBeanFactory(new FileInputStream("hello.xml"));
GreetingService greetingService = (GreetingService)factory.getBean("greetingSercice");
greetingService.sayGreeting();
}
}
這里的BeanFactory就是Spring容器。將hello.xml文件載入容器后，main()方法調用BeanFactory的getBean()方法來得到問候服務的引用。
反向控制：控制的什么方面被反轉了，獲得依賴對象的方式反轉了。
依賴注入：任何重要的系統都需要至少2個相互合作的類來完成業務邏輯，通常，每個對象都要自己負責得到它的合作(依賴)對象。你會發現，這樣會導致代碼耦合度高而且難以測試。
使用IOC，對象的依賴都是在對象創建時由負責協調系統中各個對象的外部實體提供的。
耦合是一個雙頭怪物，一方面，緊密耦合的代碼難以測試，難以重用，難以理解，帶來典型的摧毀大堤bug.另一方面，完全沒有耦合的代碼什么也做不了。為了做一些有意義的工作，類必須以某種方式知道其他類的存在。耦合是必須的，但需要小心管理。
減少耦合的一個通常的做法就是將具體實現隱藏在接口下面，這樣具體實現類的替換不會影響到引用類。
posted @
2009-10-12 21:53 王永慶 閱讀(249) |
評論 (0) |
編輯 收藏
Spring以反向控制和AOP這2種先進的設計理念為基礎。統一了應用對象的查找、配置和生命周期管理，分離了業務與基礎服務中的不同關注點。
在業務層，Spring為企業級應用提供了一個相當全面的解決方案。這個方案包括數據庫持久化支持、聲明式事務管理、遠程服務訪問，以及JMS、Mail、定時等多種企業服務。
在WEB層，Spring為企業級應用提供了一個MVC框架，該框架與其他流行的Web框架相比毫不遜色；而且Spring可以集成各種Web框架和視圖技術。
Java可以實現使用分布的模塊來建立一個復雜的系統，他們為Applet而來，為組件而留。
復雜的系統往往需要一些JavaBeans無法直接提供的服務，如事務支持、安全、分布計算等，所以在1998年3月，Sun發不了EJB1.0規范。它把Java組件擴展到服務器端，提供了很多必須的企業級服務，但是它不像原來的JavaBean那樣簡單了。
現在Java組件開發重新煥發青春，很多新技術包括AOP和Ioc為JavaBean提供了很多EJB才擁有的強大功能，為JavaBeans提供了類似于EJB那樣的聲明式編碼模型，同事沒有帶來任何像EJB那樣的復雜問題。
首先為什么要使用EJB,如果沒有使用實體Bean,所以沒有使用持久化服務，同樣如果沒有使用遠程服務和安全服務。就沒有必要使用EJB.EJB之所以復雜是因為EJB是為解決復雜問題而設計的，如分布式對象和遠程事務的問題。
作為一個開發者，你始終應該為你的系統找到最好的設計而不是實現。Spring背后的理念是讓你的系統按照你的需求盡量簡單。如果你需要的只是使用簡單Java對象來提供一些支持透明事務的服務的話，使用Spring就足夠了。
使用Spring,你的Bean通過接口與它的關聯類通信。因為不依賴任何特殊實現，所以采用Spring的系統是松耦合的，易測試的和易維護的。
因為開發Spring應用系統使用的都是JavaBeans,所以測試很簡單。你不需要啟動J2EE容器，因為你測試的是一個POJO.
Spring是為簡化企業級系統開發而誕生的。使用Spring,你可以用簡單的JavaBeans來實現那些以前只有EJB才能實現的功能。
Spring是一個輕量級的Ioc和AOP容器框架
輕量級：Spring是非侵入式的，基于Spring開發的系統中的對象一般不依賴于Spring的類。
反向控制：使用IOC，對象是被動接收依賴類而不是自己主動去找。可以將IOC理解為JNDI的反轉-對象不是從容器中查找它的依賴類，而是容器在實例化對象的時候主動將它的依賴類注入給它。
面向切面：通過將業務邏輯從系統服務中分離出來，實現了內聚開發。系統對象只做它們該做的-業務邏輯，它們不負責其他系統問題(如日志和事務支持)。
容器：Spring是一個容器，是因為它包含并且管理系統對象的生命周期和配置。
框架：Spring實現了使用簡單的組件配置組合成一個復雜的系統。
posted @
2009-10-12 21:09 王永慶 閱讀(199) |
評論 (0) |
編輯 收藏
Hibernate基礎配置選項主要圍繞SessionFactory展開：
在hibernate.cfg.xml配置文件中，我們可以通過mapping節點配置需要加載的Hibernate映射文件，如果選用了propertie
形式的配置文件(hibernate.properties),由于缺乏相應的配置條目，這時候就需要通過編碼進行加載：
Configuration cfg = new Configuration().addFile("TUser.hbm.xml").addClass(com.redsage.db.entity.TGroup.class)
1、添加位于CLASSPATH根目錄下的TUser.hbm.xml映射文件
2、以class形式加載映射實體類com.readsage.db.entity.TGroup
在Hibernate中，可以設置2種數據庫訪問策略：一種是根據指定的JDBC參數進行數據庫連接，由Hibernate來完成連接管
理過程：另外一種則是通過JNDI完成數據庫連接獲取。
1、數據庫適配器
hibernate.dialect net.sf.hibernate.dialect.MySQLDialect
2、數據庫JDBC驅動類
hibernate.connection.driver_class com.mysql.jdbc.Driver
JNDI配置：
hibernate.connection.datasource jdbc/test
3、數據庫URL
hibernate.connection.url jdbc:mysql://localhost/sample
4、數據庫用戶名
hibernate.connection.username root
5、數據庫密碼
hiberante.connection.password
當我們使用JDBC方式訪問數據庫時，可以為其指定數據庫連接池實現，目前Hibernate支持4種連接池實現組件：
C3P0:
hibernate.c3p0.max_size 2
hibernate.c3p0.min_size 2
//獲得連接的超時時間,如果超過這個時間,會拋出異常，單位毫秒
hibernate.c3p0.timeout 5000
//最大的PreparedStatement的數量
hibernate.c3p0.max_statements 100
//每隔3000秒檢查連接池里的空閑連接 ，單位是秒
hibernate.c3p0.idle_test_period 3000
//當連接池里面的連接用完的時候，C3P0一下獲取的新的連接數
hibernate.c3p0.acquire_increment 2
//每次都驗證連接是否可用
hibernate.c3p0.validate false
hibernate.connection.provider_class net.sf.hibernate.connection.C3p0ConnectionProvider
解釋：
hibernate.c3p0.timeout，這個表示連接池中的連接對象在多長時間沒有使用過后，就應該被銷毀
hibernate.c3p0.idle_test_period ，這個表示連接池檢測線程多長時間檢測一次池內的所有鏈接對象是否超時
注意：連接對象自己不會把自己從連接池中移除，而是專門有一個線程按照一定的時間間隔
(hibernate.c3p0.idle_test_period )來做這件事，這個線程通過比較連接對象最后一次被使用時間和當前時間的時間差來
和hibernate.c3p0.timeout做對比，進而決定是否銷毀這個連接對象。
DBCP:
//連接池的最大活動個數
hibernate.dbcp.maxActive 100
//當連接池中的連接已經被耗盡的時候，DBCP將怎樣處理( 0 = 失敗, 1 = 等待, 2= 增長)
hibernate.dbcp.whenExhaustedAction 1
//最大等待時間
hibernate.dbcp.maxWait 120000
//沒有人用連接的時候，最大閑置的連接個數。
hibernate.dbcp.maxIdle 10
hibernate.dbcp.ps.maxActive 100
hibernate.dbcp.ps.whenExhaustendAction 1
hibernate.dbcp.ps.maxWait 120000
hibernate.dbcp.ps.maxIdle 10
//給出一條簡單的sql語句進行驗證
hibernate.dbcp.validationQuery select 1 from dual
//在取出連接時進行有效驗證
hibernate.dbcp.testOnBorrow true
//在放回連接時進行有效驗證
hibernate.dbcp.testOnreturn false
//Hibernate已經實現了DBCP Provider實現，別忘了在下面的鍵值去掉＃字符
hibernate.connection.provider_class net.sf.hibernate.connection.DBCPConnectionProvider
posted @
2009-10-11 11:11 王永慶 閱讀(292) |
評論 (0) |
編輯 收藏
在Hibernate中，session負責完成對象的持久化操作，而Hibernate Session與之Hibernate,相當于JDBCConnection與之JDBC
1、初始化Hibernate配置管理類Configuration
Configuration config = new Configuration().configure();
利用CLASSPATH中的默認配置文件hibernate.cfg.xml構建Configuration實例。
2、通過Configuration類實例創建Session的工廠類SessionFactory
SessionFactory sessionFactory = config.buildSessionFactory();
3、通過SessionFactory得到Session實例
session = sessionFactory.openSession();
通過這個Session實例，就可以對對象進行持久化操作
Configuration類負責管理Hibernate的配置信息，Hibernate運行時需要獲取一些底層實現的基本信息，包括：
數據庫URL
數據庫用戶名
數據庫用戶密碼
數據庫JDBC驅動類
數據庫適配器，用于對特定數據庫提供支持。
Configuration類一般只有在獲取SessionFactory時需要涉及，當SessionFactory實例創建之后，由于配置信息已經由hibernate綁定在返回的SessionFactory之中，因此一般情況下無需在對其操作。
如果不希望使用默認的hibernate.cfg.xml文件作為配置文件，還有如下方法：
File file = new File("c:\\sample\\myhiernate.xml");
Configuration config = new Configuration().configure(file);
SessionFactory負責創建Session實例：
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
SessionFactory一旦構造完成，即被賦予特定的配置信息。如果需要使用基于改動后的config實例的SessionFactory,需要從config重新構建一個SessionFactory實例。
SessionFactory中保存了對應當前數據庫配置的所有映射關系，同時也負責維護當前的二級緩存和Statement Pool.由此可見，SessionFactory的創建過程必然非常復雜，代價高昂，而這也就意味著，我們應該在系統設計中充分考慮到SessionFactory的重用策略。由于SessionFactory是線程安全的，可以多個線程并發調用，大多數情況下，一個應用中針對一個數據庫共享一個SessionFactory實例即可。
Session作為貫穿Hibernate的持久化管理器核心，提供了眾多持久化方法，如save、update、delete,find等。通過這些方法，可透明的完成對象的增刪改查。同事，Hibernate Session的設計是非線程安全的，也就是說，一個Session實例同時只可一個線程使用，同一個Session實例的多線程并發調用將導致難以預知的錯誤
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
Save操作：
//新增名為"Emma"的用戶記錄
TUser user = new TUser();
user.setName("Emma");
session.save(user);
Get操作：
//假設T_User表中存在id=1的記錄
TUser user = (TUser)session.get(TUser.class,new Integer(1));
delete操作：
//假設T_User表中存在id=1的記錄
TUser user = (TUser)session.get(TUser.class,new Integer(1));
session.delete(user);
//也可以通過HQL指定刪除條件(Hibernate2)
session.delete("from TUser where id=1");
//通過Query接口進行基于HQL的刪除操作(Hibernate3)
String hql = "delete TUser where id=1";
Query query = session.createQuery(hql);
query.executeUpdate();
Find(Hibernate2)操作
String hql = "form TUser where name='Erica'";
List userList = session.find(hql);
Hibernate3中的Session接口取消了find方法，我們必須通過Query或Criteria接口進行數據查詢
通過Query接口進行數據查詢：
String hql = "from TUser user where user.name like ?";
Query query = session.createQuery(hql);
query.setParameter(0,"Cartier");
List list = query.list();
Iterator it = list.iterator();
while(it.hasNext()){
TUser user = (TUser)it.next();
System.out.println(user.getName);
}
通過Criteria接口進行數據查詢：
Criteria criteria = session.createCriteria(TUser.class);
criteria.add(Expression.eq("name","Cartier"));
List list = criteria.list();
Iterator it = list.iterator();
while(it.hasNext()){
TUser user = (TUser)it.next();
System.out.println(user.getName());
}
Query面向HQL和Native SQL，而Criteria則提供了面向對象的查詢模式。
posted @
2009-10-11 10:33 王永慶 閱讀(203) |
評論 (0) |
編輯 收藏
Hibernate對JDBC進行了妥善封裝，會自動根據對象和表之間的映射關系，將對象操作轉換為SQL加以執行。
public class HibernateTest extends TestCase{
Session session = null;
/**
* JUnit中setUp方法在TestCase初始化的時候會自動調用一般用于初始化公用資源
*/
protected void setUp(){
try{
/**
*采用hibernate.properties或者hibernate.cfg.xml
*配置文件的初始化代碼：
*Configuration config = new Configuration();
*config.addClass(Tuser.class);
*/
//采用hiberante.cfg.xml配置文件
//1、configuration的初始化方式
//2、xml文件中已經定義了Mapping文件，因此無需在編碼導入
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
session = sessionFactory.openSession();
}catch(HibernateException e){
e.printStackTrace();
}
}
/**
*與setUp方法相對應，JUnitTestCase執行完畢時，會自動調用tearDown方法
*一般用于資源釋放
*/
protected void tearDown(){
try{
session.close();
}catch(HibernateException e){
e.printStackTrace();
}
}
/**
*對象持久化
*/
public void testInsert(){
Transaction tran = null;
try{
tran = session.beginTransaction();
Tuser user = new Tuser();
user.setName("Emma");
session.save(user);
tran.commit();
}catch(HiberanteException e){
e.printStackTrance();
}
}
}
posted @
2009-10-09 15:07 王永慶 閱讀(150) |
評論 (0) |
編輯 收藏
Hibernate基礎代碼包括POJO類和Hibernate映射文件。
POJO在Hibernate語義中理解為數據庫表所對應的Domain Object.字面上來講就是無格式普通Java對象，可以簡單的理解為一個不包含邏輯代碼的值對象(Value Object簡稱VO),從數據層面上看，POJO作為數據實體的對象化表現形式，也成為實體類。
Hibernate是一種對象-關系型數據映射組件，它使用映射文件將對象與關系型數據相關聯。在Hibernate中，映射文件通常以.hbm.xml作為后綴。
配置文件名默認為hibernate.cfg.xml,Hibernate初始化期間會自動在CLASSPATH中尋找這個文件，并讀取其中的配置信息，為后期數據庫操作做好準備。
一個典型的hibernate.cfg.xml配置文件如下：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">
<hibernate-configuration>
<session-factory>
<!--數據庫URL-->
<property name="hibernate.connection.url">
jdbc:mysql://localhost/sample
</property>
<!--數據庫JDBC驅動-->
<property name="hibernate.connection.driver_class">
org.git.mm.mysql.Driver
</property>
<!--數據庫用戶名-->
<property name="hibernate.connection.username">
User
</property>
<!--數據庫密碼-->
<property name="hibernate.connection.password">
Mypass
</property>
<!--dialect,每個數據庫都有其對應的Dialect以匹配其平臺特性-->
<property name="hibernate.dialect.MySQLDialect">
net.sf.hibernate.dialect.MySQLDialect
</property>
<!--是否將運行期生成的SQL輸出到日志以供調試-->
<property name="hibernate.show_sql">
True
</property>
<!--是否使用數據庫外連接-->
<property name="hibernate.use_outer_join">
True
</property>
<!--事務管理類型，這里我們使用JDBC Transaction-->
<property name="hibernate.transaction.factory_class">
net.sf.hibernate.transaction.JDBCTransactionFactory
</property>
<!--映射文件配置，注意配置文件名必須包含其相對于根的全路徑-->
<mapping resource="com/redsage/quickstart/Tuser.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Hibernate3中對包名進行了修改(net.sf.hibernate=>org.hibernate)如果采用hibernate3除了包名修改外，DTD文件也要做對應修改http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd
在hibernate項目的SRC目錄下，創建內容同上的hibernate.cfg.xml文件。
Hibernate采用Apache common logging,并結合Apache log4j作為日志輸出組件。
posted @
2009-10-09 14:36 王永慶 閱讀(138) |
評論 (0) |
編輯 收藏
現在眾多應用服務器以及開源社區中，都提供了完備的數據庫連接池組件，選擇采用這些成熟穩定的組件作為我們產品開發的基石，在絕大多數情況下是比選擇自己實現更聰明的決策，還是那句老話：不要重復發明輪子。
2個數據庫連接池組件：
Apache Jakarta Commons DBCP
Proxool
JDBC程序設計中，除了數據庫連接，還有另外一個往往被忽視的重要資源---Statement,通過使用PreparedStatement,在絕大多數情況下可以有效提高重復性數據庫調用的性能。
借助Connection實例創建PreparedStatement對象相當簡單，不過簡單的表面下卻隱藏著復雜的實現，當PreparedStatement對象創建時，數據庫會對這個PreparedStatement中的SQL進行語法檢查、語義分析、選擇優化器并創建相應的執行計劃。
目前，無論是商業領域還是開源社區，都已經為我們提供了豐富且久經考驗的持久層組件，使用這些成熟可靠的已有實現可以在很大程度上規避技術上的風險，同時迅速提高應用系統開發的勞動產出比。
第一章終于看完了，好累，每看一次，每次的感覺都不一樣。方興未艾。
posted @
2009-10-08 11:25 王永慶 閱讀(147) |
評論 (0) |
編輯 收藏
Decorator模式：簡單來講，就是通過一個Decorator對原有對象進行封裝，同事實現與原有對象相同的接口，從而得到一個基于原有對象的，對既有接口的增強型實現。
首先引入一個ConnectionDecorator類：
public class ConnectionDecorator implements Connection{
Connection dbconn;
public ConnectionDecorator(Connnection conn){
this.dbconn = conn;//實際從數據庫獲得的Connection引用
}
public void close()throws SQLException{
this.dbconn.close();
}
public void commit()throws SQLException{
this.dbconn.commit();//調用實際連接的commit方法
}
}
ConnectionDecorator類實際上是對傳入的數據庫連接加上了一個外殼，它實現了java.sql.Connection接口，不過本身并沒有實現任何實際內容，只是簡單的把方法的實現委托給運行期實際獲得的Connection實例，而從外部看，ConnectionDecorator與普通的Connection實例沒有什么區別。
public class PooledConnection extends ConnectionDecorator implements Connection{
private ConnectionPool connPool;
public PooledConnection(ConnectionPool pool,Connection conn){
super(conn);
connPool = pool;
}
//覆蓋close方法，將數據庫連接返回連接池中，而不是直接關閉連接
public void close()throws SQLException{
connPool.releaseConnection(this.dbconn);
}
}
動態代理：
public class ConnectionHandler implements InvocationHandler{
Connection dbconn;
ConnectionPool pool;
public ConnectionHandler(ConnectionPool connPool){
this.pool = connPool;
}
//將動態代理綁定到指定Connection
public Connection bind(Connection conn){
this.dbconn = conn;
Connection proxyConn = (Connection)Proxy.newProxyInstance(conn.getClass().getClassLoader(),conn.getClass().getInterfaces(),this);
return proxyConn;
}
//方法調用攔截器
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
Object obj =null;
if("close".equals(method.getName())){
pool.releaseConnection(dbconn);
}else{
obj = method.invoke(dbconn,args);
}
return obj;
}
}
ConnectionHandler connHandler = new ConnectionHandler(this);
return connHandler.bind(conn);
可以看到，基于Dynamic Proxy模式的實現相對Decorator更加簡潔明了。
posted @
2009-10-08 10:02 王永慶 閱讀(205) |
評論 (0) |
編輯 收藏
無論是怎樣的應用系統，都無法脫離對資源的管理和使用。而對于持久層而言，資源的合理管理和調度則顯得尤為重要。
資源管理機制的設計對于系統整體表現往往可以產生關鍵性影響。同時，除去性能之外，良好的資源管理機制還能為系統的伸縮性、可維護性帶來相當的提升。
Connection Pool:數據庫連接池技術帶來的優勢
1、資源重用
由于數據庫連接得以重用，避免了頻繁創建、釋放連接引起的大量性能開銷。在減少系統消耗的基礎上，另一方面也增進了系統運行環境的平穩性。
2、更快的系統響應速度
數據庫連接池在初始化過程中，往往已經創建了若干數據庫連接池置于池中備用。此時連接的初始化工作均已完成。對于業務請求處理而言，直接利用現有可用連接，避免了數據庫連接初始化和釋放過程的時間開銷，從而縮減了系統整體響應時間。
3、新的資源分配手段
對于多應用共享同一數據庫的系統而言，可在應用層通過數據庫連接池的配置，實現某一應用最大可用數據庫連接數的限制，避免某一應用獨占所有數據庫資源
4、統一的連接管理，避免數據庫連接泄露
在較為完備的數據庫連接池實現中，可根據預先的連接占用超時設定，強制收回被占用連接。從而避免了常規數據庫連接操作中可能出現的資源泄露。
public class DBConnectionPool implements ConnectionPool{
private statci Vector pool;
private final int POOL_MAX_SIZE = 20;
//獲取數據庫連接，如果當前池中有可用連接，則將池中最后一個返回，如果沒有，則新建一個返回
public synchronized Connection getConnection()throws DBException{
if(pool==null){
pool = new Vector();
}
Connection conn;
if(pool.isEmpty()){
conn = createConnection();
}else{
int last_idx = pool.size()-1;
conn = (Connection)pool.get(last_idx);
pool.remove(pool.get(last_idx));
}
return conn;
}
//將使用完畢的數據庫連接放回備用池中
public synchronized void releaseConnection(Connection conn){
if(pool.size()>POOL_MAX_SIZE){
try{
conn.close();
}catch(SQLException e){
e.printStackTrace();
}
}else{
pool.add(conn);
}
}
//讀取數據庫配置信息，從數據庫連接池中獲得數據庫連接
private static Connection createConnection()throws DBException{
Connection conn;
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:oracle","personal","personal");
return conn;
}cacth(ClassNotFoundException e){
throw new DBException("ClassNotFoundException when loading JDBC Driver");
}
}
}
posted @
2009-10-07 15:26 王永慶 閱讀(155) |
評論 (0) |
編輯 收藏