第五章 征服数据库

5.1 数据库的访问哲学

　　DAO是数据访问对象（data access object）的缩写。

5.1.1 了解Spring的数据访问异常体系

 可能抛出的SQLException常见问题：

• 应用程序无法连接数据库；
• 要执行的查询有语法错误
• 查询中所使用的表和列不存在
• 视图插入或更新数据违反了数据库完整性约束

Spring的凭条无关持久化异常

spring的异常都继承自DataAccessException（他是一个非检查型异常）。

5.1.2 数据访问模板化

spring将数据访问过程中固定的和可变的部分明确划分为两个不同的类：模板类（template）和回调（callback）。模板管理过程汇总固定的部分，回调处理自定义的数据访问代码。

5.1.3 使用DAO支持类

应用程序的DAO继承自JdbcDaoSupport，调用getJdbcTemplate（）方法获得JcbcTemplate；可以直接处理JDBC连接；

5.2 配置数据源

spring提供了在Spring上下文配置数据源Bean的多种方式，包括：

• 通过JDBC驱动成语定义的数据源
• 通过JNDI查找数据源
• 连接池的数据源

5.2.1 使用JNDI数据源

 先略过....

5.2.2 使用数据源连接池

首先配置pom.xml,用dbcp的jar提供连接池功能：

<!-- 配置数据源的链接dbcp（ 提供链接池功能）-->
      <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.3</version>
    </dependency>

下载的jar包如下：

在springbean.xml中配置：

<!--基于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/test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="mysql"></property>
         <property name="initialSize" value="5"></property>
         <property name="maxActive" value="10"></property>
     </bean>

测试代码：

package com.springinaction.test;

import org.apache.commons.dbcp.BasicDataSource;
import org.junit.Test;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.springinaction.springidol.Auditorium;
import com.springinaction.springidol.Instrumentalist;
import com.springinaction.springidol.Magician;
import com.springinaction.springidol.MindReader;
import com.springinaction.springidol.OneManBand;
import com.springinaction.springidol.Performer;
import com.springinaction.springidol.PoeticJuggler;
import com.springinaction.springidol.Stage;
import com.springinaction.springidol.Thinker;
import com.springinaction.springidol.Ticket;
import com.springinaction.springidol.Volunteer;


public class TestCase {
    
    //这个ClassPathXmlApplicationContext是springframe-context中
    //org.springframework.context.support包下的类
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring/springbean.xml");//注意路径
    
    //测试数据源配置
    @Test
    public void testData() throws Exception {
        
        BasicDataSource dataSource = (BasicDataSource)ac.getBean("dataSource");

        System.out.println(dataSource.getInitialSize());
        
        System.out.println(dataSource.getDriverClassName());

    }
    
    
    
}

结果如下：

5.2.3 基于JDBC驱动的数据源

spring提供了两种数据源供选择（org.springframework,jdbc,datasource）:

• DriverManagerDataSource:在每个连接请求时都会范湖一个新建的链接。与DBCP的BasicDataSource不同，由DriverManagerDataSource提供的链接并没有进行池化管理。
• SingleConnectionDataSource：在每个链接请求时都会返回同一个链接，

配置spring-jdbc，首先pom.xml中：

<!-- spring-jdbc配置数据源 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.2.9.RELEASE</version>
    </dependency>

会引进两个包，一个jdbc包，一个事物处理包：

 <!--基于dbcp 配置数据源 -->
     <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/test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="mysql"></property>
         <!-- <property name="initialSize" value="5"></property>
         <property name="maxActive" value="10"></property> -->
     </bean>

在pom.xml配置中引入mysql数据库的驱动包：

<!-- mysql的链接的驱动包 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.40</version>
    </dependency>

//测试spring数据源配置
    @Test
    public void testSpringData() throws Exception {
        
        DriverManagerDataSource dataSource = (DriverManagerDataSource)ac.getBean("dataSource");
        
        Connection connection = dataSource.getConnection();
    
        Statement createStatement = connection.createStatement();
        
        ResultSet rs = createStatement.executeQuery("select * from  user");
        
        while(rs.next()){
            System.out.println(rs.getString("username"));
        }
        
    }

