SpringJDBC数据库的基本使用

 本文整理SpringJDBC的基础使用部分内容，在上版的基础上进行了略微修改。

 云笔记项目数据库部分采用的是Spring-MyBatis，前面学过了JDBC，SpringJDBC，Mybatis和Spring-MyBatis，有必要重新复习一下各个数据库连接的使用方法，理解差异点后再开始项目环境配置，磨刀不误砍柴工。

Spring JDBC是什么

 是Spring框架对JDBC的封装，简化对JDBC操作

Spring JDBC编程步骤

 step1 导包 

 spring-webmvc，spring-jdbc，ojdbc，dbcp，junit等。

 在pom.xml中进行如下配置

<dependencies>
<!-- 导入spring-webmvc的jar包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.2.3.RELEASE</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.2.3.RELEASE</version>
<classifier>sources</classifier>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.2.3.RELEASE</version>
<classifier>javadoc</classifier>
</dependency>
<!-- 导入junit测试包-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<classifier>sources</classifier>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<classifier>javadoc</classifier>
</dependency> 

<!-- 导入数据库包 -->
<dependency>
   <groupId>commons-dbcp</groupId>
   <artifactId>commons-dbcp</artifactId>
   <version>1.4</version>
</dependency> 
<dependency>
 <groupId>com.oracle</groupId>
 <artifactId>ojdbc6</artifactId>
 <version>11.2.0.1.0</version>
</dependency> 

<!-- 针对mysql的导包 -->
<dependency>
<groupId>org.wisdom-framework</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34_1</version>
</dependency>

 <!-- 针对spring JDBC导包 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>4.2.3.RELEASE</version>
 </dependency>
 
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>4.2.3.RELEASE</version>
 <classifier>sources</classifier>
 </dependency>
 
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-jdbc</artifactId>
 <version>4.2.3.RELEASE</version>
 <classifier>javadoc</classifier>
 </dependency> 
</dependencies>  
step2 添加Spring JDBC配置文件，主要有两步：

1.读取配置文件，初始化连接池：

类似于以前的工具类DBUtils，先读取properties属性内容，然后初始化连接池BasicDataSource，设置数据库连接驱动，url，用户名和密码等，还可以配置其他参数，如最大连接数maxactive或者等待时间maxwait。

2.将连接池注入到SpringJDBCTemplate里，初始化SpringJDBCTemplate，后面就可以被使用了

<bean //此部分内容省略>
   <!-- 读取properties属性文件 -->
   <util:properties id="db" location="classpath:config.properties">    
   </util:properties>
   <!-- 配置连接池,可以参考DBUtil的方法，这里采用spring创建连接池-->
   <!-- destroy-method方法作用是：当spring容器关闭后，会将连接释放回到连接池，避免资源浪费 -->
   <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
   <property name="driverClassName" value="#{db.driver}"/>
   <property name="url" value="#{db.url}" />
   <property name="username" value="#{db.user}" />
   <property name="password" value="#{db.pwd}" /
</bean>        

<!-- 配置JDBCTemplate -->
<bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
   <!-- 说明JdbcTemplate里有dataSource属性，有setDataSource方法，将连接池注入进去 -->
   <!-- 查看JdbcTemplate源码发现，连接池是通过构造器方式注入的 -->
   <property name="dataSource" ref="ds"></property>
</bean>
    
 <!-- 配置组件扫描 -->
 <context:component-scan base-package="DAO"></context:component-scan>

可以对比下DBUtil里的方法，也是读取properties属性文件，然后初始化BasicDataSource，然后写出建立连接和关闭连接的静态方法供使用，在SpringJDBC下，会使用依赖注入的方式，帮忙初始化连接池，这是Spring的特点，降低耦合度。

package Day03;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;

import Day01.DBUtilByDBCPInMac;

