spring JDBC的支持使用实例源码介绍

Java代码  收藏代码
  1. 1、spring对DAO的支持
  4. Java代码
  5. public class AccountServiceImpl implements AccountService{
  6.     private AccountDao accountDao;
  7.     /** set方法注入 */
  8.     public void setAccountDao(AccountDao accountDao);
  9.         this.accountDao = accountDao;
  10.                 }
  11.                 public void insert(Account acc){
  12.                     accountDao.insert(acc);
  13.                 }
  14. }
  16.         从这个类的源代码可以看出，程序所依赖的是数据访问接口。因此，可以随时更换AccountDao的实现类。Spring的DAO框架正式基于这样的基本原理来将应用程序与底层数据存取技术解耦的。
  18.   2、数据源的注入
  19.  对数据库数据执行任何的存取操作，必须要有数据源，spring提供了javax.sql,DataSource注入，这样在需要更换数据源时只需要在spring配置文件中修改即可。而不需要修改程序代码。
  20.                不同的应用系统可能使用不同的数据源。
  22.       2.1、不带连接池的数据源
  24. Xml代码
  25. <!– 配置不带连接池的数据源 –>
  26.     <bean id=”dataSource” class=”org.springframework.jdbc.datasource.DriverManagerDataSource”>
  27.         <property name=”driverClassName” value=”com.mysql.jdbc.Driver” />
  28.         <property name=”url” value=”jdbc:mysql:///spring” />
  29.         <property name=”username” value=”root” />
  30.         <property name=”password” value=”123>
  31.     </bean>
  32.     <bean id=”accountDao” class=”com.zxf.dao.AccountDaoImpl”>
  33.         <property name=”dataSource” ref=”dataSource” />
  34.     </bean>
  36.     <bean id=”accountService” class=”com.zxf.service.AccountService”>
  37.         <property name=”accountDao” ref=”accountDao”/>
  38.     </bean>
  40.     2.2、集成第三方连接池技术的数据源
  43.     第一种方式所获取的数据源是不带连接池的，不适合正式的商业使用。正式的商业应用需要使用带连接池的数据源，比较常见的第三方连接池有：DBCP和C3P0。
  44.        要想使用第三方的连接池技术，首先需要在项目类路径下添加它的类库。
  45.         commons-dbcp.jar 和 commons-pool.jar.
  47. Xml代码
  48. <!– 配置DBCP的数据源 –>
  49.     <bean id=”dataSource2″
  50.           class=”org.apache.commons.dbcp.BasicDataSource”
  51.           destroy-method=”close”>
  52.         <property name=”driverClassName” value=”com.mysql.jdbc.Driver”/>
  53.         <property name=”url” value=”jdbc:mysql:///spring” />
  54.         <property name=”username” value=”root” />
  55.         <property name=”password” value=”123″ />
  56.     </bean>
  58.     <!– 配置C3P0的数据源 –>
  59.     <bean id=”dataSource3″
  60.           class=”com.mchange.v2.c3p0.ComboPooledDataSource”
  61.           destroy-method=”close”>
  62.         <property name=”driverClass” value=”com.mysql.jdbc.Driver” />
  63.         <property name=”jdbcUrl” value=”jdbc:mysql:///spring” />
  64.         <property name=”user” value=”root” />
  65.         <property name=”password” value=”123”/>
  66.     </bean>
  68.     备注：若要使用分散配置设置数据库的连接的话，可以使用分散配置。在配置数据源的是代码前面配置一下的代码。
  70. Xml代码
  71. <!– 分散配置 –>
  72.     <context:property-placeholder location=”jdbc.properties”/>
  73.     举例：
  74.         <!–  驱动程序 –>
  75.         <property name=”driverClass”>
  76.             <value>${jdbc.driverClass}</value>
  77.         </property>
  79.         <!–  连接的url地址 –>
  80.         <property name=”jdbcUrl”>
  81.             <value>${jdbc.url}</value>
  82.         </property>
  84.         <!–  连接的用户名 –>
  85.         <property name=”user”>
  86.             <value>${jdbc.user}</value>
  87.         </property>
  89.         <!–  连接的用户名的密码 –>
  90.         <property name=”password”>
  91.             <value>${jdbc.password}</value>
  92.         </property>
  93.         <!–  最大池数 –>
  94.         <property name=”maxPoolSize”>
  95.             <value>${c3p0.pool.max}</value>
  96.         </property>
  98.         <!–  最小池数 –>
  99.         <property name=”minPoolSize”>
  100.             <value>${c3p0.pool.min}</value>
  101.         </property>
  103.         <!–  默认的初始化的池数 –>
  104.         <property name=”initialPoolSize”>
  105.             <value>${c3p0.pool.init}</value>
  106.         </property>
  111. Properties代码
  112. 下面是jdbc.properties
  113.     jdbc.driverClass=com.mysql.jdbc.Driver
  114. jdbc.url=jdbc\:mysql\://localhost\:3306/spring
  115. jdbc.user=root
  116. jdbc.password=123
  117. c3p0.pool.max=10
  118. c3p0.pool.min=3
  119. c3p0.pool.init=5
