Spring里将jdbc集成了一种更加方便使用的小型框架，只要配置成功即可使用。下面具体看一下JdbcTemplate的简述以及使用。
1、什么是JdbcTemplate？
为了使JDBC更加易于使用，Spring在JDBC API上定义了一个抽象层，以此建立一个JDBC存取框架。
作为Spring JDBC框架的核心，JDBC模板的设计目的是为不同类型的JDBC操作提供模板方法，通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取的工作量降到最低。 一般情况下可以将Spring的JdbcTemplate看作是一个小型的轻量级持久化层框架。
2、环境准备
1）导入JAR包
IOC容器所需要的JAR包：
commons-logging-1.1.1.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
JdbcTemplate所需要的JAR包：
spring-jdbc-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar
数据库驱动和数据源：
druid-1.1.9.jar
mysql-connector-java-5.1.7-bin.jar
2）创建连接数据库基本信息属性文件
jdbc.properties：
3） 在Spring配置文件中配置相关的bean
jdbc.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:aop="http://www.springframework.org/schema/aop"
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/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
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
</bean>
<!-- 配置jdbcTemplate -->
<bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
4）加载容器并获取数据源对象
Main类：
package com.spring.jdbc.jdbcTemplate;
import java.sql.SQLException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
public class Main {
public static void main(String[] args) throws SQLException {
ApplicationContext ctx = new ClassPathXmlApplicationContext("jdbc.xml");
//获取数据源对象
DruidDataSource bean = ctx.getBean(DruidDataSource.class);
DruidPooledConnection conn = bean.getConnection();
System.out.println(conn);
}
}
5）下面用JdbcTemplate写一下单条数据的增删改查，以及批量增加。
创建一个测试类JDBCTest ：
使用JDK连接数据库并添加数据：
package com.spring.jdbc.jdbcTemplate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.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;
class JDBCTest {
ApplicationContext ctx = new ClassPathXmlApplicationContext("jdbc.xml");
/**
* 使用原生jdk连接数据库进行添加数据
* @throws SQLException
*/
@Test
void test1() throws SQLException {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/conntest", "root", "abc123");
String sql = "insert into student values(null,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setObject(1, "小哈");
ps.setObject(2, 18);
int row = ps.executeUpdate();
System.out.println(row);
ps.close();
conn.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
结果如下图：
使用JdbcTemplate 添加单条数据：
@Test
public void test2() {
//添加单条数据
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
String sql="insert into student values(null,?,?)";
int row = jt.update(sql, "小修" ,20);
System.out.println(row);
}
结果如下图：
使用JdbcTemplate 添加多条数据：
@Test
public void test3() {
//添加多条数据
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
String sql="insert into student values(null,?,?)";
List<Object[]> list = new ArrayList<Object[]>();
list.add(new Object[] {"小众",21});
list.add(new Object[] {"做哈",21});
list.add(new Object[] {"小号",18});
list.add(new Object[] {"小OA",31});
list.add(new Object[] {"小打",21});
list.add(new Object[] {"小大王",21});
list.add(new Object[] {"小的",21});
list.add(new Object[] {"小非",5});
int[] rows = jt.batchUpdate(sql, list);
System.out.println(Arrays.toString(rows));
}
结果如下图：
使用JdbcTemplate 添加修改：
/**
* 单条修改
*/
@Test
public void test4() {
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
String sql = "update student set name=? where id=?";
int row = jt.update(sql, "fenghuo",5);
System.out.println(row);
}
结果如下图：
使用JdbcTemplate 查询单挑数据：
@Test
public void test5() {
//查询单条数据
String sql = "select * from student where id=?";
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
RowMapper<Student> rowMapper = new BeanPropertyRowMapper<>(Student.class);
Student stu = jt.queryForObject(sql, rowMapper, 1);
System.out.println(stu);
}
结果如下图：
使用JdbcTemplate 查询多条数据：
@Test
public void test6() {
// 查询多条数据
String sql = "select * from student";
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
RowMapper<Student> rowMapper = new BeanPropertyRowMapper<>(Student.class);
List<Student> list = jt.query(sql, rowMapper);
for (Student student : list) {
System.out.println(student);
}
}
结果如下图：
使用JdbcTemplate 查询单条属性值：
@Test
public void test7() {
// 查询单条属性值
JdbcTemplate jt = ctx.getBean(JdbcTemplate.class);
String sql = "select name from student where id = ?" ;
String name = jt.queryForObject(sql, String.class , 2);
System.out.println(name);
}
}
结果如下图：
关于JdbcTemplate的基本操作就说到这里了，下节会说到使用使用JdbcTemplate实现Dao以及过程中出现的一些问题。
转载：https://blog.csdn.net/zxdspaopao/article/details/104478193
查看评论