spring框架计算

Spring4 JDBC详解

在事先的Spring4 IOC详解
的小说中,并不曾介绍使用外部属性的知识点。未来使用配置c3p0连接池的契机来共同念书。本章内容主要有五个部分:配置c3p0(重点)和
使用 Spring JDBC模版。

spring框架总计(04)—-介绍的是Spring中的JDBC模板,springjdbc

1.1  Jdbc模板概述

它是spring框架中提供的二个对象,是对原始Jdbc
API对象的简练包装
。spring框架为我们提供了广大的操作模板类,入下图所示:

图片 1

大家明天的台柱在spring-jdbc-4.24.RELEASE.jar中,我们在导包的时候,除了要导入这一个jar包外,还索要导入3个spring-tx-4.2.4.RELEASE.jar(它是和工作相关的)。

① 、Spring中的jdbc模板入门

预备条件

导入spring-jdbc的jar包

        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-jdbc</artifactId>  
            <version>4.1.6.RELEASE</version>  
        </dependency>  

创办数据表

SET FOREIGN_KEY_CHECKS=0;  
-- ----------------------------  
-- Table structure for `itdragon`  
-- ----------------------------  
DROP TABLE IF EXISTS `itdragon`;  
CREATE TABLE `itdragon` (  
  `id` int(11) NOT NULL AUTO_INCREMENT,  
  `account` varchar(255) NOT NULL,  
  `password` varchar(255) NOT NULL,  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB DEFAULT CHARSET=utf8;  

1.1.1.   创造工程、引入jar包

图片 2

配置c3p0

c3p0的外表属性文件(能够在无需重启系统的地方下修改系统环境变量):db.properties。
db.properties文件中,user 和 password 分别代表 mysql连接
的账号和密码。driverClass 是加载的驱动。
jdbcUrl 是延续数据库的路径。格式是
jdbc:mysql://ip:port/数据库名(jdbc:mysql://localhost:3306/spring)
若果ip地址是地面,port是3306 是足以简写为 jdbc:mysql:///+数据库名。
initPoolSize 是
池内早先的数据连接个数,maxPoolSize是最达累斯萨拉姆接个数。和线程池是相同的概念。
假定您对那么些不是很理解,能够先看看jdbc操作mysql数据库

jdbc.user=root  
jdbc.password=root  
jdbc.driverClass=com.mysql.jdbc.Driver  
jdbc.jdbcUrl=jdbc:mysql:///spring  

jdbc.initPoolSize=5  
jdbc.maxPoolSize=10  

中央文件applicationContext.xml
,首先要钦命导入的财富context:property-placeholder
location从类路径下加载外部属性文件db.properties。
布局一个c3p0的bean,和日常bean一样。只是赋值采纳el表达式${}。再布署八个jdbc的沙盘bean就能够了。

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">  

    <!-- 导入资源文件 -->  
    <context:property-placeholder location="classpath:db.properties"/>  

    <!-- 配置 C3P0 数据源 -->  
    <bean id="dataSource"  
        class="com.mchange.v2.c3p0.ComboPooledDataSource">  
        <property name="user" value="${jdbc.user}"></property>  
        <property name="password" value="${jdbc.password}"></property>  
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>  
        <property name="driverClass" value="${jdbc.driverClass}"></property>  

        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>  
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>  
    </bean>  

    <!-- 配置 Spirng 的 JdbcTemplate -->  
    <bean id="jdbcTemplate"   
        class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  

    <!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数 -->  
    <bean id="namedParameterJdbcTemplate"  
        class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">  
        <constructor-arg ref="dataSource"></constructor-arg>      
    </bean>  

</beans>  

值得注意的是,在安插JdbcTemplate是用属性注入的艺术,当然也能够用构造注入。但在配备NamedParameterJdbcTemplate只可以通过结构注入的格局。源码如下:

/*      */   public JdbcTemplate(DataSource dataSource)
/*      */   {
/*  166 */     setDataSource(dataSource);
/*  167 */     afterPropertiesSet();
/*      */   }

/*     */   public NamedParameterJdbcTemplate(DataSource dataSource)
/*     */   {
/*  89 */     Assert.notNull(dataSource, "DataSource must not be null");
/*  90 */     this.classicJdbcTemplate = new JdbcTemplate(dataSource);
/*     */   }

1.1.2.   创设测试表

CREATE TABLE account(

         id BIGINT PRIMARY KEY AUTO_INCREMENT,

         NAME VARCHAR(40),

         money DOUBLE

)CHARACTER SET utf8 COLLATE utf8_general_ci;

Spring JDBC模版

先温故一下Mysql的着力语法
新增:INSERT [INTO] 表名 [(列名1, 列名2, 列名3, …)] VALUES (值1,
值2, 值3, …);
修改:UPDATE 表名 SET 列名=新值 WHERE 更新标准;
去除:DELETE FROM 表名 WHERE 删除条件;
查询:SELECT 列名称 FROM 表名称 [查询条件];
操作Mysql的测试方法,JdbcTemplate只是贰个JDBC的小工具。很多作用还无法促成,比如级联操作。真正的多寡处理,照旧提交Hibernate等OPAJEROM框架。

import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
import javax.sql.DataSource;  
import org.junit.Test;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
import org.springframework.jdbc.core.BeanPropertyRowMapper;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.jdbc.core.RowMapper;  
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;  
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;  
import org.springframework.jdbc.core.namedparam.SqlParameterSource;  

public class MyJDBCMain {  

    private ApplicationContext ctx = null;  
    private JdbcTemplate jdbcTemplate = null; // JdbcTemplate 只是一个 JDBC的小工具,不支持级联属性  
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate = null; // 支持具名参数,提高代码的可读性。  

    // 构造块,在创建对象的时候调用  
    {  
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");  
        jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");  
        namedParameterJdbcTemplate = (NamedParameterJdbcTemplate) ctx.getBean("namedParameterJdbcTemplate");  
    }  

    // 测试是否连上数据库连接池  
    @Test  
    public void connectionDataSource() {  
        System.out.println("----------- connectionDataSource ----------");  
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");  
        try {  
            // 若能打印com.mchange.v2.c3p0.impl.NewProxyConnection 说明连接成功。  
            System.out.println(dataSource.getConnection());  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
        System.out.println("^^^^^^^^^^^ connectionDataSource ^^^^^^^^^^^");  
    }  

    /** 
     * 直接对Mysql数据进行增,删,改,查,统计的操作 
     */  
    @Test  
    public void crudMysqlOperation() {  
        System.out.println("----------- crudMysqlOperation ----------");  
        // 插入  
        String insertSql = "INSERT INTO ITDragon (account, password) VALUES (?,?)";  
        System.out.println("insert result : " + jdbcTemplate.update(insertSql, "itdragon", "pwdItdragon"));  
        // 修改  
        String updateSql = "UPDATE ITDragon SET password = ? WHERE account = ?";  
        System.out.println("update result : " + jdbcTemplate.update(updateSql, "passwordItdragon", "itdragon"));  
        // 查询  
        String querySql = "SELECT * FROM ITDragon";  
        List<Map<String, Object>> results = jdbcTemplate.queryForList(querySql);  
        System.out.println("query result : " + results);  
        // 删除  
        String deleteSql = "DELETE FROM ITDragon WHERE account = ?";  
        System.out.println("delete result : " + jdbcTemplate.update(deleteSql, "itdragon"));  
        // 统计  
        String countSql = "SELECT count(id) FROM ITDragon";  
        System.out.println("count result : " + jdbcTemplate.queryForObject(countSql, Long.class));  
        System.out.println("^^^^^^^^^^^ crudMysqlOperation ^^^^^^^^^^^");  
    }  

    /** 
     * 直接对Mysql数据进行批量的增,删,改的操作 
     */  
    @Test  
    public void batchCrudMysqlOperation() {  
        System.out.println("----------- batchCrudMysqlOperation ----------");  
        // 批量插入  
        String insertSql = "INSERT INTO ITDragon (account, password) VALUES (?,?)";  
        List<Object[]> insertArgs = new ArrayList<>();  
        insertArgs.add(new Object[]{"itdragon", "pwdItdragon"});  
        insertArgs.add(new Object[]{"blog", "pwdBlog"});  
        System.out.println("batch insert result : " + jdbcTemplate.batchUpdate(insertSql, insertArgs));  
        // 查询  
        String querySql = "SELECT * FROM ITDragon";  
        List<Map<String, Object>> results = jdbcTemplate.queryForList(querySql);  
        System.out.println("query result : " + results);  
        // 批量修改  
        String updateSql = "UPDATE ITDragon SET password = ? WHERE account = ?";  
        List<Object[]> updateArgs = new ArrayList<>();  
        updateArgs.add(new Object[]{"passwordItdragon", "itdragon"});  
        updateArgs.add(new Object[]{"passwordBlog", "blog"});  
        System.out.println("batch udpate result : " + jdbcTemplate.batchUpdate(updateSql, updateArgs));  
        // 批量删除  
        String deleteSql = "DELETE FROM ITDragon WHERE account = ?";  
        List<Object[]> deleteArgs = new ArrayList<>();  
        deleteArgs.add(new Object[]{"itdragon"});  
        deleteArgs.add(new Object[]{"blog"});  
        System.out.println("batch delete result : " + jdbcTemplate.batchUpdate(deleteSql, deleteArgs));  
        // 统计  
        String countSql = "SELECT count(id) FROM ITDragon";  
        System.out.println("count result : " + jdbcTemplate.queryForObject(countSql, Long.class));  
        System.out.println("^^^^^^^^^^^ batchCrudMysqlOperation ^^^^^^^^^^^");  
    }  

    /** 
     * 对象的增删改查,改用 NamedParameterJdbcTemplate 
     * 要求:参数名要和类的属性名一样 
     * 好处:之前的参数用?表示,不直观,代码的可读性较差,出错率较高。 
     * 缺点:多敲几个字母 
     */  
    @Test  
    public void crudObjectOperation() {  
        System.out.println("----------- crudObjectOperation ----------");  
        // 插入  
        String insertSql = "INSERT INTO ITDragon (account, password) VALUES (:account,:password)";  
        ITDragon itDragon = new ITDragon();  
        itDragon.setAccount("itdragon");  
        itDragon.setPassword("pwdItdragon");  
        SqlParameterSource paramSource = new BeanPropertySqlParameterSource(itDragon);  
        System.out.println("insert object result : " + namedParameterJdbcTemplate.update(insertSql, paramSource));  
        // 查询  
        String querySql = "SELECT * FROM ITDragon";  
        // 使用 RowMapper 指定映射结果集的行  
        RowMapper<ITDragon> rowMapper = new BeanPropertyRowMapper<>(ITDragon.class);  
        List<ITDragon> results = namedParameterJdbcTemplate.query(querySql, rowMapper);  
        System.out.println("query object result : " + results);  
        // 更新和删除 也是update方法,这里不做过多的描述   
        System.out.println("^^^^^^^^^^^ crudObjectOperation ^^^^^^^^^^^");  
    }  

}  

public class ITDragon {

    private Integer id;
    private String account;
    private String password;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "ITDragon [id=" + id + ", account=" + account + ", password="
                + password + "]";
    }

}

----------- connectionDataSource ----------  
com.mchange.v2.c3p0.impl.NewProxyConnection@16ba2b8  
^^^^^^^^^^^ connectionDataSource ^^^^^^^^^^^  
----------- crudMysqlOperation ----------  
insert result : 1  
update result : 1  
query result : [{id=4, account=itdragon, password=passwordItdragon}]  
delete result : 1  
count result : 0  
^^^^^^^^^^^ crudMysqlOperation ^^^^^^^^^^^  
----------- batchCrudMysqlOperation ----------  
batch insert result : [I@3c9dd8  
query result : [{id=10, account=itdragon, password=pwdItdragon}, {id=11, account=blog, password=pwdBlog}]  
batch udpate result : [I@c094f6  
batch delete result : [I@1917d6d  
count result : 0  
^^^^^^^^^^^ batchCrudMysqlOperation ^^^^^^^^^^^  
----------- crudObjectOperation ----------  
insert object result : 1  
query object result : [ITDragon [id=12, account=itdragon, password=pwdItdragon]]  
^^^^^^^^^^^ crudObjectOperation ^^^^^^^^^^^  

从打字与印刷的结果能够看来,假如插入,修改,删除一条数据,成功就赶回1。假使是批量操作,则赶回的是八个int[]
数组。
好了!到那边,Spring4
的JDBC就讲完了。有关jdbc的事体,就放置下一章介绍。喜欢的话可以点个赞哦!

一小点成长,一丝丝不错。如若有啥样提出和难点能够留言。

1.1.3.   创制测试类

小心:供给导入c3p0的jar包

public class TestJdbcTemplate {

 

   @Test

   public void test1(){

      //创制jdbc模板对象

      JdbcTemplate jdbcTemplate = new JdbcTemplate();

      //创建c3p0数据源

      ComboPooledDataSource dataSource = new
ComboPooledDataSource();

      try {

         dataSource.setDriverClass(“com.mysql.jdbc.Driver”);

        
dataSource.setJdbcUrl(“jdbc:mysql://localhost:3306/spring_itheima10”);

         dataSource.setUser(“root”);

         dataSource.setPassword(“123456”);

      } catch (PropertyVetoException e) {

         e.printStackTrace();

      }

      //设置数据源

      jdbcTemplate.setDataSource(dataSource);

      //插入操作

      jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,”张三”,1000.0);

}

1.1.4.   将JdbcTemplate交给Spring管理(讲某一指标大概围着提交spring进行管制,需求的时候平素从评释中展开田管是完毕,下落耦合性)

<!– 配置JdbcTemplate –>

       <bean id=“jdbcTemplate”
class=“org.springframework.jdbc.core.JdbcTemplate”>

             <property name=“dataSource”
ref=“dataSource”></property>

       </bean>

 

<!– 配置数据源 –>

       <bean id=“dataSource”
class=“com.mchange.v2.c3p0.ComboPooledDataSource”>

          <property name=“driverClass”
value=“com.mysql.jdbc.Driver”></property>

          <property name=“jdbcUrl”
value=“jdbc:mysql://localhost:3306/spring_itheima10”></property>

          <property name=“user” value=“root”></property>

          <property name=“password”
value=“123456”></property>

       </bean>

1.1.5.   在DAO中使用JdbcTemplate

n  创建AccountDao接口

public interface AccountDao {

   public void save(Account account);

}

n  创建AccountDaoImpl实现类

public class AccountDaoImpl  implements AccountDao {

   private JdbcTemplate jdbcTemplate;

  

   }

  

   @Override

   public void save(Account account) {

      this.jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,account.getName(),account.getMoney());

   }

}

1.1.6.   把JdbcTemplate注入给DAO(然后再通过spring把持久层中需求的东西添加给那一个表上的是一向从spring容器中取得,不用从工作层中进行获取)

<bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

          <property name=“jdbcTemplate”
ref=“jdbcTemplate”></property>

 </bean>

 <bean id=“jdbcTemplate”
class=“org.springframework.jdbc.core.JdbcTemplate”>

          <property name=“dataSource”
ref=“dataSource”></property>

  </bean>

<bean id=“dataSource”
class=“com.mchange.v2.c3p0.ComboPooledDataSource”>

          <property name=“driverClass”
value=“com.mysql.jdbc.Driver”></property>

          <property name=“jdbcUrl”
value=“jdbc:mysql://localhost:3306/spring_itheima10”></property>

          <property name=“user” value=“root”></property>

          <property name=“password”
value=“123456”></property>

   </bean>

1.1.7.   编写测试类

/**

    * 测试保存

    */

   @Test

   public void test2(){

      Account account = new Account();

      account.setName(“JAY”);

      account.setMoney(1000.0);

      accountDao.save(account);

   }

 

1.2. 配置DBCP连接池

1.2.1.   导入jar包

图片 3

1.2.2.   配置DBCP连接池

<!– 配置dbcp数据库源 –>

       <bean id=“dataSource”
class=“org.apache.commons.dbcp.BasicDataSource”>

             <property name=“driverClassName”
value=“com.mysql.jdbc.Driver”></property>

             <property name=“url”
value=“jdbc:mysql://localhost:3306/spring”></property>

             <property name=“username”
value=“root”></property>

             <property name=“password”
value=“123456”></property>

       </bean>

1.3. 计划Spring自带的数据库连接池

 <!– 配置spring自带的数目源 –>

 

        <bean id=“dataSource”
class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

          <property name=“driverClassName”
value=“com.mysql.jdbc.Driver”></property>

          <property name=“url”
value=“jdbc:mysql://localhost:3306/spring_itheima10”></property>

          <property name=“username”
value=“root”></property>

          <property name=“password”
value=“123456”></property>

       </bean>

 

总结:

三种艺术:一种是c3p0数据源举办布局,一种是dbcp数据源举行安排,第三种Spring自带的数据源实行配置达成这么些进度中的数据。

 

1.4. 将数据库连接音讯保存到属性文件中

1.4.1.   新建jdbc.properties属性文件

图片 4

 

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/hibernate_itcast55

jdbc.username=root

jdbc.password=123456

 

1.4.2.   在applicationContext.xml中引入jdbc.properties文件

n  配置bean引入

      <!– 配置bean引入jdbc.properties –>

       <bean
class=“org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>

             <property name=“location”
value=“classpath:jdbc.properties”></property>

       </bean>

       

       <!– 配置数据源 –>

       <bean id=“dataSource”
class=“org.springframework.jdbc.datasource.DriverManagerDataSource”>

             <property name=“driverClassName”
value=“${driverClass}”></property>

             <property name=“url”
value=“${jdbcUrl}”></property>

             <property name=“username”
value=“${user}”></property>

             <property name=“password”
value=“${password}”></property>

       </bean>

n  通过context标签引入

 <!– 通过context标签引入jdbc.properties –>

 <context:property-placeholder
location=“classpath:jdbc.properties”/>

提醒:此处不加classpath也行,因为jdbc.properties就置身类路径下,就放在类一般加上。

 

总括:引入jdbc.properties配置文件的三种格局:一 、使用安插bean实行引入(第②种方法)

                                                                     
              二 、通过context格局实行引入

 

1.5. 用到Jdbc模板完结CRUD

 

1.5.1.   新增多少

/**

    * JdbcTemplate之新增

    */

   @Test

   public void test1(){

      jdbcTemplate.update(“insert into account(name,money)
values(?,?)”,”李四”,1000);

   }

 

1.5.2.   修改数据

/**

    * JdbcTemplate之修改

    */

   @Test

   public void test2(){

      jdbcTemplate.update(“update account set money = ? where id =
?”,1100,1);

   }

1.5.3.   删除数据

/**

    * JdbcTemplate之删除

    */

   @Test

   public void test3(){

      jdbcTemplate.update(“delete from account where id = ?”,2);

   }

 查询数据相比较简单此处省略

 

1.1.1.1.        查询某列的值

/**

    * JdbcTemplate之查询某列的值

    */

   @Test

   public void test5(){

      double money = jdbcTemplate.queryForObject(“select money from
account where id = ?”, Double.class, 1);

      System.out.println(money);

   }

1.1.1.1.        查询3个对象

n  创制实体类

public class Account implements Serializable{

 

   private static final long serialVersionUID =
1L;

   private Long id;

   private String name;

   private Double money;

   public Long getId() {

      return id;

   }

   public void setId(Long id) {

      this.id = id;

   }

   public String getName() {

      return name;

   }

   public void setName(String name) {

      this.name = name;

   }

   public Double getMoney() {

      return money;

   }

   public void setMoney(Double money) {

      this.money = money;

   }

   @Override

   public String toString() {

      return “Account [id=” + id + “, name=” + name + “, money=” +
money + “]”;

   }

}

n  创建RowMapper

public class AccountRowMapper implements
RowMapper<Account>{

 

   @Override

   public Account mapRow(ResultSet rs, int rownum) throws
SQLException {

      Account account = new Account();

      account.setId(rs.getInt(“id”));

      account.setName(rs.getString(“name”));

      account.setMoney(rs.getDouble(“money”));

      return account;

   }

 

}

n  查询得到三个对象

/**

    * JdbcTemplate之查询3个对象

    */

   @Test

   public void test4(){

      AccountRowMapper mapper = new AccountRowMapper();

      Account account = jdbcTemplate.queryForObject(“select * from
account where id = ?”, mapper, 1);

      System.out.println(account);

   }

1.1.1.2.        查询八个集合

/**

    * JdbcTemplate之查询三个晤面

    */

   @Test

   public void test6(){

      AccountRowMapper rowMapper = new AccountRowMapper();

      List<Account> accounts = jdbcTemplate.query(“select * from
account”, rowMapper);

      for(int i = 0;i < accounts.size();i++){

         System.out.println(accounts.get(i));

      }

   }

 

1.6. 在DAO中使用JdbcTemplate的二种方法

1.6.1.   格局一:在DAO中央直机关接注入JdbcTemplate

 编写DAO,注入JdbcTemplate

public class AccountDaoImpl implements AccountDao {

  

   private JdbcTemplate jdbcTemplate;

  

   public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

      this.jdbcTemplate = jdbcTemplate;

   }

 

   @Override

   public void save(Account account) {

      jdbcTemplate.update(“insert into account(name,money) values(?,?)”,
account.getName(),account.getMoney());

   }

 

}

   把DAO配置到Spring中

  <bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

         <property name=“jdbcTemplate”
ref=“jdbcTemplate”></property>

  </bean>

 

1.6.2.   方式二:在DAO中使用JdbcDaoSupport

 让DAO继承JdbcDaoSupport

public class AccountDaoImpl extends JdbcDaoSupport
implements AccountDao {

  

   @Override

   public void save(Account account) {

      this.getJdbcTemplate().update(“insert into account(name,money)
values(?,?)”, account.getName(),account.getMoney());

   }

 

}

  给DAO注入DataSource

<bean id=“accountDao”
class=“cn.itcast.dao.impl.AccountDaoImpl”>

       <property name=“dataSource”
ref=“dataSource”></property>

</bean>

 

比较:两版Dao有怎么样不一样吗?

率先种在Dao类中定义JdbcTemplate的措施,适用于拥有配置格局(xml和注释都得以)。

第壹种让Dao继承JdbcDaoSupport的方法,只可以用来基于XML的法子,注脚用持续。

三种dao类中定义jdbcTemplate的法门,适用于拥有的配备方式,(xml和注释都以足以行使的一种办法)

 

② 、第3大块内容介绍———————————————-Spring中的事务控制**

政工的纪念:

l  事务的概念


事务是逻辑上一组操作,组成那组操作各种逻辑单元,要么一起成功,要么一起失利。

l  事务的风味

n  原子性

n  一致性

n  隔离性

n  持久性

l  若是不考虑隔绝性,引发安全题材

n  读问题

u  脏读

u  不可重复读

u  虚读

n  写问题

u  丢失更新

l  消除读难点

n  设置工作隔断级别

u  read uncommitted

read committed

repeatable read

u  Serializable

http://www.bkjia.com/Javabc/1228694.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1228694.htmlTechArticlespring框架总结(04)—-介绍的是Spring中的JDBC模板,springjdbc
1.1 Jdbc模板概述 它是spring框架中提供的二个目的, 是对原始 Jdbc API
对象的简单…