JdbcTemplate--spring 提供的一个操作数据库(表)功能强大的类

JdbcTemplate–spring 提供的一个操作数据库(表)功能强大的类

简介

​ 想要使用spring 框架来做项目，我们可以用 ioc 容器来配置一个jdbcTemplate 对象，使用它来完成对数据库表的各种操作.

官方文档：

JdbcTemplate APIs : /spring-framework-5.3.8/docs/javadoc-api/index.html

JdbcTemplate-基本介绍

1. 通过 Spring 可以配置数据源，从而完成对数据表的操作。
2. JdbcTemplate 是Spring 提供的访问数据库的技术，是功能强大彪悍的。可以将JDBC 的常用操作封装为模板方法。

JdbcTemplate的使用

需要引入JdbcTemplate的jar包

​ c3p0-0.9.1.2.jar
​ mysql-connector-java-5.1.7-bin.jar
​ spring-jdbc-5.3.8.jar
​ spring-orm-5.3.8.jar
​ spring-tx-5.3.8.jar

创建配置文件src/jdbc.properties

jdbc.userName=root//名字自己命名
jdbc.password=nlc
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring

创建xml文件，引入jdbc.properties，配置数据源

<?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"
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.xsd">
    <!-- 引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.userName}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
    </bean>
        
        <!-- 配置JdbcTemplate -->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                <!-- 将上面的数据源分配给jdbcTemplate -->
                <property name="dataSource" ref="dataSource"/>
        </bean>
        
</beans>

测试数据源是否连通

我们不要一股气的直接写完，过程中可能会有一些小小的错误，编译器没有报错，为了防止最后运行错误，我们在完成一个小模块的时候要验证一下。

public class JdbcTemplateTest {
    /**
    * 通过spring 提供的JdbcTemplate 获取连接
    * @throws SQLException
    */
    @Test
    public void testDataSourceByJdbcTemplate() throws SQLException {
        ApplicationContext ioc = new  ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        DataSource dataSource = ioc.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println("connection= " + connection);
        connection.close();
    }
}

简单使用JdbcTemplate

添加一个对象

@Test
public void addDataByJdbcTemplate() {
    ApplicationContext ioc = new  ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    // 1. 添加方式1
    // String sql = "INSERT INTO monster VALUES(1, '花花', '卖萌')";
    // bean.execute(sql);
    //2. 添加方式2, 绑定参数
    String sql = "INSERT INTO monster VALUES(?, ?, ?)";
    int affected = bean.update(sql, 7, "帆帆", "天赋");
    //输出影响的行数
    System.out.println("add ok affected= " + affected);
}

更新一个对象

@Test
public void updateDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    String sql = "UPDATE monster SET skill = ? WHERE id=?";
    int affected = bean.update(sql, "美人计", 3);
    System.out.println("affected= " + affected);
    System.out.println("update data ok~");
}

批量添加二个对象

@Test
public void addBatchDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    String sql = "INSERT INTO monster VALUES(?, ?, ?)";
    List<Object[]> param_list = new ArrayList<Object[]>();
    param_list.add(new Object[]{5, "白蛇", "吸收月光"});
    param_list.add(new Object[]{6, "青蛇", "吸收月光"});
    bean.batchUpdate(sql, param_list);
    System.out.println("batch add ok");
}

查询对象 并封装到 实体对象

@Test
public void selectDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    String sql = "SELECT id as monsterId,name,skill FROM monster WHERE id =?";
    //下面这个rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster 对象中.
    RowMapper<Monster> rowMapper =  new BeanPropertyRowMapper<Monster>(Monster.class);
    Monster monster = bean.queryForObject(sql, rowMapper, 1);
    System.out.println("monster= " + monster);
}

查询多条记录

@Test
public void selectMulDataByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    String sql = "SELECT id as monsterId,name,skill FROM monster WHERE id >=?";
    //下面这个rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster 对象中.
    RowMapper<Monster> rowMapper = new  BeanPropertyRowMapper<Monster>(Monster.class);
    List<Monster> monster_list = bean.query(sql, rowMapper, 2);
    for (Monster monster : monster_list) {
    	System.out.println(monster);
    }
}

查询返回结果只有一行一列的值

@Test
public void selectScalarByJdbcTemplate() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到JdbcTemplate bean
    JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
    String sql = "SELECT name FROM monster WHERE id =100";
    String name = bean.queryForObject(sql, String.class);
    System.out.println(name);
}

使用Map 传入具名参数完成操作

比如添加小狐狸:name 就是具名参数形式需要使用NamedParameterJdbcTemplate 类

<!-- 配置NamedParameterJdbcTemplate,支持具名参数-->
<bean id="namedParameterJdbcTemplate"
class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<!-- 这里需要使用构造器关联数据源-->
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>
/**
* 使用Map 传入具名参数完成操作，比如添加
*/
@Test
public void testDataByNamedParameterJdbcTemplate() {
    ApplicationContext ioc = new  ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到NamedParameterJdbcTemplate bean
    NamedParameterJdbcTemplate nameTemplate =  ioc.getBean(NamedParameterJdbcTemplate.class);
    String sql = "INSERT INTO monster VALUES(:my_id, :name, :skill)";
    Map<String, Object> map_parameter = new HashMap<String, Object>();
    map_parameter.put("my_id", 800);
    map_parameter.put("name", "小狐狸");
    map_parameter.put("skill", "无敌大法");
    nameTemplate.update(sql, map_parameter);
}

使用sqlparametersoruce 来封装具名参数

还是添加一个Monster 狐狸

@Test
public void operDataBySqlparametersoruce() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    //得到NamedParameterJdbcTemplate bean
    NamedParameterJdbcTemplate namedParameterJdbcTemplate =   ioc.getBean(NamedParameterJdbcTemplate.class);
    String sql = "INSERT INTO monster VALUES(:monsterId, :name, :skill)";
    Monster monster = new Monster(900, "狐狸", "狐媚之术");
    SqlParameterSource source = new BeanPropertySqlParameterSource(monster);
    namedParameterJdbcTemplate.update(sql, source);
    System.out.println("add ok~");
}

Dao 对象中使用JdbcTemplate 完成对数据的操作

@Repository
public class MonsterDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //添加monster
    public void save(Monster monster) {
        String sql = "INSERT INTO monster VALUES(?, ?, ?)";
        jdbcTemplate.update(sql, monster.getMonsterId(),
        monster.getName(), monster.getSkill());
    }
}

修改D:\idea_java_projects\spring5\src\JdbcTemplate_ioc.xml 增加扫描配置

<!-- 加入自动扫描包-->
<context:component-scan base-package="com.nlc.spring.jdbctemplate.dao"/>

通过dao 使用jdbcTemplate 完成操作

@Test
public void operDataByDao() {
    ApplicationContext ioc =  new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
    MonsterDao bean = ioc.getBean(MonsterDao.class);
    Monster monster = new Monster(10 "大虾精", "夹子功");
    bean.save(monster);
}