本章简介
在掌握了Spring容器的基础知识之后，我们要把它们应用到实际的程序之中。一个很好的起点是针对几乎所有企业程序都存在的需求：数据访问。几乎所有程序员都曾经处理过数据库访问，也都知道使用传统的JDBC进行数据访问具有一些缺陷。接下来我们将要学习Spring是如何改善数据访问过程中存在的缺陷的。核心技能部分
Java持久化技术有很多种，Hibernate、iBATIS 和 JPA 只是其中的几种而已。尽管如此，很多程序还在以古老的方式把 Java 对象写入到数据库，就是JDBC技术。
使用JDBC这有什么不好吗？JDBC基于SQL，不要求我们掌握其他框架的查询语言，简单易学，因此学习成本低。另外，在使用 JDBC 时，可以更细致地调整数据访问的性能。JDBC 还允许我们利用数据库的特有功能，而其他框架可能不鼓励甚至禁止使用它们。
再者， JDBC可以让我们在比持久化框架低得多的层次上处理数据，能够访问和操作数据库里单独的字段。这种细致访问方法在有些程序里是很方便的，比如报表程序，如果把查询结果数据封装到对象里，而稍后惟一要做的只是把它分解为原始的数据进行输出，那封装过程就显的没有太大的意义了。
JDBC也不是十全十美的。它具有强大的功能、灵活性和其他一些优点，但也有缺点。
在讲解后面的内容之前，我们先来了解一下本章所有例子的数据模型。我们采用的是Oracle示范账户scott的emp表和dept表，针对这两张表，我们设计了两个实体类，用于封装查询结果，传递传递数据等，示例3.1是部门实体类：
示例3.1
public class Dept {
private Integer deptno; //部门编号
private String dname; //部门名称
private String loc; //部门位置
//省略构造函数和get/set方法
}
示例3.2是员工实体类
示例3.2
public class Emp {
private Integer empno; //员工编号
private Dept dept; //所属部门
private String ename;//员工姓名
private String job; //员工岗位
private Date hiredate; //入职日期
private Double sal; //员工薪水
//省略构造函数和get/set方法
}
第1章
1.1 JDBC的缺陷
JDBC为我们提供了一个API 来处理数据库，我们要负责处理与数据库访问相关的一切事宜，其中包括管理数据库资源和处理异常。
对于曾经利用JDBC从数据库查询数据的程序员来说，示例3.3中根据主键查询唯一员工实体对象的代码应该并不陌生：
示例3.3
public Emp findById(int empno) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = dataSource.getConnection(); 打开连接
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e "+
"inner join dept d on e.deptno = d.deptno where e.empno = ?";
st = conn.prepareStatement(sql); 创建语句
st.setInt(1,empno); 绑定参数
rs = st.executeQuery(sql); 执行查询
Emp e = null; 处理结果
if(rs.next())
{
e = new Emp();
e.setEmpno(rs.getInt("empno"));
e.setEname(rs.getString("ename"));
Dept d = new Dept();
d.setDeptno(rs.getInt("deptno"));
d.setDname(rs.getString("dname"));
e.setDept(d);
}
return e;
} catch (SQLException e) { 处理异常
e.printStackTrace();
} finally{ 释放资源
try {
if(rs!=null)rs.close();
if(st!=null)st.close();
if(conn!=null)conn.close();
} catch (SQLException e) {}
}
return null;
}失控的代码！这二十多行代码就是向数据库查询返回一个简单的对象。对于JDBC操作来说，简单易学是其特点，但为什么要用这么多行代码才能做到如此简单的事情呢？实际上不是这样的，只有几行是真正完查询操作的。无论是执行查询，更新，插入还是删除操作， JDBC都要求我们正确地管理连接和语句，还要处理可能抛出的SQLException，及时的释放资源。这显然造成了大量的代码重复。这似乎印证了 Pareto 法则：只有 20% 的代码是查询操作所必需的，而80%代码是样板代码。
但实际上这这些每次都需要重复编写的的样板代码是很重要的。清理资源和处理错误提高了数据访问的健壮性，没有这些操作，不能发现错误，就会让资源处于打开状态，从而导致意外的代码和资源泄漏。正是因为这些原因，我们让框架来处理这些样板代码，从而确保这些代码是存在的，而且是正确的。
Spring JDBC抽象框架所带来的价值将在以下几个方面得以体现，应用开发人员只需要完成粗体斜体字部分的编码工作，其它的由框架来自动完成：
l 定义数据库连接参数
l 打开数据库连接
l 声明SQL语句
l 预编译并执行SQL语句
l 遍历查询结果（如果需要的话）
l 处理每一次遍历操作
l 处理抛出的任何异常
l 处理事务
l 关闭数据库连接
1.1 配置数据源
无论使用什么形式的Spring DAO支持类，都需要配置对数据源的引用。Spring提供了多个选项用于在Spring程序里配置数据源，其中包括：
l 由JDBC驱动程序定义的数据源
l 基于连接池的JNDI数据源
l 基于连接池的本地数据源
数据库连接是一种关键的有限的昂贵的资源，频繁的建立和关闭数据库连接将造成很大的性能损失。这一点在多用户并发操作频繁的 web 应用程序中体现得尤为突出。
然而针对客户程序的连接请求，基于JDBC驱动程序定义的数据源每次都会创建一个新的连接。因此，此种数据源仅适合规模很小程序的程序或开发阶段。 对于已经准备进行发布的程序，建议使用从连接池获取连接的数据源。那么在了解如何创建基于连接池的JNDI数据源和本地数据源之前，先让我们了解一下数据连接池的基本原理和使用。
1.1.1 数据库连接池
对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
数据库连接池负责创建、管理和释放数据库连接。当数据源被创建时，会预先创建出一定数量的连接。它允许应用程序重复使用连接池中现有的数据库连接，而不是每次重新建立一个数据库连接。事实上，当我们试图关闭一个从连接池获取的连接时，连接并没有被真的关闭，而是被连接池回收到池中，置于闲置状态，等待应用重新获取进行复用。这样就可以避免频繁创建和关闭连接，有效节省系统资源。
当并发访问量增大，现有数据库连接不够用时，连接池才会尝试从数据库获取一定数量新的连接，直到达到连接池能够分配的最大连接数量为止。
当并发访问量降低时，连接池又会释放空闲时间超过最大空闲时间限制的闲置连接来避免因为没有释放连接而引起的数据库连接遗漏和资源浪费。
数据库连接池产品的实现原理大致相同，下面我们就以 Apache 软件基金会旗下 Jakarta 小组开发的 Commons Database Connection Pooling（公共数据库连接池）为例，为大家讲解数据库连接池的使用。Spring和tomcat都内置了这个数据库连接池组件。
和其它连接池组件一样，DBCP 也通过实现 javax.sql.DataSource 接口来为应用提供数据源服务。示例3.4是 javax.sql.DataSource 接口的源代码，我们可以看到它有两个重载的 getConnection 方法，用于为应用程序提供数据库连接。
示例3.4
public interface DataSource extends CommonDataSource,Wrapper {
Connection getConnection() throws SQLException;
Connection getConnection(String username,
String password) throws SQLException;
}
DBCP连接池组件的一个 DataSource 实现类叫做 BasicDataSource ，它定义了一些属性用于配置数据库连接池，我们来了解一些常用属性：
l initialSize ：连接池启动时创建的初始化连接数量，默认值为0 。
l maxActive ：连接池在任意同一时刻可以分配给应用程序使用的连接的最大数量。默认值为8。
l maxIdle：连接池中闲置连接的最大数量，超过此数量以外的空闲连接将被释放，如果设置为负数表示不限制，默认为8。
l minIdle：连接池中闲置连接的最小数量，当闲置连接数量低于这个数量时会创建新的连接，默认为0，表示不会创建连接
l maxWait ：最大等待时间，以毫秒为单位。当没有可用连接时，连接池等待应用释放连接的最大时间，超过该时间限制会抛出异常。默认-1，表示无限等待。应该设置合适的等待超时时间，如60000ms，避免因连接不够用，而导致请求被无限制挂起。
l minEvictableIdleTimeMillis ：闲置连接被逐出连接池的时间期限，以毫秒为单位，默认为30分钟，可以适当做调整，需要和后端服务端的策略配置相关。
了解了DBCP数据库连接池组件的常用配置属性后，让我们来创建一个DBCP数据源对象，请看示例3.5：
示例3.5
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("oracle.jdbc.driver.OracleDriver");
ds.setUrl("jdbc:oracle:thin:@localhost:1521:orcl");
ds.setUsername("scott");
ds.setPassword("tiger");
ds.setInitialSize(5);
ds.setMaxActive(100);
ds.setMaxIdle(20);
ds.setMinIdle(1);
ds.setMaxWait(3000);
需要注意的是，示例3.5只是创建了数据源对象，并配置了连接池参数，此时连接池并没有被初始化。当我们执行示例3.6中代码，即第一次调用数据源的getConnection方法时，数据源对象将会根据配置参数初始化数据库连接池，创建5个数据库连接，返回一个供应用使用，剩余4个处于闲置状态，保存在池中。请看示例3.6，通过数据源获得数据库连接。
示例3.6
Connection conn = ds.getConnection();
System.out.println("NumActive:" + ds.getNumActive());//打印分配给应用的连接数量
System.out.println("NumIdle: " + ds.getNumIdle());//打印池中闲置连接数量
当应用程序退出时，我们应该执行数据源对象的close方法，关闭数据源，释放所有连接资源。
示例3.7
ds.close()
数据库连接池对象一般都是以唯一实例形式存在的，即单例。这样便于统一管理连接资源。当应用程序需要数据库连接时，都必须向这个唯一的数据库连接池对象发送连接请求。
接下来，让我们来学习如何在Spring中创建和使用数据源。在我们真正做项目的时候，如果可能，我们应该优先选择通过 JNDI 从应用服务器获取连接池数据源。记住这一点，下面我们来看一看如何配置 Spring 从 JNDI 获取数据源。
1.1.2 在Spring中使用JNDI数据源
Spring Web应用通常运行于一个JEE程序服务器里，比如WebSphere、JBoss或像 Tomcat这样的Web容器。这些服务程序可以配置数据源，然后通过JNDI（java 名字目录服务）暴露给应用程序，应用程序通过本地或远程加载数据源获得数据库连接。以这种方式配置数据源的好处是可以在应用程序之外对数据源进行独立管理。应用程序本身只需要在需要访问数据库时请求数据源即可。而且，程序服务器里管理的数据源通常具有更好的性能，并能够由应用服务器系统管理员进行热切换（修改数据源配置，无需重启服务器）。
下面，让我们来学习如何在Tomcat中配置JNDI数据源，如何在Spring中使用JNDI数据源。
1. 在tomcat中配置JNDI数据源
1) 添加数据库驱动程序
如oracle 数据库jdbc驱动程序ojdbc6.jar，将其添加到 tomcat根目录下面的lib目录下即可。
2) 添加数据库连接池组件
我们使用tomcat自带的Apache组织开发的开源数据库连接池组件——Commons Database Connection Pooling（公共数据库连接池）。该组件位于tomcat根目录下面的lib目录下，名为tomcat-dbcp.jar。
3) 配置数据源
打开tomcat根目录下面的conf目录下面的context.xml文件，如D:\java\apache-tomcat-6.0.18\conf\context.xml，在根元素<Context>内部的末尾添加如示例3.8代码：
示例3.8
<Resource name="jdbc/scott"
auth="Container"
type="org.apache.commons.dbcp.BasicDataSource"
username="scott"
password="tiger"
driverClassName="oracle.jdbc.driver.OracleDriver"
url="jdbc:oracle:thin:@localhost:1521:orcl"
initialSize="10"
maxActive="100"
maxIdle="10"
minIdle="5"
maxWait="10000"
factory="org.apache.naming.factory.BeanFactory"/>
4) 重启tomcat
观察启动日志信息，如果没有报错，则表示数据源配置成功。如果报错，根据报错信息定位是那个环节出了问题，解决问题。
2. 在Spring 应用容器中配置JNDI数据源bean
利用Spring，我们可以像使用Bean一样配置一个数据源（保存在JNDI里）的引用，并且把它作为依赖，注入到其他需要使用数据源的bean里。Spring 的 JndiObjectFactoryBean 类能够从 JNDI 获取任何对象（包括数据源），并且可以将它配置在applicationContext.xml中，作为Spring Bean 使用。示例3.9通过JndiObjectFactoryBean类配置了一个JNDI数据源：
示例3.9
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="java:comp/env/jdbc/scott"/>
</bean>
属性 jndiName 用于指定 JNDI 资源目录和名称。目录为java:comp/env/，资源名称为jdbc/scott。另外需要注意的一点事，数据源作为数据库连接资源的统一管理者一般以单例形式存在。
为了示范如何应用数据源，接下来我们使用传统 JDBC 技术创建一个dao类，将其配置成bean，为其注入数据源，实现员工信息查询。 请看示例3.10：
示例3.10
package dao.jdbc;
@Component("empDaoJdbc")
public class EmpDaoJdbc {
@Resource(name="dataSource")
private DataSource dataSource;
public List<Emp> search() {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
List<Emp> list = new ArrayList<Emp>();
try {
conn = dataSource.getConnection();
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ";
st = conn.createStatement();
rs = st.executeQuery(sql);
while(rs.next())
{
Emp e = new Emp();
e.setEmpno(rs.getInt("empno"));
e.setEname(rs.getString("ename"));
Dept d = new Dept();
d.setDeptno(rs.getInt("deptno"));
d.setDname(rs.getString("dname"));
e.setDept(d);
list.add(e);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
try {
if(rs!=null)rs.close();
if(st!=null)st.close();
if(conn!=null)conn.close();
} catch (SQLException e) {}
}
return list;
}
}
由于tomcat的JNDI数据源只能提供给同一JVM进程中的应用使用，所以我们通过一个Servlet创建Spring容器，获得empDaoJdbc bean，调用search方法查询输出所有员工信息。请看示例：
示例3.11
public class JndiTest extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//创建spring容器
ApplicationContext beanFactory =
new ClassPathXmlApplicationContext("applicationContext.xml");
//通过spring容器获取dao
EmpDaoJdbc dao = (EmpDaoJdbc) beanFactory.getBean("empDaoJdbc");
List<Emp> list = dao.search();
//设置响应内容类型和字符集，获取字符输出流
response.setContentType("text/html");
response.setCharacterEncoding("UTF-8");
PrintWriter out = response.getWriter();
//向客户端输出员工信息
out.print("<table border=1>");
for (Emp emp : list) {
out.print("<tr>");
out.print("<td>");
out.println(emp.getEmpno());
out.print("</td>");
out.print("<td>");
out.println(emp.getEname());
out.print("</td>");
out.print("<td>");
out.println(emp.getDept().getDname());
out.print("</td>");
out.print("</tr>");
}
out.print("</table>");
out.flush();
out.close();
}
}执行结果如图3.1.1：
图3.1.1 查询显示所有员工信息
1.1.3 在Spring中使用基于连接池的本地数据源
我们也可以直接在Spring应用容器内部以bean的形式定义基于连接池的本地数据源。请看示例：
示例3.12
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" scope="singleton">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:ntcsoft" />
<property name="username" value="scott" />
<property name="password" value="tiger" />
<property name="initialSize" value="10"/>
<property name="maxActive" value="50"/>
<property name="maxIdle" value="10"/>
<property name="minIdle" value="5"/>
<property name="maxWait" value="10000"/>
</bean>
destroy-method属性指定bean生命周期结束回调方法。Spring容器在销毁bean之前会调用close方法，关闭数据源。
我们一样可以把这个数据源注入给示例3.8的 EmpDaoJdbc bean，并执行其search方法返回所有员工信息。我们只需要在applicationContext.xml中用示例3.12中的数据源bean定义替换示例3.9中的JNDI数据源bean定义即可。本地数据源可以直接在非web应用程序中使用，我们只需简单地在mian方法中执行下列代码即可测试数据源：
示例3.13
//创建spring容器
ApplicationContext beanFactory =
new ClassPathXmlApplicationContext("applicationContext.xml");
//通过spring容器获取dao
EmpDaoJdbc dao = (EmpDaoJdbc) beanFactory.getBean("empDaoJdbc");
//执行查询
List<Emp> list = dao.search();
for (Emp emp : list) {
System.out.println(emp.getEmpno()+"\t"
+emp.getEname()+"\t"
+emp.getDept().getDname());
}
执行结果：
7902 FORD RESEARCH!!
7876 ADAMS RESEARCH!!
7788 SCOTT RESEARCH!!
7566 JONES RESEARCH!!
7369 SMITH RESEARCH!!
7985 AAAAA RESEARCH!!
7698 BLAKE SALES
7654 MARTIN SALES
7521 WARD SALES
7499 ALLEN SALES
1011 测试2 OPERATIONS
1010 测试 OPERATIONS
1012 测试3 OPERATIONS
……现在我们已经了解了如何基于连接池配置本地数据源和JNDI数据源，接下来让我们来学习使用Spring JDBC模版简化jdbc操作。在后面的例子中，我们会直接使用到之前配置好的数据源。
1.2 使用Spring JDBC 模版
Spring的JDBC框架将数据访问的过程中获取连接、释放资源、异常处理、遍历查询结果等必须的样板代码封装隐藏到模板类之下，从而简化我们的JDBC 代码，让我们只需编写从数据库读写数据所必需的代码。Spring针对JDBC提供了3个模板类：
l JdbcTemplate：Spring 里最基本的 JDBC 模板，利用 JDBC 和简单的索引参数查询提供对数据库的简单访问。
l NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数，这有利于简化动态组合条件查询的实现，也不容易搞混参数
l SimpleJdbcTemplate：利用Java 5的特性，比如自动装箱、泛型（generic）和可变参数列表来简化JDBC模板的使用。
具体使用哪个模板基本上取决于个人喜好。下面我们依次介绍它们，首先从JdbcTemplate开始。
1.2.1 使用JdbcTemplate
使用JdbcTemplate访问数据只需要将其配置成bean，并为其注入DataSource 就可以了。 在applicationContext.xml 加入如下代码配置JdbcTemplate Bean：
示例3.14
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
接下来我们将使用 JdbcTemplate 创建一个dao对象，以完成scott示范账户中员工信息的增删查改操作。
首先，我们在dao包下面创建一个EmpDao接口，在其中定义需要的增删查改方法：
示例3.15
package dao
public interface EmpDao {
/**
* 查询所有员工
*/
List<Emp> search();
/**
* 根据参数Emp中的属性值作为查询条件实现动态组合查询
*/
List<Emp> search(Emp e);
/**
* 根据主键查询员工
*/
Emp findById(int empno);
/**
* 插入
*/
void save(Emp e);
/**
* 更新
*/
void update(Emp e);
/**
* 删除
*/
void delete(int empno);
}
然后，我们在dao.jdbcTemplate包下创建一个叫做 EmpDaoJdbcTemplate 的EmpDao接口实现类，给它一个JdbcTemplate类型的属性，将示例3.14中配置好的JdbcTemplate bean注入其中，并将该dao类配置成一个bean，id为empDao。
示例3.16
@Component("empDao")
public class EmpDaoJdbcTemplate implements EmpDao {
@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;
……
}
接着我们就用JdbcTemplate对象一个一个地实现EmpDao接口的方法。
1. 插入新员工
示例3.16是JdbcTemplate的update方法的定义。第一个参数是sql语句，第二个参数用于传递sql语句中内置的参数，类型是Object...，所以args既可以接受Object数组类型的参数，又可以接受不定个数的Obejct类型的参数。
示例3.16
public int update(String sql, Object... args) throws DataAccessException
使用JdbcTemplate 能够极大简化JDBC代码的编写，我们只需要准备好sql语句和数据，就可以直接将数据保存到数据库中去了，请看示例3.17：
示例3.17
public void save(Emp e) {
String sql = "insert into emp (empno,ename,deptno) values (?,?,?)";
Object[] params = newObject[]{
e.getEmpno(), e.getEname(), e.getDept().getDeptno()
};
jdbcTemplate.update(sql, params);
}
显然，示例3.17中的save(Emp e) 的实现比用传统JDBC实现简单多了，没有了创建连接和语句的代码，没有异常处理代码和释放资源的代码，只有纯的数据插入代码。
实际上，那些样板代码还在。看不到并不意味着它们不在，它们被巧妙地隐藏到JdbcTemplate里。当JdbcTemplate的update方法被调用时，JdbcTemplate将获取连接、创建语句并执行插入SQL。
对SQLException的处理也被隐藏了。 JdbcTemplate会捕获全部SQLException， 把通用的SQLException转化为Spring自定义的数据访问异常，然后重新抛出。由于Spring的数据访问异常全部是运行时异常，所以不必在dao的操作方法里捕获它。
除了以数组形式为update操作传递参数数据，我们还可以简写为示例3.18的形式：
示例3.18
public void save(Emp e) {
String sql = "insert into emp (empno,ename,deptno) values (?,?,?)";
jdbcTemplate.update(sql,
e.getEmpno(), e.getEname(), e.getDept().getDeptno()
);
}
为了测试save方法及后续其它方法，我们创建一个JUnit测试类。它有一个静态的ApplicationContext属性叫做 beanFactory，在声明时直接初始化。还有一个EmpDao属性叫做dao，在静态块中初始化，这是为了保证 ApplicationContext 已经初始化完毕。
然后我们继续在其中添加一个叫做testSave的方法，用于测试员工插入操作。注意，方法名称必须以test开头。
示例3.19
public class EmpDaoJdbcTemplateTest extends TestCase {
private static ApplicationContext beanFactory =
new ClassPathXmlApplicationContext("applicationContext.xml");
private static EmpDao dao;
static {
dao = (EmpDao) beanFactory.getBean("empDao");
}
public void testSave() throws Exception {
Emp emp = new Emp(1012,"员工测试",new Dept(40));
dao.save(emp);
}
}
在测试类上点击鼠标右键，选择Run As -> JUnit Test，执行测试，有要学习JUnit的可以参见，本博客的JUnit文章。
2. 实现无参的search方法
JdbcTemplate 也简化了数据读取操作。示例3.20展示了利用JdbcTemplate的query方法执行查询，并使用JdbcTemplate回调RowMapper的mapRow方法把结果集映射到实体对象返回。
示例3.20
public List<Emp> search() {
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ";
RowMapper rowMapper = new ParameterizedRowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int rowNum) throws SQLException {
Emp e = new Emp();
e.setEmpno(rs.getInt("empno"));
e.setEname(rs.getString("ename"));
Dept d = new Dept();
d.setDeptno(rs.getInt("deptno"));
d.setDname(rs.getString("dname"));
e.setDept(d);
return e;
}
};
List<Emp> list = jdbcTemplate.query(sql,rowMapper);
return list;
}
JdbcTemplate的query方法有2个参数：
l 一个字符串，包含用于从数据库里选择数据的SQL语句
l 一个RowMapper对象，它从ResultSet里提取数值并构造一个实体对象返回，在这里就是员工对象。
真正奇妙之处在于RowMapper对象。对于查询返回的每一行记录，JdbcTemplate都会调用RowMapper的mapRow()方法。在RowMapper里，我们已经编写了代码来创建Emp对象和Dept对象，并且用ResultSet里的值填充它们。
相比传统JDBC实现查询，我们不仅不需要处理异常、打开连接、创建语句对象、清除资源，而且不需要自己循环结果集来填充实体对象。由于EmpDao接口将来的每一个实现类在实现search()、findById()和search(Emp e)时都需要使用同一个RowMapper对象来完成数据记录到实体对象的映射，我们把它定义成EmpDao接口的一个公共静态常量属性，这样每个Dao实现类都可以直接继承使用EmpDao接口的rowMapper属性，进一步简化了查询的代码编写：
示例3.21 在EmpDao接口中定义公共静态常量属性rowMapper
public static final RowMapper rowMapper = new ParameterizedRowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int rowNum) throws SQLException {
Emp e = new Emp();
e.setEmpno(rs.getInt("empno"));
e.setEname(rs.getString("ename"));
Dept d = new Dept();
d.setDeptno(rs.getInt("deptno"));
d.setDname(rs.getString("dname"));
e.setDept(d);
return e;
}
};
实例3.20 简写为示例3.22所示代码：
示例3.22 简写后的search方法
public List<Emp> search() {
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ";
List<Emp> list = jdbcTemplate.query(sql,rowMapper);
return list;
}
3. 实现findById方法
findById方法几乎与search()方法相同，仅有两点不同：
l 需要传递查询条件
l 仅返回一个员工对象而不是一个员工对象集合
示例3.23
public Emp findById(int empno) {
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno where empno = ?";
List<Emp> list = jdbcTemplate.query(sql, rowMapper,empno);
return list.size()>0?(Emp)list.get(0):null;
}
Sql语句中查询条件参数的传递和seve方法相同，即可用传递Object数组，也可以一个一个的指定参数。rowMapper继承自EmpDao接口。
4. 实现search（Emp e）方法
该方法要实现的是根据用户在多个查询条件中选填后得到动态组合查询的效果。在这里我们有两个查询条件，员工姓名和所属部门。可以组合得到如下几种查询：
l 无条件查询，即查询所有。如图3.1.3为查询显示效果：
l 仅填写姓名，进行模糊查询。如图所示查询效果：
图3.1.4名字包含S的员工信息
l 仅选择部门，查询谋部门的所有员工。如图所示查询效果：
图3.1.5 SALES部门所有员工信息
l 即填写姓名又选择部门，查询谋部门符合姓名条件的员工信息。如图所示查询效果：
图3.1.6 SALES部门中名字包含S的员工信息
我们将查询条件封装在Emp对象中，一次性提供给search方法。search方法判断Emp对象的ename属性和dept属性的deptno属性是否保存了查询条件，有则为sql语句添加条件限定子句，并向参数列表中添加查询条件值，动态生成sql语句和查询条件列表，执行查询。请看示例：
示例3.23
public List<Emp> search(Emp e) {
StringBuilder sql = new StringBuilder("select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ");
List plist = new ArrayList();
if(e!=null){
if(e.getEname()!=null && e.getEname().trim().length()!=0){
sql.append(" and e.ename like ?");
plist.add("%"+e.getEname()+"%");
}
if(e.getDept()!=null && e.getDept().getDeptno()!=null
&& e.getDept().getDeptno()>0){
sql.append(" and d.deptno = ?");
plist.add(e.getDept().getDeptno());
}
}
Object[] params = plist.toArray();
List<Emp> list = jdbcTemplate.query(sql.toString(),params,rowMapper);
return list;
}1.1.1 使用NamedParameterJdbcTemplate
在示例3.17的save方法实现中使用了索引参数，这意味着在把参数传递给 update()方法时，我们必须注意参数在SQL语句里的次序，并且以正确次序设置对应参数的值。如果在修改SQL语句时不得不改变参数的次序，那么值的次序也必须随之改变。
为了避免这种情况，我们可以使用命名参数，给 SQL 里的每个参数赋予一个名称，在赋值时利用这些名称来引用参数。现在我们把3.17示例中的insert语句中的索引参数修改成命名参数如示例3.24：
示例3.24 为sql指定命名参数
insert into emp ( empno , ename , deptno ) values ( :empno, :ename, :deptno)
在使用命名参数时，绑定值的次序是没有关系的。我们可以用名称绑定每个值。如果sql语句参数次序改变了，我们也不需要修改参数绑定的代码。
不过， JdbcTemplate 不支持命名参数，我们需要使用一个特殊的 JDBC 模板：NamedParameterJdbcTemplate，它在Spring里的配置XML类似于JdbcTemplate：
示例3.25 NamedParameterJdbcTemplate bean
<bean id="namedParameterJdbcTemplate"
class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg ref="dataSource"/>
</bean>
由于NamedParameterJdbcTemplate是个特殊的JDBC模板，而且不是JdbcTemplate的子类，所以我们新创建一个叫做EmpDaoNamedParameter的DAO类，将jdbcTemplate属性的类型定义为NamedParameterJdbcTemplate：
示例3.26 使用NamedParameterJdbcTemplate的Dao
@Component("empDaoNamedParam")
public class EmpDaoNamedParameter implements EmpDao {
@Resource(name="namedParameterJdbcTemplate")
private NamedParameterJdbcTemplate jdbcTemplate;
……
}
现在，我们用NamedParameterJdbcTemplate来实现命名参数形式的员工插入操作：
示例3.27 使用命名参数的save方法
public int save(Emp e) {
String sql = "insert into emp (empno,ename,deptno) " +
"values (:empno,:ename,:deptno)";
Map params = new HashMap();
params.put("empno", e.getEmpno());
params.put("ename", e.getEname());
params.put("deptno", e.getDept().getDeptno());
return jdbcTemplate.update(sql, params);
}
命名参数的绑定需要通过参数名称去映射参数值，我们可以通过java.util.Map来保存这些映射关系，然后一次性提交给update方法执行插入。
接下来，我们来看一下以命名参数形式实现的查询方法。示例3.28中的findById方法根据唯一的参数empno查询返回一个员工实体对象：
示例3.28 只有一个参数的findById方法
public Emp findById(int empno) {
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno where empno = :empno";
Map params = new HashMap();
params.put("empno", empno);
List<Emp> list = jdbcTemplate.query(sql, params,rowMapper);
return list.size()>0?(Emp)list.get(0):null;
}
示例3.29是没有查询条件的search方法，返回所有员工：
示例3.29
public List<Emp> search() {
String sql = "select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ";
List<Emp> list = jdbcTemplate.query(sql,new HashMap(),rowMapper);
return list;
}
示例3.30是动态组合条件查询：
示例3.30
public List<Emp> search(Emp e) {
StringBuilder sql = new StringBuilder("select e.empno,e.ename,d.deptno,d.dname from emp e inner join dept d on e.deptno = d.deptno ");
Map params = new HashMap();
if(e!=null){
if(e.getEname()!=null && e.getEname().trim().length()!=0){
sql.append(" and e.ename like :ename");
params.put("ename", "%"+e.getEname()+"%");
}
if(e.getDept()!=null && e.getDept().getDeptno()!=null
&& e.getDept().getDeptno()>0){
sql.append(" and d.deptno = :deptno");
params.put("deptno", e.getDept().getDeptno());
}
}
List<Emp> list = jdbcTemplate.query(sql.toString(),params,rowMapper);
return list;
}
1.1 使用Spring 对 JDBC的 DAO支持类
对于程序里基于JDBC的全部DAO类，我们都需要添加一个JdbcTemplate属性和一个设置器方法，并且把JdbcTemplate Bean装配到每个DAO的JdbcTemplate属性。如果程序只有一个DAO，这不是什么问题，但如果有多个DAO，这就会产生很多重复代码。
一种解决方案是为全部DAO 对象创建一个通用父类，在其中设置 JdbcTemplate 属性，然后让全部 DAO 继承这个类，使用父类的JdbcTemplate进行数据访问，Spring恰好提供了这样一些基类。
1.1.1 使用JdbcDaoSupport
Spring 的 JdbcDaoSupport 就是用于编写基于JDBC 的DAO 类的基类，我们只需让自己的DAO类继承它即可。举例来说，基于JdbcDaoSupport的DAO类可能是这样的：
示例3.31
package dao.support;
public class EmpDaoJdbcSupport extends JdbcDaoSupport implements EmpDao{
……省略方法
}
我们可以调用父类的getJdbcTemplate()方法获得JdbcTemplate，编写数据操作方法，比如实现EmpDao接口的save方法。请看示例3.34，EmpDaoJdbcSupport类的save方法实现：
示例3.32
public int save(Emp e) {
String sql = "insert into emp (empno,ename,deptno) values (?,?,?)";
Object[] params = new Object[]{
e.getEmpno(),e.getEname(),e.getDept().getDeptno()
};
return getJdbcTemplate().update(sql, params);
}
由于JdbcTemplate属性定义在父类JdbcDaoSupport中，其由Spring提供，所以我们无法使用注解配置，因为添加注解需要修改源代码。所有我们只能使用xml方式配置EmpDaoJdbcSupport这个Dao了，请看示例，将基于JdbcDaoSupport的EmpDaoJdbcSupport配置为bean：
示例3.33
<bean id="empDaoJdbcSupport" class="dao.support.EmpDaoJdbcSupport">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
1.1.2 使用NamedParameterJdbcDaoSupport
JdbcDaoSupport的jdbcTemplate属性类型是JdbcTemplate，所以只支持索引参数形式。如果你希望使用命名参数形式，那么就让Dao类继承NamedParameterJdbcDaoSupport类。请看示例3.34，基于NamedParameterJdbcDaoSupport的Dao类：
示例3.34
package dao.support;
public class EmpDaoNamedJdbcSupport extends NamedParameterJdbcDaoSupport implements EmpDao{
……省略方法
}
调用父类NamedParameterJdbcDaoSupport的getNamedParameterJdbcTemplate()方法返回一个NamedParameterJdbcTemplate对象，就可以使用命名参数的形式编写dao操作了。请看示例3.35，基于NamedParameterJdbcDaoSupport的save方法实现：
示例3.35
public int save(Emp e) {
String sql = "insert into emp (empno,ename,deptno) values "+
"(:empno,:ename,:deptno)";
Map params = new HashMap();
params.put("empno", e.getEmpno());
params.put("ename", e.getEname());
params.put("deptno", e.getDept().getDeptno());
return getNamedParameterJdbcTemplate().update(sql, params);
}
另外一点需要注意的是EmpDaoNamedJdbcSupport bean的配置。我们可能会想当然的认为 EmpDaoNamedJdbcSupport bean 应该有一个叫做namedParameterJdbcTemplate的属性，类型是NamedParameterJdbcTemplate。那么我们就可以通过setter注入将示例3.25中定义的 id为namedParameterJdbcTemplate的bean注入给 EmpDaoNamedJdbcSupport，如示例3.36：
示例3.36
<bean id="empDaoNamedJdbcSupport" class="dao.support.EmpDaoNamedJdbcSupport">
<property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate">
</property>
</bean>
事实上，当我们试图根据示例3.36中的配置创建Spring应用容器时就会报错。NamedParameterJdbcDaoSupport 确实有一个属性叫做namedParameterJdbcTemplate，其类型为NamedParameterJdbcTemplate，但是遗憾的是，它没有setNamedParameterJdbcTemplate方法，只有getNamedParameterJdbcTemplate方法。那么我们到底应该如何为基于NamedParameterJdbcDaoSupport的dao bean注入NamedParameterJdbcTemplate依赖呢？让我们来看一下示例3.37中的NamedParameterJdbcTemplate源代码，一探究竟。
示例3.37
public class NamedParameterJdbcDaoSupport extends JdbcDaoSupport {
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
/**
* 基于JdbcTemplate创建 NamedParameterJdbcTemplate。
*/
@Override
protected void initTemplateConfig() {
this.namedParameterJdbcTemplate = new
NamedParameterJdbcTemplate( getJdbcTemplate() );
}
public NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {
return namedParameterJdbcTemplate;
}
}
从示例3.37中可以看出，NamedParameterJdbcDaoSupport类实际上继承了JdbcDaoSupport类，并在initTemplateConfig()方法中调用JdbcDaoSupport的getJdbcTemplate()方法返回一个JdbcTemplate，然后以这个JdbcTemplate 为条件构造了一个NamedParameterJdbcTemplate，赋值给namedParameterJdbcTemplate属性。所以，正确的bean配置应是这样的：
示例3.38
<bean id="empDaoNamedJdbcSupport" class="dao.support.EmpDaoNamedJdbcSupport">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
本章总结
1. 数据库连接池
2. 配置数据源
由JDBC驱动程序定义的数据源
基于连接池的JNDI数据源
基于连接池的本地数据源
3 使用JDBC模板简化JDBC开发
JdbcTemplate
NamedParameterJdbcTemplate
4 使用Spring 对 JDBC的 DAO支持类
JdbcDaoSupport
NamedParameterJdbcDaoSupport
任务实训部分
1：完成网店购物系统的框架搭建
训练技能点
数据源的配置
Jdbc模板的配置
需求说明
某公司需要开发一个小型网络商店系统，该系统能实现用户登录，注册，浏览商品，添加商品到购物车，生成订单等功能，要求使用Spring和Spring JDBC抽象框架来实现该系统的Dao层。该系统有两张表，分别是商品表（products）、用户表（users）、订单表（orders）和订单条目表（item），详细字段说明如表所示。
商品表（products）
|
列名 |
数据类型 |
描述 |
|
Id |
Int |
商品唯一标识，主键，自动增长列 |
|
ProductName |
Varchar(50) |
商品名称，非NULL |
|
Price |
float |
商品价格，非NULL |
|
Amount |
Int |
数量，非NULL |
|
Details |
Varchar(1000) |
商品描述 可以为NULL |
|
ImgUrl |
Varchar(200) |
图片路径 |
用户表（users）
|
列名 |
数据类型 |
描述 |
|
Id |
Int |
用户唯一标识，主键，自动增长列 |
|
UserName |
Varchar(50) |
用户名称，非NULL，唯一 |
|
Password |
Varchar(50) |
用户密码，非NULL |
订单表（orders）
|
列名 |
数据类型 |
描述 |
|
Id |
Int |
订单唯一标识，主键，自己生成ID |
|
UserId |
Int |
下订单用户Id，外键，参考用户表 Id 字段 |
|
Date |
date |
下订单时间，非NULL |
订单条目表（item）
|
列名 |
数据类型 |
描述 |
|
Id |
Int |
订单条目唯一标识，主键，自动增长列 |
|
OrderId |
Int |
条目所属订单Id，外键，参考订单表 Id 字段 |
|
ProductId |
Int |
商品Id，外键，参考商品表 Id 字段 |
|
Amount |
Int |
数量，非NULL |
实现思路
(1) 在oracle中创建数据表。
(2) 在用户表和商品表中插入一些数据。
(3) 为项目添加Spring支持。
(4) 根据表编写实体类。
(5) 配置数据源
(6) 配置JDBC模板
关键代码
(1) 数据源和JDBC模板配置。
<!-- 扫描注解配置的 dao bean -->
<context:component-scan base-package="com.shoppingcart.dao" />
<!-- 数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close" scope="singleton">
<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" />
<property name="initialSize" value="10"/>
<property name="maxActive" value="50"/>
<property name="maxIdle" value="10"/>
<property name="minIdle" value="5"/>
<property name="maxWait" value="10000"/>
</bean>
<!-- jdbc模版 -->
<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg ref="dataSource"/>
</bean>
(2) 根据表结构实体类。//用户实体类
public class User {
private int id; //用户ID
private String password; //登录密码
private String userName; //登录账号
public User() {}
public User(int id) {
super();
this.id = id;
}
//setter & getter
}
//商品体类
public class Product {
private int id; //商品ID
private String name; //商品名称
private float price; //商品单价
private int amount; //商品存货数量
private String details; //商品详细描述
public Product(){}
public Product(int id) {
super();
this.id = id;
}
}
//订单体类
public class Order {
private String id; //订单ID
private Date date; //订单创建时期
private User user; //订单创建用户
private Set<OrderItem> items = new HashSet<OrderItem>();//订单条目信息
//setter & getter
}
public class OrderItem {
private int id; //订单条目ID
private Product product; //商品信息
private int amount; //商品的数量
public OrderItem(){}
public OrderItem(int amount, Product product) {
super();
this.amount = amount;
this.product = product;
}
//setter & getter
}
2：订单DAO实现
训练技能点
JDBC模板应用
需求说明
完善框架搭建，实现订单操作的Dao层设计，并将Dao配置成bean，为其注入JDBC模板
实现思路
(1) 定义OrderDao接口
(2) 定义OrderDaoImpl类
关键代码
(1) 定义DAO接口和实现，课堂上仅实现OrderDao的保存订单和查询单个订单方法。
package com.shoppingcart.dao;
public interface OrderDao {
/**
* 保存订单
* @param order
*/
public void saveOrder(Order order);
/**
* 根据编号查询订单
* @param id
*/
public Order loadOrder(int id);
/**
* 根据用户编号查询用户拥有的所有基本订单信息
* @param id
*/
public Order selectOrder(int id);
/**
* 修改订单信息
* @param id
*/
public Order updateOrder(Order order);
/**
* 删除订单（先删除该订单的条目，然后删除订单基本信息）
* @param id
*/
public Order deleteOrder(int orderId);
}
(2) 定义OrderDaoImpl类，利用注解配置将其配置成bean，并为其注入jdbc模板
package com.shoppingcart.dao;
@Component("orderDao")
public class OrderDaoImpl implements OrderDao {
@Resource(name = "jdbcTemplate")
private NamedParameterJdbcTemplate jdbcTemplate;
private static final String nextOrderIdSql = "select orders_seq.nextval from dual";
private static final String orderInsertSql = "insert into orders (id,userid,createDate) values (:oid,:uid,:createDate)";
private static final String itemInsertSql = "insert into item (id,orderid,productid,amount) values (item_seq.nextval,:oid,:pid,:amount)";
@Override
public void saveOrder(Order order) {
//查询下一个订单编号
int orderId = jdbcTemplate.queryForInt(nextOrderIdSql, new HashMap());
//保存订单基本信息
Map params = new HashMap();
params.put("uid", order.getUser().getId());
params.put("oid", orderId);
params.put("createDate", order.getCreateDate());
jdbcTemplate.update(orderInsertSql, params);
//利用jdbc批量操作保存多条订单条目信息
//将每个订单条目数据保存到一个Map中，再将Map存放到List中，一次性批量插入
List<Map> list = new ArrayList<Map>();
for(OrderItem item : order.getItems())
{
params = new HashMap();
params.put("oid", orderId);
params.put("pid", item.getProduct().getId());
params.put("amount", item.getAmount());
list.add(params);
}
Map[] batchValues = list.toArray(new Map[0]);
jdbcTemplate.batchUpdate(itemInsertSql, batchValues);
}
private static final String loadOrderSql = "select o.id,o.createDate,u.id as userid,u.username from orders o , users u where o.userid = u.id and o.id=:oid";
private static final String selectItemSql = "select i.id,i.amount,p.id as pid,p.productname,p.price,p.amount as pamount,p.details from item i , products p where i.ProductId = p.id and i.OrderId = :oid";
@Override
public Order loadOrder(int id) {
// 查询条件预置参数
Map params = new HashMap();
params.put("oid", id);
// 执行订单查询
List<Order> list = jdbcTemplate.query(loadOrderSql, params, orderMapper);
Order order = list.size() > 0 ? (Order) list.get(0) : null;
//执行订单条目查询
List<OrderItem> items = jdbcTemplate.query(selectItemSql, params,itemMapper);
order.getItems().addAll(items);
return order;
}
public static final RowMapper orderMapper = new ParameterizedRowMapper<Order>() {
@Override
public Order mapRow(ResultSet rs, int rowNum) throws SQLException {
Order order = new Order();
User user = new User();
order.setId(rs.getString("id"));
order.setCreateDate(rs.getDate("createDate"));
user.setId(rs.getInt("userid"));
user.setUserName(rs.getString("userName"));
order.setUser(user);
return order;
}
};
public static final RowMapper itemMapper = new ParameterizedRowMapper<OrderItem>() {
@Override
public OrderItem mapRow(ResultSet rs, int rowNum) throws SQLException {
OrderItem item = new OrderItem();
Product p = new Product();
item.setId(rs.getInt("id"));
item.setAmount(rs.getInt("amount"));
p.setId(rs.getInt("pid"));
p.setName(rs.getString("productname"));
p.setPrice(rs.getFloat("price"));
p.setAmount(rs.getInt("pamount"));
p.setDetails(rs.getString("details"));
item.setProduct(p);
return item;
}
};
}3：测试OrderDao实现：测试OrderDao实现
训练技能点
JUnit的使用
需求说明
利用JUnit对OrderDao的方法进行测试
关键代码
public class SaveOrderTest extends TestCase {
//创建spring ApplicationContext
private static ApplicationContext beanFactory = new ClassPathXmlApplicationContext("com/shoppingcart/applicationContext.xml");
private static OrderDao dao;
//初始化dao
static {
dao = (OrderDao) beanFactory.getBean("orderDao");
}
//测试保存订单
public void testSaveOrder()
{
Order o = new Order();
o.setCreateDate(new Date());
o.setUser(new User(1));
o.getItems().add(new OrderItem(5,new Product(1)));
o.getItems().add(new OrderItem(5,new Product(3)));
dao.saveOrder(o);
}
//测试加载单个订单
public void testLoadOrder()
{
Order o = dao.loadOrder(4);
System.out.println("下单用户："+o.getUser().getUserName()+"\t订单编号："+o.getId()+" \t下单日期："+o.getCreateDate());
System.out.print("产品名称 \t购买数量 \t单价\t小计 \n");
float totalCount = 0f;
for (OrderItem item : o.getItems()) {
int amount = item.getAmount();
float price = item.getProduct().getPrice();
float itemCount = price * amount;
System.out.print(item.getProduct().getName()+"\t"
+amount+"\t"
+price+"\t"
+itemCount+"元\n");
totalCount += itemCount;
}
System.out.println("合计："+totalCount+"元");
}
}
巩固练习
一．选择题
1. 以下关于JDBC缺陷描述的每次都要反复编写的样板代码包括哪些？（）。
A. 打开数据库连接
B. 处理可能抛出的SQLException
C. 及时的释放资源（关闭Connection、Statement、ResultSet）
D. 执行数据库操作（执行查询，更新操作）
2. Spring支持的数据源不包括哪一种？（）
A. 由JDBC驱动程序定义的数据源
B. 基于连接池的JNDI数据源
C. 基于webservice技术的远程数据源
D. 基于连接池的本地数据源
3. 以下关于数据库连接池技术描述错误的是？（）。
A. 数据库连接是非常有限的宝贵资源，连接池可以高效复用有限的连接，按需创建连
接，及时释放空闲连接
B. 关闭和创建数据库连接操作会销毁大量系统资源，数据库连接池避免频繁创建和关
闭和创建数据库连
C. 数据库连接池可以打开任意多个连接
D. 数据源必须通过数据库连接池提供
4. Spring针对JDBC提供了3个模板类，不包括下面那一个？（）。
A. JdbcTemplate
B. JdbcDaoSupport
C. SimpleJdbcTemplate
D. NamedParameterJdbcTemplate
5. 关于JDBC抽象框架描述错误的是（）。
A. Spring 对JDBC 的DAO支持类为我们提供了JDBC模板对象，因此不需要对Dao注
入JDBC模板对象了
B. Spring JDBC DAO支持类拥有JDBC模板类型的属性和setter方法，从而简化了Dao
的设计，但是我们依然需要为dao注入JDBC模板对象
C. JDBC抽象框架和Hibernate一样属于ORM框架
D. JDBC抽象框架并非ORM框架，它采用模板方法设计模式，将获取连接，释放资源，
处理异常，创建Statement对象等样板代码封装在模板方法中，简化了JDBC开发
过程
二．操作题
1. 将任务实训中OrderDao接口中定义的未实现的方法完整实现。
