反向控制：协调以来对象之间合作的责任从对象自身中转移出来，这就是像Spring这样的轻量级框架所起的作用。
创建系统组件之间关联的动作叫做装配。在Spring应用系统中，BeanFactory负责装载Bean的定义并把它们装配起来。
IOC使软件组件松散连接成为可能，AOP让你能够捕捉系统中经常使用的功能，把它转化为组件。
系统由很多组件组成，每个组件负责一部分功能，然而，这些组件也经常带有一些除了核心功能之外的附带功能。系统服务如日志、事务管理和安全经常融入到一些其他功能模块中。这些系统服务通常叫做交叉业务，这是因为它们总是分布在系统的很多组件中。通过将这些业务分布在多个组件中，给你的代码引入了双重复杂性。
ProxyFactoryBean当需要容器提供一个对象时，它返回一个针对这个对象所有调用的拦截器对象，在调用目标对象方法之前给AOP对象一个先执行的机会。AOP对象执行完毕后，控制权转回给这个对象，由它执行自己的任务。
尽管Spring的AOP支持可以被用于从系统核心罗集中分离交叉任务，但是它的主要任务是作为Spring对声明式事务支持的基础，Spring带有很多为JavaBean提供声明式事务策略的切面。Acegi安全系统为JavaBean提供了声明式安全服务。
posted @
2009-10-14 10:48 王永庆 阅读(182) |
评论 (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 王永庆 阅读(244) |
评论 (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 王永庆 阅读(195) |
评论 (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 王永庆 阅读(287) |
评论 (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 王永庆 阅读(198) |
评论 (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 王永庆 阅读(144) |
评论 (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 王永庆 阅读(133) |
评论 (0) |
编辑 收藏
现在众多应用服务器以及开源社区中，都提供了完备的数据库连接池组件，选择采用这些成熟稳定的组件作为我们产品开发的基石，在绝大多数情况下是比选择自己实现更聪明的决策，还是那句老话：不要重复发明轮子。
2个数据库连接池组件：
Apache Jakarta Commons DBCP
Proxool
JDBC程序设计中，除了数据库连接，还有另外一个往往被忽视的重要资源---Statement,通过使用PreparedStatement,在绝大多数情况下可以有效提高重复性数据库调用的性能。
借助Connection实例创建PreparedStatement对象相当简单，不过简单的表面下却隐藏着复杂的实现，当PreparedStatement对象创建时，数据库会对这个PreparedStatement中的SQL进行语法检查、语义分析、选择优化器并创建相应的执行计划。
目前，无论是商业领域还是开源社区，都已经为我们提供了丰富且久经考验的持久层组件，使用这些成熟可靠的已有实现可以在很大程度上规避技术上的风险，同时迅速提高应用系统开发的劳动产出比。
第一章终于看完了，好累，每看一次，每次的感觉都不一样。方兴未艾。
posted @
2009-10-08 11:25 王永庆 阅读(137) |
评论 (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 王永庆 阅读(197) |
评论 (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 王永庆 阅读(150) |
评论 (0) |
编辑 收藏