spring+JdbcTemplate簡單使用(一)

@

目錄

• 1. 環境配置
• 2. 創建項目
• 3. 配置 pom.xml(導入 jar 包)
• 4. 配置文件（resources 目錄下）
• 5. 創建測試數據庫
• 6. 新建實體類
• 7. 持久層（dao）
• 8. 測試（test）
• 9. 下載源碼

1. 環境配置

1. maven（項目管理）
2. idea（編譯器）
3. jdk1.8（Java環境）
4. MySQL5.6（MySQL數據庫）

2. 創建項目

1. 在 idea 中創建普通的 maven 項目
2. 新建 resources 目錄用來存放配置文件
   

3. 配置 pom.xml(導入 jar 包)

<properties>
        <aspectj.version>1.8.1</aspectj.version>
        <aopalliance.version>1.0</aopalliance.version>
        <!--spring版本-->
        <spring.version>5.0.8.RELEASE</spring.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--測試 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>

        <!--spring 面向切面start-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>${aopalliance.version}</version>
        </dependency>
        <!--spring 面向切面end-->

        <!--MySQL 驅動包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <!--c3p0連接池-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
    </dependencies>

4. 配置文件（resources 目錄下）

1. db.properties

#用戶名
jdbc.user=root
#登錄密碼
jdbc.password=123456
#驅動
jdbc.driverClass=com.mysql.jdbc.Driver
#連接路徑
jdbc.jdbcUrl=jdbc:mysql:///test

#初始化連接數量
jdbc.initPoolSize=5
#最大連接數
jdbc.maxPoolSize=10

db.properties 是數據庫配置文件

2. applicationContext.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: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">

    <!--自動掃描包，此處 com.tuck.jdbc 改成自己實際項目包路徑-->
    <!--掃描 com.ordust 包及子包中所有的組件類-->
    <context:component-scan base-package="com.ordust.jdbc"/>

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

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

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

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

applicationContext.xml 是 spring 的配置文件

5. 創建測試數據庫

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '學號',
  `name` varchar(50) NOT NULL COMMENT '姓名',
  `age` int(11) NOT NULL COMMENT '年齡',
  `teacher_id` int(11) NOT NULL COMMENT '老師工號',
  PRIMARY KEY (`id`),
  KEY `teacher_id` (`teacher_id`),
  CONSTRAINT `student_ibfk_1` FOREIGN KEY (`teacher_id`) REFERENCES `teacher` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '工號',
  `name` varchar(50) NOT NULL COMMENT '姓名',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

student 表與 teacher 表中主鍵為學號，為演示方便，設置成自增

插入數據

insert into `teacher` (`id`, `name`) values('1','張三');
insert into `teacher` (`id`, `name`) values('2','李四');
insert into `teacher` (`id`, `name`) values('3','王五');

insert into `student` (`id`, `name`, `age`, `teacher_id`) values('1','AA','10','1');
insert into `student` (`id`, `name`, `age`, `teacher_id`) values('2','BB','11','1');
insert into `student` (`id`, `name`, `age`, `teacher_id`) values('3','CC','12','2');

6. 新建實體類

1. Teacher.java

public class Teacher {
    private int id;//老師工號
    private String name;//老師姓名
    
	/*省略對應的 setter getter 和 toString 方法*/
}

3. Student.java

public class Student {
    private int id;//學生學號
    private String studentName;//學生姓名
    private int age;//年齡
    private Teacher teacher;
	/*省略對應的 setter getter 和 toString 方法*/
}

7. 持久層（dao）

import com.ordust.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository //標識為持久層組件
public class StudentDao {

    @Autowired //自動裝配jdbcTemplate
    private JdbcTemplate jdbcTemplate;

    /**
     * 添加、修改、刪除一個student對象
     * 此處只實現 修改
     *
     * @param student 學生實體類
     * @return 返回操作結果
     */
    public int testUpdate(Student student) {
        String sql = "update student set name = ?, age = ? where id = ?";
        return jdbcTemplate.update(sql, student.getStudentName(), student.getAge(), student.getId());
    }

    /**
     * 執行批量更新：批量的 INSERT, UPDATE, DELETE
     *
     * @param batchArgs Object[] 的 list 集合
     * @return 返回操作結果
     */
    public int[] testBatchUpdate(List<Object[]> batchArgs) {
        String sql = "INSERT INTO student VALUES(null,?,?,?)";
        return jdbcTemplate.batchUpdate(sql, batchArgs);
    }

    /**
     * 從數據庫中讀取一條記錄，得到對應的一個對象
     * 注意使用的方法為 queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args)
     *
     * @param id 需要查找的id
     * @return 返回student對象
     */
    public Student testQueryForObject(int id) {
        /**
         * 1、使用 sql 中的列的別名完成列名和類的屬性名的映射 如下面sql語句：name studentName
         * 2、JdbcTemplate 不支持級聯屬性，此處 teacher.id 值為空
         */
        String sql = "SELECT id, name studentName , age, teacher_id AS `teacher.id` FROM student WHERE id=?";
        BeanPropertyRowMapper<Student> rowMapper = new BeanPropertyRowMapper<Student>(Student.class);
        return jdbcTemplate.queryForObject(sql, rowMapper, id);
    }

    /**
     * 得到實體類集合
     * 注意調用的不是 queryForList 方法
     *
     * @param id 參數
     * @return student 集合
     */
    public List<Student> testQueryForList(Integer id) {
        String sql = "SELECT id, name studentName, age FROM student WHERE id > ?";
        BeanPropertyRowMapper<Student> rowMapper = new BeanPropertyRowMapper<Student>(Student.class);
        return jdbcTemplate.query(sql, rowMapper, id);
    }

    /**
     * 獲取單個列的值，或做統計查詢
     * 使用 queryForObject(String sql, Class<T> requiredType) 方法
     */
    public Integer testQueryForObject2() {
        String sql = "select  count(*) from student";
        return jdbcTemplate.queryForObject(sql, Integer.class);
    }

}

8. 測試（test）

import com.ordust.dao.StudentDao;
import com.ordust.entity.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.ArrayList;
import java.util.List;

/**
 * 測試類，用來測試 StudentDao 類
 */
public class Demo {
    private ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    private StudentDao studentDao = context.getBean(StudentDao.class);

    /**
     * 執行 INSERT, UPDATE, DELETE
     */
    @Test
    public void testUpdate() {
        Student student = new Student();
        student.setStudentName("哈哈哈");
        student.setAge(22);
        student.setId(3);
        int i = studentDao.testUpdate(student);
        System.out.println(i);
    }

    @Test
    public void testBatchUpdate() {
        List<Object[]> batchArgs = new ArrayList<Object[]>();

        batchArgs.add(new Object[]{"鼠大王", 22, 1});
        batchArgs.add(new Object[]{"東側", 22, 2});
        batchArgs.add(new Object[]{"嘻嘻", 22, 3});

        studentDao.testBatchUpdate(batchArgs);
    }

    @Test
    public void testQueryForObject() {
        int id = 1;
        Student student = studentDao.testQueryForObject(id);
        System.out.println(student);
    }

    @Test
    public void testQueryForList() {
        List<Student> students = studentDao.testQueryForList(1);
        for (Student student : students) {
            System.out.println(student);
        }
    }

    @Test
    public void testQueryForObject2() {
        Integer integer = studentDao.testQueryForObject2();
        System.out.println(integer);
    }
}

9. 下載源碼

spring-jdbctemplate-annotation