结果:

5.3 在Spring中使用JDBC

5.3.1 失控的JDBC代码

原生的jdbc代码，创建链接和处理异常，以及关闭链接等都是一样的操作。可以将其提取出来成为一个模板。

5.3.2 使用JDBC模板

spring将数据访问的样板式代码提取到模板类中。Spring为JDBC提供了3个模板类使用：

• JdbcTemplate：最基本的Spring JDBC模板，这个模板支持最简单的JDBC数据库访问功能以及简单的索引参数查询。
• NameParameterJDbcTeplate：使用该模板类执行查询时，可以将查询值以命名参数的形式绑定带SQL中，而不是见到你的索引参数。
• SimpleJdbcTemplate：该模板类利用Java5的一些特性，如自定装箱、泛型以及可变参数列表来简化JDBC模板使用；

使用SimpleJdbcTemplate访问数据库（写完之后发现Spring3.0.0左右的版本有SimpleJdbcTemplate这个类，而我之前一直用的4.2.9这个版本，于是，为了配合这本书，又换成了老版本，技术更新的快，这本书老了）：

用法不难：

首先数据库表（创建如下的表，我用的mysql，数据随便写）：

需要下面几个类：

model:

package com.springinaction.model;

/**
 * 
 * @ClassName: User 
 * @Description: 用户的model类
 * @author mao
 * @date 2017年3月29日 下午11:57:39 
 *
 */
public class User {
    
    private int id;
    private String userName;
    private String birthday;
    private String sex;
    private String address;
    
    public User() {
        
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", birthday="
                + birthday + ", sex=" + sex + ", address=" + address + "]";
    }
    
    
    
    
    
}

dao接口：

package com.springinaction.dao;

import com.springinaction.model.User;

/**
 * 
 * @ClassName: UserDao 
 * @Description: 用户dao的接口
 * @author mao
 * @date 2017年3月29日 下午11:58:50 
 *
 */
public interface UserDao {
    
    public void addUser(User user);
    
}

dao的实现类（可以看到里面的东西都过时了，被划了横线）：

package com.springinaction.dao.impl;

import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;

import com.springinaction.dao.UserDao;
import com.springinaction.model.User;

/**
 * 
 * @ClassName: JdbcUserDao 
 * @Description: UserDao的实现类
 * @author mao
 * @date 2017年3月29日 下午11:59:45 
 *
 */
public class JdbcUserDao implements UserDao{
    
    //过时了都，4.2.9版本都没有这个类，哎，这书太老了
    private SimpleJdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(SimpleJdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    
    public void addUser(User user){
        
        jdbcTemplate.update("update user set username=? where id=?",
                user.getUserName(),
                user.getId()
                );
    }
}

springbean.xml

<?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:aop="http://www.springframework.org/schema/aop" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
    
     <!--注解形式的 组件扫描 -->
     <context:component-scan 
        base-package="com.springinaction.springidol"></context:component-scan>
     
     
     <!--基于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/test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="mysql"></property>
         <property name="initialSize" value="5"></property>
         <property name="maxActive" value="10"></property>
     </bean> -->
     
     <!--基于dbcp 配置数据源 -->
     <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/test"></property>
         <property name="username" value="root"></property>
         <property name="password" value="mysql"></property>
         <!-- <property name="initialSize" value="5"></property>
         <property name="maxActive" value="10"></property> -->
     </bean>
    
    <!-- 使用SimpleJdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.simple.SimpleJdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>
    
    <!-- dao层 -->
    <bean id="jdbcUserDao" class="com.springinaction.dao.impl.JdbcUserDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    
</beans>

测试代码：

//测试SimpleJdbcTemplate
    //测试spring数据源配置
    @Test
    public void testTemplate() throws Exception {
        
        UserDao userDao = (UserDao)ac.getBean("jdbcUserDao");
        
        User user = new User();
        user.setId(1);
        user.setUserName("测试用户");
        userDao.addUser(user);
        
        
    }

测试是是成功的，整个过程也可以用注解扫面的方式，不是很难，就是过时了；

 源码下载地址