Spring中利用JDBC模板完成SQLServer数据库（MySQL一样）各种操作

一、导入jar包
这里的包是测试类的包

这里是Spring需要的各种包

二、配置文件db.property

jdbcUser=数据库的用户名（中文地方自己填写）
jdbcPassword=数据库的密码
jdbcDriver=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbcUrl=jdbc\:sqlserver\://127.0.0.1\:1433;databaseName\= 数据库名字
initPoolSize=5
maxPoolSize=10

三、Spring bean configuration File文件的配置
在这里名字为Application-Context.xml
建立此文件的时候，导入命名空间bean、context、jdbc

<?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:jdbc="http://www.springframework.org/schema/jdbc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd">

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

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

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

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

四、建立测试.java文件
文件名：JDBCTest.java

    private ApplicationContext ctx = null;
    private JdbcTemplate jdbcTemplate = null;
    {
        //建立spring容器
        ctx = new ClassPathXmlApplicationContext("Application-Context.xml");
        jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
    }

五、初始化数据库
建立数据库

create database Spring

建表

create table department(
    id varchar(10) not null,
    name varchar(10) not null,
    primary key(id)
)
create table student(
    id varchar(10) not null,
    name varchar(10) not null,
    sex char(2) check(sex='男' or sex='女'),
    departmentId varchar(10),
    primary key(id),
    foreign key(departmentId) references department(id)
)

插入department表数据

插入student表数据

六、利用DataSource尝试连接SQLServer数据库

/**
     * 利用DataSource连接数据
     */
    @Test
    public void test(){
        //获取DataSource实例
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        try {
            //连接数据库
            dataSource.getConnection();
            System.out.println("连接成功");
        } catch (SQLException e) {
            System.out.println("连接失败");
        }
    }

结果为：（显示数据库连接成功,确保数据库之前可以正常工作）

七、利用JdbcTemplate，更新数据库

    /**
     *更新数据库数据
     *可以执行insert，delete，update语法 
     */
    @Test
    public void testUpdate(){
        String sql = "update student set name=? where id=?";
        jdbcTemplate.update(sql, "小黄","8000114001");
    }

结果为；

八、批量更新数据库

    /**
     * 执行批量更新：批量的Insert、update，delete
     * batchArgs是一个List集合，而集合中是数组，这样可以实现批量添加数据
     */
    @Test
    public void testBatchUpdate(){
        String sql = "insert into student(id,name,departmentId) values(?,?,?)";
        List<Object[]> batchArgs = new ArrayList<>();
        batchArgs.add(new Object[]{"8000114004","小赖","4"});
        batchArgs.add(new Object[]{"8000114005","小浩","1"});
        batchArgs.add(new Object[]{"8000114006","小陈","2"});
        batchArgs.add(new Object[]{"8000114007","小张","3"});
        batchArgs.add(new Object[]{"8000114008","小王","4"});
        jdbcTemplate.batchUpdate(sql, batchArgs);
    }

结果为：

九、建两个基本的类
student.java

package com.hui.spring.jdbc;

public class Student {
    private String id;
    private String name;
    private String sex;
    private Department department;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + sex + ", department=" + department + "]";
    }

}

Department.java

package com.hui.spring.jdbc;

public class Department {
    private String id;
    private String name;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Department [id=" + id + ", name=" + name + "]";
    }

}

十、从数据库中获取数据填充student对象

    /**
     * 从数据库获取对象
     * 注意的是:此处用的方法不是JdbcTemplate.queryForObject(String sql, Class<Student> requiredType, Object... args)
     * 需要调用JdbcTemplate.queryForObject(String sql, RowMapper<Student> rowMapper, Object... args) 
     * 1、其中的RowMapper指定如何去映射结果集的行，常用的实现类为BeanPropertyRowMapper
     * 2、使用SQL中列的别名（数据库中的列名不符合类的成员变量时，使用别名）去进行映射
     * 3、不支持级联属性，即依赖对象不能够通过此实现
     */
    @Test
    public void testQueryForObject(){
        String sql = "select id , name , sex from student where id = ?";
        RowMapper<Student> rowMapper = new BeanPropertyRowMapper<>(Student.class);
        Student student = jdbcTemplate.queryForObject(sql, rowMapper, "8000114001");
        System.out.println(student);
    }

结果为：

十一、利用条件查询语句，获取实例集合，即多个符合条件的student对象的集合

    /**
     * 条件查询语句，得到实体类集合
     * 注意调用的不是queryForList
     */
    @Test
    public void testQueryForList(){
        String sql = "select id , name , sex from student where id != ?";
        RowMapper<Student> rowMapper = new BeanPropertyRowMapper<>(Student.class);
        List<Student> students = jdbcTemplate.query(sql, rowMapper, "8000114001"); 
        System.out.println(students);
    }

结果为：

十二、用条件查询，获取单个值

    /*
     * 获取单个值
     */
    @Test
    public void testQueryForObjectValue(){
        String sql = "select count(*) from student";
        //过时方法
        //long count = jdbcTemplate.queryForLong(sql);
        long count = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(count);

    }

结果为：

这就是利用JdbcTemplate进行数据库各种操作的简单示例。
后加：
十三、在 JDBC 模板中使用具名参数
Application-Context.xml文件中加入以下内容：

<!-- 配置NamedParameterJdbcTemplate,该对象可以使用具名参数，其没有无参数的构造器 ，所以必须为构造器指定参数-->
    <bean id = "namedParameterJdbcTemplate"
        class = "org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"></constructor-arg>

    </bean>写代码片

具名参数的使用一：

    /**
     * 具名参数，可以为参数起名字
     * 1、好处：若有多个参数，则不用再去对应位置，直接对应名字，便于维护
     * 2、缺点：较为麻烦
     */
    @Test
    public void testNameParameterJdbcTemplate(){
        String sql = "insert into student(id,name,sex) values(:id,:name,:sex)";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("id", "8000114009");
        paramMap.put("name", "小鹏");
        paramMap.put("sex", "男");
        namedParameterJdbcTemplate.update(sql, paramMap);
    }
    //结果是数据中添加了上述数据

具名参数的使用二：

    /**
     * 使用具名参数时，可以使用update（String sql,SqlParameterSource)方法进行更新操作
     * 1、SQL语句中的参数名和类的属性一致
     * 2、使用SqlParameterSource的BeanPropertySqlParameterSource实现类作为参数。
     */
    @Test
    public void testNamedParameterJdbcTemplate2(){
        String sql = "insert into student(id,name,sex) values(:id,:name,:sex)";
        Student student = new Student();
        student.setId("8000114010");
        student.setName("小敏");
        student.setSex("女");
        SqlParameterSource paramSource = new BeanPropertySqlParameterSource(student);
        namedParameterJdbcTemplate.update(sql, paramSource);
    }
    //结果是数据中添加了上述数据

十四、进行数据库事务操作（原子性操作）
如下流程（简述）：
1、加入AOP（面向切面编程）的jar包
2、导入tx命名空间
1、在Application-Context.xml文件中加入以下内容：

    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
    </bean>
        <!-- 启用事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

在所需要进行事务操作的方法上添加注释：

//加了此注释，才可以进行事务操作
@Trasactional
public 返回值 方法名（args）
{

}