Java的代码  收藏代码
  1.  API的使用。
  2. Java的代码
  3. 包 com.zxf.domain;
  4. 导入 java.util.Date的;
  6. / **
  7.  * @作者z_xiaofei168
  8.  * /
  9. 公共 类 帐户{
  10.     私人 长的ID;
  11.     私人 弦乐LOGINNAME;
  12.     私人 弦乐密码;
  13.     私人 弦乐电子邮件;
  14.     私人 弦乐手机;
  15.     私人 日期registedTime;
  17.     / /以下省略所以的设置和获取方法
  18. }
  20.    3.1 ，使用的JdbcTemplate类
  22. Java的代码
  23. 包 com.zxf.dao;
  25. 进口 的java.util.List;
  26. 导入 com.zxf.domain.Account;
  28. / **账户的DAO接口* /
  29. 公共 接口 AccountDao {
  30.     / **新增账户* /
  31.     无效 创建（帐户ACC）;
  32.     / **删除指定账户* /
  33.     无效 删除（帐号ACC）;
  34.     / **更新账户中* /
  35.     无效 更新（帐户ACC）;
  36.     / **查询指定ID的账户* /
  37.     findById帐户（隆ID）;
  38.     / **查询所有账户* /
  39.     列表<Account>的findAll（）;
  40. }
  44. 包 com.zxf.dao;
  46. 进口 的java.sql.ResultSet;
  47. 进口 的java.sql.SQLException;
  48. 导入 的java.sql.Timestamp;
  49. 导入 java.util.Date的;
  50. 进口 的java.util.List;
  52. 导入 了javax.sql.DataSource;
  54. 进口 org.springframework.jdbc.core.JdbcTemplate;
  55. 导入 org.springframework.jdbc.core.RowMapper;
  57. 导入 com.zxf.domain.Account;
  59. / **
  60.  * AccountDao实现类
  61.  *使用的JdbcTemplate来实现
  62.  * /
  63. 公共 类实现 AccountDao的{
  64.     私人 的JdbcTemplate的JdbcTemplate;
  66.     公共 无效 的setDataSource（DataSource的数据源）{
  67.         JdbcTemplate的=  新的 JdbcTemplate（数据源）;
  68.     }
  70.     公共 无效 创建（帐户ACC）{
  71.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”
  72.                 + “手机，registed_time）VALUES（？？？？，NOW（））” ;
  74.         Object []的paramValues​​ = {acc.getPassword acc.getLoginname（），（），
  75.                 acc.getEmail（），acc.getCellphone（）};
  77.         jdbcTemplate.update（SQL，paramValues）;
  78.     }
  81.     公共 无效 删除（帐户ACC）{
  82.         字符串的sql =  “DELETE WHERE ID =？”帐户;
  83.         paramValues​​对象[] = {acc.getId（）};
  85.         jdbcTemplate.update（SQL，paramValues）;
  86.     }
  88.     公共 无效 更新（帐户ACC）{
  89.         弦乐的sql =  “UPDATE帐户SET LOGINNAME的=？，密码=？，电子邮件=？”
  90.             + “手机=？WHERE ID =？” ;
  92.         Object []的paramValues​​ = {acc.getPassword acc.getLoginname（），（），
  93.             acc.getCellphone acc.getEmail（），（），acc.getId（）};
  95.         jdbcTemplate.update（SQL，paramValues）;
  96.     }
  98.     @ SuppressWarnings （“未选中” ）
  99.     公共 列表<Account>的findAll（）{
  100.         字符串的sql =  “SELECT * FROM帐户” ;
  101.         返回 jdbcTemplate.query（SQL，：  新 AccountRowMapper（））;
  102.     }
  104.     公共 帐户findById（长ID）{
  105.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;
  106.         Object []的paramValues​​ = {ID};
  107.         返回 （帐户）的JdbcTemplate。
  108.                     queryForObject（SQL，paramValues，：  新 AccountRowMapper（））;
  109.     }
  111.     / /把结果集封装成帐户对象的包装类
  112.     私人 静态 最终 类 AccountRowMapper  实现 RowMapper的{
  113.         公共的 对象mapRow（结果集RS，  INT  ROWNUM）  抛出 的SQLException {
  114.             帐户ACC =  新 帐户（）;
  115.             acc.setId（rs.getLong（“ID” ））;
  116.             acc.setLoginname（rs.getString（登录名“ ））;
  117.             acc.setPassword（rs.getString（ “ 密码” ））;
  118.             acc.setEmail（rs.getString（ “ 电子邮件” ））;
  119.             acc.setCellphone（rs.getString（ “ 手机” ））;
  121.             时间戳温度= rs.getTimestamp（“registed_time” ）;
  122.             （温度！=  0 ）{
  123.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;
  124.             }
  125.             返回 ACC;
  126.         }
  127.     }
  128. }
  130.   3.2 ，使用NamedParameterJdbcTemplate类类
  132. Java的代码
  133. 包 com.zxf.dao;
  135. 进口 的java.sql.ResultSet;
  136. 进口 的java.sql.SQLException;
  137. 导入 的java.sql.Timestamp;
  138. 导入 java.util.Date的;
  139. 导入 的java.util.HashMap;
  140. 进口 的java.util.List;
  141. 导入 的java.util.Map;
  143. 导入 了javax.sql.DataSource;
  145. 导入 org.springframework.jdbc.core.RowMapper;
  146. 导入 org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
  147. 导入 org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
  148. 进口 org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
  149. 导入 org.springframework.jdbc.core.namedparam.SqlParameterSource;
  151. 导入 com.zxf.domain.Account;
  153. / **
  154.  *使用NamedParameterJdbcTemplate类来实现AccountDao接口
  155.  * /
  156. 公共 类实现 AccountDao的{
  157.     / /带命名参数功能的JDBC模板类实例
  158.     私人 NamedParameterJdbcTemplate类的JdbcTemplate;
  160.     公共 无效 的setDataSource（DataSource的数据源）{
  161.         的JdbcTemplate =  新 NamedParameterJdbcTemplate类（数据源）;
  162.     }
  164.     公共 无效 创建（帐户ACC）{
  165.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”
  166.                 +  “手机，registed_time）”
  167.                 +  “VALUES（登录名，密码，电子邮件，手机，NOW（））” ;
  168.         / /使用一个Bean的对象的属性值作为命名参数的值
  169.         SqlParameterSource的namedParameters =
  170.                 新 组件属性SQL参数源（ACC）;
  172.         这jdbcTemplate.update（SQL，namedParameters）;
  173.     }
  176.     公共 无效 删除（帐户ACC）{
  177.         字符串的sql =  “DELETE FROM帐户WHERE ID =：ID” ;
  178.         / /使用指定的值来代替命名参数
  179.         SqlParameterSource的namedParameters =
  180.                 新 MapSqlParameterSource（“ID” ，acc.getId（））;
  182.         这jdbcTemplate.update（SQL，namedParameters）;
  183.     }
  185.     公共 无效 更新（帐户ACC）{
  186.         字符串的sql =  “ ​​更新账户的SET LOGINNAME =：登录名。”
  187.                 +  “密码：密码，电子邮件：电子邮件，”
  188.                 +  手机=手机WHERE ID =：ID“ ;
  189.         / /使用地图对象中的键/值对来代替多个命名参数的实际值
  190.         地图<String, namedParameters对象> =  新 的HashMap <String,对象>（）;
  191.         namedParameters.put（ “ 登录名” ，acc.getLoginname（））;
  192.         namedParameters.put（ “ 密码” ，acc.getPassword（））;
  193.         namedParameters.put（ “ 电子邮件” ，acc.getEmail（））;
  194.         namedParameters.put（ “ 手机” ，acc.getCellphone（））;
  195.         namedParameters.put（“ID” ，acc.getId（））;
  197.         这jdbcTemplate.update（SQL，namedParameters）;
  198.     }
  200.     @ SuppressWarnings （“未选中” ）
  201.     公共 列表<Account>的findAll（）{
  202.         字符串的sql =  “SELECT * FROM帐户” ;
  203.         / /通过getJdbcOperations（）来访问只有在使用JdbcTemplate中拥有的功能
  204.         返回 的JdbcTemplate
  205.                    getJdbcOperations（）
  206.                    查询（SQL，：  新 AccountRowMapper（））;
  207.     }
  209.     公共 帐户findById（长ID）{
  210.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;
  211.         / /使用指定的值来代替命名参数
  212.         SqlParameterSource的namedParameters =
  213.                 新 MapSqlParameterSource（ “ 身份证” ，身份证）;
  214.         返回 （帐户）的JdbcTemplate
  215.                     查询（SQL，namedParameters  新 AccountRowMapper（））;
  216.     }
  218.     / /把结果集封装成帐户对象的包装类
  219.     私人 静态 最终 类 AccountRowMapper  实现 RowMapper的{
  220.         公共的 对象mapRow（结果集RS，  INT  ROWNUM）  抛出 的SQLException {
  221.             帐户ACC =  新 帐户（）;
  222.             acc.setId（rs.getLong（“ID” ））;
  223.             acc.setLoginname（rs.getString（登录名“ ））;
  224.             acc.setPassword（rs.getString（ “ 密码” ））;
  225.             acc.setEmail（rs.getString（ “ 电子邮件” ））;
  226.             acc.setCellphone（rs.getString（ “ 手机” ））;
  227.             时间戳温度= rs.getTimestamp（“registed_time” ）;
  228.             （温度！=  0 ）{
  229.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;
  230.             }
  231.             返回 ACC;
  232.         }
  233.     }
  234. }
  236.   3.3 ，使用SimpleJdbcTemplate类类
  237. Java的代码
  238. 包 com.zxf.dao;
  240. 进口 的java.sql.ResultSet;
  241. 进口 的java.sql.SQLException;
  242. 导入 的java.sql.Timestamp;
  243. 导入 java.util.Date的;
  244. 进口 的java.util.List;
  246. 导入 了javax.sql.DataSource;
  248. 导入 org.springframework.jdbc.core.simple.ParameterizedRowMapper;
  249. 进口 org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
  251. 导入 com.zxf.domain.Account;
  253. / **
  254.  *使用SimplateJdbcTemplate来实现AccountDao接口
  255.  * /
  256. 公共 类实现 AccountDao的{
  257.     私人 SimpleJdbcTemplate类的JdbcTemplate;
  259.     公共 无效 的setDataSource（DataSource的数据源）{
  260.         的JdbcTemplate =  新 SimpleJdbcTemplate类（数据源）;
  261.     }
  263.     公共 无效 创建（帐户ACC）{
  264.         弦乐的sql =  “INSERT INTO帐户（登录名，密码，电子邮件，”
  265.                 + “手机，registed_time）VALUES（？？？？，NOW（））” ;
  267.         这jdbcTemplate.update（SQL acc.getLoginname（）
  268.                                       acc.getPassword（），
  269.                                       acc.getEmail（），
  270.                                       acc.getCellphone（））;
  271.     }
  273.     公共 无效 删除（帐户ACC）{
  274.         字符串的sql =  “DELETE WHERE ID =？”帐户;
  276.         jdbcTemplate.update（SQL，acc.getId（））;
  277.     }
  279.     公共 无效 更新（帐户ACC）{
  280.         弦乐的sql =  “UPDATE帐户SET LOGINNAME的=？，密码=？，电子邮件=？”
  281.             + “手机=？WHERE ID =？” ;
  283.         这jdbcTemplate.update（SQL acc.getLoginname（）
  284.                                       acc.getPassword（），
  285.                                       acc.getEmail（），
  286.                                       acc.getCellphone（），
  287.                                       acc.getId（））;
  288.     }
  290.     公共 列表<Account>的findAll（）{
  291.         字符串的sql =  “SELECT * FROM帐户” ;
  292.         返回 jdbcTemplate.query（SQL，：  新 AccountRowMapper（））;
  293.     }
  295.     公共 帐户findById（长ID）{
  296.         字符串的sql =  “SELECT * FROM帐户WHERE ID =？” ;
  297.         返回 jdbcTemplate.queryForObject（SQL，  新 AccountRowMapper（），身份证）;
  298.     }
  300.     / /把结果集封装成帐户对象的包装类
  301.     私人 静态 最终 类 AccountRowMapper
  302.             实现 ParameterizedRowMapper的<Account> {
  303.         公众的 帐户方法mapRow（结果集RS，  INT  ROWNUM）
  304.                 抛出 SQLException异常{
  305.             帐户ACC =  新 帐户（）;
  306.             acc.setId（rs.getLong（“ID” ））;
  307.             acc.setLoginname（rs.getString（登录名“ ））;
  308.             acc.setPassword（rs.getString（ “ 密码” ））;
  309.             acc.setEmail（rs.getString（ “ 电子邮件” ））;
  310.             acc.setCellphone（rs.getString（ “ 手机” ））;
  311.             时间戳温度= rs.getTimestamp（“registed_time” ）;
  312.             （温度！=  0 ）{
  313.                 （新 acc.setRegistedTime的 日期（temp.getTime（）））;
  314.             }
  315.             返回 ACC;
  316.         }
  317.     }
  318. }
  321. 包 com.zxf.service;
  323. 进口 的java.util.List;
  325. 导入 com.zxf.dao.AccountDao;
  326. 导入 com.zxf.domain.Account;
  328. / **
  329.  *帐户业务逻辑类
  330.  * @作者z_xiaofei168
  331.  * /
  332. 公共 类 的AccountService {
  333.     私人 AccountDao accountDao;
  335.     / / setter方法​​注入
  336.     公共的 无效 setAccountDao（AccountDao accountDao）{
  337.         accountDao = accountDao;
  338.     }
  340.     公共 无效 创建（帐户ACC）{
  341.         accountDao.create（ACC）;
  342.     }
  344.     公共 无效 删除（帐户ACC）{
  345.         accountDao.delete（ACC）;
  346.     }
  348.     公共 无效 更新（帐户ACC）{
  349.         accountDao.update（ACC）;
  350.     }
  352.     公共 帐户findById（长ID）{
  353.         返回 accountDao.findById（ID）;
  354.     }
  356.     公共 列表<Account>的findAll（）{
  357.         返回 accountDao.findAll（）;
  358.     }
  359. }
本文链接地址: spring JDBC的支持使用实例源码介绍

Related posts:

  1. PROPAGATION_REQUIRED事务介绍详解
  2. JSP通过JDBC驱动MySQL数据库jar文件mysql-connector-java-3.1.8-bin.jar下载以及使用说明
  3. 什么是JDBC，概述
  4. jsp中JAVABEAN用法之setProperty实例源码
  5. jsp中JAVABean（UseBean）GetProperty用法实例源码说明
  6. 怎么使用JavaBean组件，调用JavaBean组件过程详解，属性、方法和事件
  7. JDBC之Statement,PreparedStatement,CallableStatement之间有什么区别