现在spring和hibernate是否还应归属于轻量级框架已经有疑义了,保留意见,关注中
解决方案 »
- hibernate二级缓存问题
- 请教HttpSessionListener和HttpSessionBindingListener的区别
- 如何理解Session
- 问一个关于intellij中生成webservice程序的问题
- 项目管理的问题，散分
- 如何将smartupload封装成类 由servlet调用实现
- 请教Hibernate中的多表查询问题。
- 在WSAD上建《精通EJB2》书上中的BMP例子为什么会有错误??
- 忘记了怎么在jsp里包含多个servlet了
- 在JavaBean中如何获取WEB的根目录？
- 已经安装了JDK16和TOMCAT6.0,但是无发显示欢迎页,请问应该怎么办.
- 大家谈谈portal的整合
就和它名字的暗示一样，org.springframework.jdbc.core包里定义了提供核心功能的类。 其中有各种SQLExceptionTranslator和DataFieldMaxValueIncrementer的实现以及一个用于JdbcTemplate的DAO基础类。
org.springframework.jdbc.datasource包里有一个用以简化数据源访问的工具类， 以及各种数据源的简单实现，以被用来在J2EE容器之外不经修改地测试JDBC代码。 这个工具类提供了从JNDI获得连接和可能用到的关闭连接的静态方法。 它支持绑定线程的连接，比如被用于DataSourceTransactionManager。
接着，org.springframework.jdbc.object包里是把关系数据库的查询， 更新和存储过程封装为线程安全并可重用对象的类。 这中方式模拟了JDO，尽管查询返回的对象理所当然的“脱离”了数据库连接。 这个JDBC的高层抽象依赖于org.springframework.jdbc.core包中所实现的底层抽象。
最后在org.springframework.jdbc.support包中你可以找到 SQLException的转换功能和一些工具类。
在JDBC调用中被抛出的异常会被转换成在定义org.springframework.dao包中的异常。 这意味着使用Spring JDBC抽象层的代码不需要实现JDBC或者RDBMS特定的错误处理。 所有的转换后的异常都是unchecked，它允许你捕捉那些你可以恢复的异常， 并将其余的异常传递给调用者。
其实复制粘贴我很在行一. 引言 Spring是一个轻量级的应用程序框架。在许多情况中，Spring都能够良好地代换传统的由Java EE应用程序服务器所提供的服务。Spring既是综合性的也是模块化的。基于其分层架构，它能够使开发者灵活地单独使用其任何一部分。Spring由许 多模块组成，例如IoC容器，AOP，MVC，持久性，DAO和remoting。这些模块都是相当松耦合的：其中，一些模块的使用根本不需要另一些模 块。以前，简直还没有象Spring应用程序这样的:你可以选择使用一些，大多数，或所有的Spring框架支持的组件来构建你的应用程序。 Spring框架所提供的JDBC支持与其它Spring部分并非是紧耦合的，这极有利于代码的可维护性。本文将向你展示任何直接使用JDBC(也即是，不通过一些O/R映射框架本身使用JDBC)的应用程序是如何从Spring中受益的。 二. 传统型JDBC 传统型JDBC有许多积极的方面使之在许多J2SE和J2EE应用程序开发中占有重要地位。然而，也有一些特征使其难于使用： ・ 开发者需要处理大量复杂的任务和基础结构，例如大量的try-catch-finally-try-catch块。 ・ 应用程序需要复杂的错误处理以确定连接在使用后被正确关闭，这样以来使得代码变得冗长，膨胀，并且重复。 ・ JDBC中使用了极不明确性的SQLException异常。 ・ JDBC没有引入具体的异常子类层次机制。 相应于任何一种错误，都只是抛出SQLException异常-无论它来源于JDBC驱动程序还是来源于数据库，这使得程序员很难理解到底是哪里实际出 现了错误。例如，如果SQL对象是无效的或已经被锁定，那么将抛出一个SQLException异常。调试这样的异常需要一定的时间来检查SQL状态值和 错误代码。更有甚者，SQL状态值和错误代码的含义在各种数据库之间都有些差别。 事实证明，编写JDBC代码并不是一项容易的工作-存在大量的重复性的工作。为了说明问题，下面是一个例子-使用传统型JDBC来从数据库中得到一个可用任务的列表。
package com.spring.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;
public class TraditionalJDBC {
public Vector getTasksNames() {
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
Vector task = new Vector();
try {
con = getConnection();
pstmt = con.prepareStatement( "select TASKNAME from tasks");
rs = pstmt.executeQuery();
while (rs.next()) {
task.add(rs.getString(1));
}
} catch (SQLException e) {
System.out.println(e);
} finally {
try {
rs.close();
pstmt.close();
con.close();
} catch (SQLException e1) {
System.out.println(e1);
}
}
return task;
}
private Connection getConnection()throws SQLException {
try {
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
return DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl"，
"scott"，"tiger");
} catch (SQLException sqle) {
System.out.println(sqle);
return null;
}
}
public static void main(String[] args) {
TraditionalJDBC obj = new TraditionalJDBC();
Vector task = obj.getTasksNames();
for (int i = 0; i ＜ task.size(); i++) {
System.out.println(task.elementAt(i));
}
}
} 除了实际查询数据库的SQL代码外，上面的示例中需要巨大数量的例程代码。getConnection()方法与我们的任务无关，而即使是getTasksNames()方法也仅包含特定于当前任务的两行代码。剩下的都是一些普通的复杂的任务代码。 JDBC的许多积极方面使得它在许多J2SE和J2EE应用程序中仍然占有重要地位。然而，正如你所见，有一些特征使其比我们可能想像的要更难于使用。 JDBC这些乏味并且有时挫败人性的特征已经导致出现了许多公共的可以利用的JDBC抽象框架(例如SQLExecutor和Apache Jakarta Commons DBUtils)，还有数不清的自家生产性JDBC应用程序框架。一种公共的可以利用的JDBC抽象框架正是Spring框架的JDBC抽象。
三. Spring JDBC简介 Spring所提供的JDBC抽象框架由四个不同的包组成： ・ 核心包包含JdbcTemplate。这个类是一个基础类之一-由Spring框架的JDBC支持提供并使用。 ・ 数据源包是实现单元测试数据库存取代码的重要的一部分。它的DriverManagerDataSource能够以一种类似于你已经习惯于JDBC中的用 法：只要创建一个新的DriverManagerDataSource并且调用setter方法来设置DriverClassName，Url， Username和Password。 ・ 对象包中包含类，用于描述RDBMS查询、更改和存储过程为线程安全的、可重用的对象。 ・ 支持包-你可以从这里找到SQLException翻译功能和一些工具类。 1) 模板设计模式 Spring JDBC实现模板设计模式，这意味着，代码中的重复的复杂的任务部分是在模板类中实现的。这种方式简化了JDBC的使用，因为由它来处理资源的创建和释 放。这有助于避免普通错误，例如忘记关闭连接等。它执行核心JDBC工作流任务，如语句创建和执行，而让应用程序代码来提供SQL并且提取结果。 2) Spring JDBC异常处理 Spring框架特别强调在传统型JDBC编程中所面临的与下列方案有关的问题： ・ Spring提供一个抽象异常层，把冗长并且易出错误的异常处理从应用程序代码移到由框架来实现。框架负责所有的异常处理;应用程序代码则能够专注于使用适当的SQL提取结果。 ・ Spring提供了一个重要的异常类层次，以便于你的应用程序代码中可以使用恰当的SQLException子类。 借助于一个抽象异常层，我们成功地实现了数据库独立性而不必改变异常处理。例如，如果你把你的数据库从PostgreSQL改变为Oracle，那么你 不必把异常处理从OracleDataException改变到PostgresDataException。Spring能够捕获应用程序服务器特定的 异常并抛出一个Spring数据异常。 当处理异常时，Spring检查来自一个数据库连接的元数据可用性以决定数据库产品。它使用这 种知识来把SQLException映射到其自己异常层次中的具体的异常上。因此，我们不需要担心专门性的SQL状态或错误代码问题；Spring的数据 存取异常不是JDBC特定的，因此你的DAO不必绑定到JDBC（由于其可能抛出的异常）。
package com.spring.jdbc;
import java.util.List;
public interface TasksDAO {
public List getTasksNames();
} 接下来，我们提供针对于TasksDAO接口的一种实现。
package com.spring.jdbc;
import java.util.Iterator;
import java.util.List;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.RowMapperResultReader;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class TasksJdbcDAO extends JdbcDaoSupport
implements TasksDAO {
public List getTasksNames() {
JdbcTemplate jt = getJdbcTemplate();
return jt.query("select TASKNAME from tasks"，
new RowMapperResultReader(new TasksRowMapper()));
}
class TasksRowMapper implements RowMapper {
public Object mapRow(ResultSet rs， int index)
throws SQLException {
return rs.getString(1);
}
}
public static void main(String[] args)throws Exception {
ApplicationContext ctx = new ClassPathXmlApplicationContext("SpringConfig.xml");
DataSource ds =(DataSource) ctx.getBean("dataSourceDBDirect");
TasksJdbcDAO taskDao = new TasksJdbcDAO();
taskDao.setDataSource(ds);
Iterator tskIter = taskDao.getTasksNames().iterator();
while (tskIter.hasNext()) {
System.out.println(tskIter.next().toString());
}
}
} 在上面的例子中，普通的和复杂的任务代码已经被移交到框架中。还应注意，借助于Spring JDBC，我们如何利用控制反转(IoC)容器来提供一种DataSource-我们仅把它注入到TasksJdbcDAO对象中。 控制反转背后的概念通常被表达为"不要找我，让我找你好了"。IoC把一些任务移交到了框架中，并且脱离出了应用程序代码。不是让你的代码调用一个传统 的类库，而是一个IoC框架调用你的代码。存在于许多API中的生命周期回调，例如相应于会话EJB的setSessionContext()方法，正是 展示了这种方法。 DataSource必须被注入到这个类中（或者其超类中），这是通过setDataSource()方法实现的。 所有配置细节都远离了业务逻辑或客户端代码；这增加你的应用程序的松耦合性并因此而提高了程序的可测试性和可维护性。作为选择，我们还能在JNDI或 servlet容器中建立一个DataSource，并用编程方式来检索它，然后把它注入到DAO对象中。下面是一个你可以使用的示例Spring bean配置文件-SpringConfig.xml：
＜?xml version="1.0" encoding="UTF-8" ?＞
＜!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="dataSourceDBDirect"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
destroy-method="close"＞
＜property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/＞
＜property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/＞
＜property name="username" value="scott"/＞
＜property name="password" value="tiger"/＞
＜/bean＞
＜/beans＞ 这个文件指示Spring bean容器实例化一个dataSourceDBDirect bean-它基于org.springframework.jdbc.datasource.DriverManagerDataSource类创建。
1) 基于Spring JDBC实现一个业务层 我们已经看到了一个简单的使用Spring JDBC的例子，在这种情况下，它从Spring BeanFactory(控制反转容器)中得到极少的帮助。现在，我们将超越这个简单的例子。让我们来探讨一下如何基于Spring JDBC实现业务服务。首先，让我们创建一个客户端-一个为终端用户提供输出的应用程序。该客户端使用了一个服务，一个遵守下面的Service接口的业 务服务：
package com.spring.jdbc;
import java.util.List;
public interface Service {
public List getTasksNames();
public void setTasksDao(TasksDAO taskDAO);
}
package com.spring.jdbc;
import java.util.List;
public class ServiceImpl implements Service{
TasksDAO taskDAO;
public void setTasksDao(TasksDAO taskDAO)
{
this.taskDAO=taskDAO;
}
public List getTasksNames()
{
List tasks = taskDAO.getTasksNames();
return tasks;
}
} 你应该已经注意到，该服务需要一个TasksJdbcDAO。反过来，这个对象实现了TasksDAO接口。因此，我们将通过BeanFactory来 把DAO注入到该服务中。在此，我们碰巧有一个TasksJdbcDAO类-bean工厂可以使用它来实现这一目的。然而，既然这个类派生于 JdbcDaoSupport，那么我们知道我们需要注入一个DataSource或让bean工厂为我们注入该DataSource。现在这个bean 配置文件看上去如下所示：
＜?xml version="1.0" encoding="UTF-8" ?＞
＜!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="dataSourceDBDirect"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
destroy-method="close"＞
＜property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/＞
＜property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/＞
＜property name="username" value="scott"/＞
＜property name="password" value="tiger"/＞
＜/bean＞
＜bean id="tasksDAO" class="com.spring.jdbc.TasksJdbcDAO"＞
＜property name="dataSource"＞
＜ref local="dataSourceDBDirect"/＞
＜/property＞
＜/bean＞
＜bean id="service" class="com.spring.jdbc.ServiceImpl"＞
＜property name="tasksDao"＞
＜ref local="tasksDAO"/＞
＜/property＞
＜/bean＞
＜/beans＞ 我们看到服务bean使得tasksDao bean被注入-它反过来又使dataSourceDBDirect对象被注入。当我们请求服务bean时，我们通过一个具有DataSource的 DAO得到它。至此，一切就绪。因此，当客户端存取bean容器以得到服务对象时，会发生什么呢？该bean容器实例化并且注入一个DataSource 和一个TasksDAO-在把服务返回到客户端之前。现在，我们的客户端变得相当简单了。它需要与BeanFactory进行通讯，"抓住"一个服务对象 并处理它：
package com.spring.jdbc;
import java.util.Iterator;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Client extends RuntimeException {
public static void main(String[] args) throws Exception {
ApplicationContext ctx = new ClassPathXmlApplicationContext("SpringConfig.xml");
Service service = (Service)ctx.getBean("service");
Iterator tskIter = service.getTasksNames().iterator();
while (tskIter.hasNext()) {
System.out.println(tskIter.next().toString());
}
}
} 你必须注意，在此Client派生于RuntimeException异常类。Spring抛出了RuntimeExceptions而不是检查的异常 -RuntimeExceptions不应该被捕获。由于在你的代码中捕获所有异常是一种复杂的任务，所以Spring开发者决定抛出 RuntimeExceptions以便实现如果你不捕获一个异常的话，那么你的应用程序将会中断而且用户会得到该应用程序异常。使用它们的第二个理由 是，绝大多数异常都是不可恢复的，因此你的应用程序逻辑不能以任何方式来再次处理它们。
五. 另外的优点 除了上面描述的Spring框架带给JDBC中的优点外，与你的JDBC应用程序一起使用Spring框架还存在另外一些优点。这些优点包括： ・ Spring框架提供了 org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor接口和这个接口的 一些实现(例如SimpleNativeJdbcExtractor)。对于经由一个Oracle连接或ResultSet访问Oracle特征的情况来 说，这些内容是非常有用的。 ・ 对于创建oracle.sql.BLOB(二进制大型对象)和oracle.sql.CLOB(字符大型对象)实例来说，Spring提供了类org.springframework.jdbc.support.lob.OracleLobHandler。 ・ Spring提供的OracleSequenceMaxValueIncrementer类提供了一个Oracle序列的下一个值。它有效地提供了与你直 接使用下列命令："select someSequence.nextval from dual"（其中，someSequence是在Oracle数据库中的你的序列的名字）所提供的一样的信息。这种方法的优点是， DataFieldMaxValueIncrementer接口可以用于一个DAO层次中而不必紧密地耦合于Oracle特定的实现。 六. 结论 本文集中讨论了使用Spring来编写更可维护的和更不易出现错误的JDBC代码。Spring JDBC提供了一些优点，例如更为干净的代码，更好的异常与资源处理，并且能够集中于业务问题而不是复杂的任务代码。另外，值得注意的是，使用 Spring框架能够使用极少的代码就可以实现实质上与传统型JDBC相同的功能。
就和它名字的暗示一样，org.springframework.jdbc.core包里定义了提供核心功能的类。 其中有各种SQLExceptionTranslator和DataFieldMaxValueIncrementer的实现以及一个用于JdbcTemplate的DAO基础类。
org.springframework.jdbc.datasource包里有一个用以简化数据源访问的工具类， 以及各种数据源的简单实现，以被用来在J2EE容器之外不经修改地测试JDBC代码。 这个工具类提供了从JNDI获得连接和可能用到的关闭连接的静态方法。 它支持绑定线程的连接，比如被用于DataSourceTransactionManager。
接着，org.springframework.jdbc.object包里是把关系数据库的查询， 更新和存储过程封装为线程安全并可重用对象的类。 这中方式模拟了JDO，尽管查询返回的对象理所当然的“脱离”了数据库连接。 这个JDBC的高层抽象依赖于org.springframework.jdbc.core包中所实现的底层抽象。
最后在org.springframework.jdbc.support包中你可以找到 SQLException的转换功能和一些工具类。
在JDBC调用中被抛出的异常会被转换成在定义org.springframework.dao包中的异常。 这意味着使用Spring JDBC抽象层的代码不需要实现JDBC或者RDBMS特定的错误处理。 所有的转换后的异常都是unchecked，它允许你捕捉那些你可以恢复的异常， 并将其余的异常传递给调用者。