public class DBUtil {
        //数据库连接池
        private static BasicDataSource ds;
        //为不同线程管理连接
        private static ThreadLocal<Connection> tl;
        //不需要实例，只需要调用静态方法
        static {
            try {
                //创建properties
                Properties prop=new Properties();
                //获取文件输入流
                InputStream is=DBUtilByDBCPInMac.class.getClassLoader().getResourceAsStream("day01/config.properties");
                //加载文件输入流
                prop.load(is);
                is.close();
                //读取配置信息    
                //初始化连接池
                ds=new BasicDataSource();
                //设置驱动（Class.forName()）
                ds.setDriverClassName(prop.getProperty("driver"));
                //设置url
                ds.setUrl(prop.getProperty("url"));
                //设置数据库用户名
                ds.setUsername(prop.getProperty("user"));
                //设置数据库密码
                ds.setPassword(prop.getProperty("psw"));
                //设置初始连接数
                ds.setInitialSize(Integer.parseInt(prop.getProperty("initsize")));
                //设置最大连接数
                ds.setMaxActive(Integer.parseInt(prop.getProperty("maxactive")));
                //设置等待时间
                ds.setMaxWait(Integer.parseInt(prop.getProperty("maxwait")));
                //设置最小空闲数
                ds.setMinIdle(Integer.parseInt(prop.getProperty("minidle")));
                //设置最大连接数
                ds.setMaxIdle(Integer.parseInt(prop.getProperty("maxidle")));
                
                //初始化线程本地
                tl=new ThreadLocal<Connection>();
                
                
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
        /**
         * 使用连接池获取连接
         * @return
         * @throws SQLException
         */
        public static Connection getConnection() throws SQLException {
            Connection conn=ds.getConnection();
            tl.set(conn);
            return conn;
        }
        /**
         * 关闭数据库连接
         */
        public static void closeConnection() {
            try {
            Connection conn=tl.get();
            if(conn!=null) {
                //恢复连接为自动提交事务
                conn.setAutoCommit(true);
                //关闭了连接
                conn.close();
                //但是连接池是不关闭连接的，为什么这里可以关闭？
                //因为这里关闭的只是连接池下连接的一个子类，关闭子类不影响连接池的连接
                //而是将连接归还
                tl.remove();
            }
            }catch(Exception e) {
                e.printStackTrace();
            }
            
        }
        
}

step3 配置JDBC Template，生成JDBC模板

JDBCTemplate把一些重复性的代码，比如获取连接关闭连接异常处理都写好了，只需要调用该对象的方法就可以很方便的访问数据库。

step4 调用JDBCTemplate的方法来进行数据库操作，通常将JDBCTemplate注入到DAO，采用依赖注入的package DAO

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import Entity.Employee;

/**
 * Spring JDBC的使用
 *
 */
@Repository("employeeDAO")
public class EmployeeDAO {
    //依赖注入jdbcTemplate
    @Resource(name="jt")//也可以用@Autowired和@Qualifier("jt")组合注解
    private JdbcTemplate jt;
    //把一个员工插入到数据库
    public void save(Employee e) {
        //只需要一条语句，完成自动创建连接，执行sql，关闭连接
        String sql ="INSERT INTO T_TABLE VALUES(2,?,?)";
        Object[] args= {e.getName(),e.getAge()};//元素的位置，跟上述sql一致
        jt.update(sql,args);
    }
    /**
     * 查询所有的员工
     * @return
     */
    //查询所有员工的方法
    public List<Employee> findAll(){
        String sql="SELECT * FROM T_TABLE";
        return jt.query(sql, new EmpRowMapper());
        
    }
    /**
     * 匿名内部类，这个类只能被当前类引用
     * @author
     *
     */
    class EmpRowMapper implements RowMapper<Employee>{
        /**
         * 告诉JDBCTemplate，如何将结果集转换成一个实体对象
         * rowNum：正在被处理的记录的下标，从0开始，为啥它好像在方法中就没用到过？
         */
        public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
            Employee e=new Employee();
            e.setId(rs.getInt("ID"));
            e.setName(rs.getString("NAME"));
            e.setAge(rs.getInt("age"));            
            return e;
        }
        
    }
    /**
     * 使用SpringJDBCTemplate进行查询
     * @param id
     * @return
     */
    public Employee findById(int id) {
        String sql="SELECT * FROM T_TABLE WHERE ID=?";
        Employee emp=null;
        try {
            Object[] object= {id};
            emp=jt.queryForObject(sql, object, new EmpRowMapper());
        }catch(EmptyResultDataAccessException e) {
            //空结果数据访问异常：没有数据查询到时会抛出此异常
            e.printStackTrace();
            return null;
        }
        return emp;
    }
    /**
     * SpringJDBC修改更新的方法
     * @param emp
     */
    public void modify(Employee emp) {
        String sql="UPDATE T_TABLE SET NAME=?,AGE=? WHERE ID=?";
        Object[] args= {emp.getName(),emp.getAge(),emp.getId()};
        jt.update(sql, args);
    }
    /**
     * SpringJDBC删除的方法
     * @param id
     */
    public void delete(int id) {
        String sql="DELETE FROM T_TABLE WHERE ID=?";
        Object[] args= {id};
        jt.update(sql, args);
    }
    

}

（5）使用junit包进行测试数据库操作，SpringJDBC底层还是调用了PreparedStatement，参数绑定在数据对象数组里

package Test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import DAO.EmployeeDAO;
import Entity.Employee;

public class testCase {
    private EmployeeDAO dao;
    /**
     * @before注解修饰的作用是在其他测试方法运行之前会执行
     */
    @Before
    public void init() {
        String config="spring-jdbc.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(config);
        dao=ac.getBean("employeeDAO",EmployeeDAO.class);    
    }
    
    /**
     * 测试springJDBCTemplate
     */
    @Test
    public void test() {
        Employee e=new Employee();
        e.setName("duanyu");e.setAge(20);
        dao.save(e);
    }
    /**
     * 测试查询方法
     */
    @Test
    public void test1() {
        List<Employee> list=dao.findAll();
        System.out.println(list);
        
    }
    /**
     * 根据ID查询的测试
     */
    @Test
    public void test2() {
        Employee emp=dao.findById(2);
        System.out.println(emp);
        
    }
    /**
     * 更新ID为1的员工信息，UPDATE
     */
    @Test
    public void test3() {
        //先查到一个
        Employee employee=dao.findById(2);
        //对信息进行修改
        employee.setAge(employee.getAge()+10);
        dao.modify(employee);
        Employee newEmployee=dao.findById(2);
        System.out.println(newEmployee);
        
    }
    /**
     * 删除id为1的员工，方法测试
     */
    @Test
    public void test4() {
        dao.delete(2);
    }

}

总结

SpringJDBC相比JDBC，降低了耦合度，并且实现自动连接和关闭数据库连接，要方便不少。