Spring的JdbcTemplate(10)

最新推荐文章于 2024-08-21 23:28:12 发布
最新推荐文章于 2024-08-21 23:28:12 发布
阅读量78 收藏
点赞数
文章标签： 数据库 java
原文链接：http://blog.51cto.com/4534309/2112489
版权
  • JdbcTemplate模板与DbUtils工具类比较类似.

Spring对持久层技术支持

  • JDBC : org.springframework.jdbc.core.JdbcTemplate
  • Hibernate3.0 : org.springframework.orm.hibernate3.HibernateTemplate
  • IBatis(MyBatis) : org.springframework.orm.ibatis.SqlMapClientTemplate
  • JPA : org.springframework.orm.jpa.JpaTemplate
开发JDBCTemplate入门:

  • 第一步:引入相应jar包:

    • spring-tx-3.2.0.RELEASE.jar
    • spring-jdbc-3.2.0.RELEASE.jar
    • mysql驱动.
  • 传统JDBC连接demo
package cn.spring3.demo1;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class SpringTest1 {

    @Test
    public void demo1(){
        //创建连接池
        DriverManagerDataSource dateSource = new DriverManagerDataSource();
        //设置参数
        dateSource.setDriverClassName("com.mysql.jdbc.Driver");
        //dateSource.setUrl("jdbc:mysql://172.16.30.189:3306/spring3_day02");
        dateSource.setUrl("jdbc:mysql://192.168.0.120:3306/spring3_day02");
        dateSource.setUsername("root");
        dateSource.setPassword("123");

        //使用jdbc的模板
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dateSource);
        //这个是第二种方式：jdbcTemplate.setDataSource(dateSource);
        String sql="create table user (id int primary key auto_increment,name varchar(20))";
        jdbcTemplate.execute(sql);
    }

}
  • 第一种方式：创建applicationContext.xml(配置Spring默认连接池)
<!-- 配置Spring默认连接池 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://172.16.30.189:3306/spring3_day02"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
    </bean>

    <!-- 定义jdbctmplate -->
    <bean id="jdbcTmplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
  • 编写一个测试类:
package cn.spring3.demo1;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringTest2 {
    //配置Spring默认连接池
    @Autowired
    @Qualifier("jdbcTmplate")
    private JdbcTemplate jdbcTmplate;
    @Test
    public void demo1(){
        jdbcTmplate.execute("create table user (id int primary key auto_increment,name varchar(20))");
    }
    }
  • 第二种方式：创建applicationContext.xml(配置DBCP连接池)
<!-- 配置DBCP连接池 -->
    <bean id="dateSourceDbcp" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://172.16.30.189:3306/spring3_day02"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
    </bean>

    <!-- 定义jdbctmplate DBCP -->
    <bean id="jdbcTmplateDbcp" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSourceDbcp"></property>
    </bean>
  • 编写测试类：
package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringTest2 {
    //配置DBCP连接池 
    @Autowired
    @Qualifier("jdbcTmplateDbcp")
    private JdbcTemplate jdbcTmplateDbcp;

    @Test
    public void demo2(){
        jdbcTmplateDbcp.execute("create table user (id int primary key auto_increment,name varchar(20))");
    }
    }
  • 第三种方式：创建applicationContext.xml(配置C3p0连接池)
<!-- 配置C3P0连接池 -->
    <bean id="dateSourceC3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://172.16.30.189:3306/spring3_day02"/>
        <property name="user" value="root"/>
        <property name="password" value="123"/>
    </bean>

    <!-- 定义jdbctmplate DBCP -->
    <bean id="jdbcTmplateC3p0" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSourceC3p0"></property>
    </bean>
  • 编写测试类：
package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringTest2 {
    //配置C3p0连接池 
    @Autowired
    @Qualifier("jdbcTmplateC3p0")
    private JdbcTemplate jdbcTmplateC3p0;

    @Test
    public void demo3(){
        jdbcTmplateC3p0.execute("create table user (id int primary key auto_increment,name varchar(20))");
    }
    }

引入配置文件方式，配置连接池（C3P0举例说明）

1.第一步：新建JDBC.properties(名字随便)

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://172.16.30.189:3306/spring3_day02
jdbc.user = root
jdbc.password =123

2.第二步：配置applicationContext.xml(两种方式引入)
2.1 第一种配置方式：

<!-- 配置C3P0连接池 引入配置文件的方式  方法一-->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
          <property name="location" value="classpath:JDBC.properties"></property>
    </bean>

    <bean id="dateSourceC3p0ref" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 定义jdbctmplate DBCP -->
    <bean id="jdbcTmplateC3p0ref" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSourceC3p0ref"></property>
    </bean>

编写测试类：

 package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class SpringTest2 {//配置C3p0连接池  引入配置文件方式 方法一 第二种方法请见springtest3.java
    @Autowired
    @Qualifier("jdbcTmplateC3p0ref")
    private JdbcTemplate jdbcTmplateC3p0ref;

    @Test
    public void demo4(){
        jdbcTmplateC3p0ref.execute("create table user (id int primary key auto_increment,name varchar(20))");
    }
    }
2.2  第二种配置方式：
xmlns:context="http://www.springframework.org/schema/context"

<!-- 配置C3P0连接池 引入配置文件的方式  方法二-->
    <context:property-placeholder location="classpath:JDBC.properties"/>

    <bean id="dateSourceC3p0ref" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 定义jdbctmplate DBCP -->
    <bean id="jdbcTmplateC3p0ref" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dateSourceC3p0ref"></property>
    </bean>

编写测试类：

 package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext1.xml")
public class SpringTest3 {

    //配置C3p0连接池  引入配置文件方式 方法二   方法一见springtest2.java
    @Autowired
    @Qualifier("jdbcTmplateC3p0ref")
    private JdbcTemplate jdbcTmplateC3p0ref;

    @Test
    public void demo1(){
        jdbcTmplateC3p0ref.execute("create table user (id int primary key auto_increment,name varchar(20))");
    }

}
* 总结以上：
在src下创建jdbc.properties
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///spring3_day02
jdbc.user = root
jdbc.password = 123

需要在applicationContext.xml 中使用属性文件配置的内容.
* 第一种写法:
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
          <property name="location" value="classpath:jdbc.properties"></property>
</bean>

* 第二种写法:
<context:property-placeholder location="classpath:jdbc.properties"/>

JdbcTemplate的CRUD的操作:

Spring框架中提供了对持久层技术支持的类:
JDBC            :   org.springframework.jdbc.core.support.JdbcDaoSupport
Hibernate 3.0   :   org.springframework.orm.hibernate3.support.HibernateDaoSupport
iBatis      :   org.springframework.orm.ibatis.support.SqlMapClientDaoSupport

编写DAO的时候:
Public class UserDao extends JdbcDaoSupport{

}

进行CRUD的操作;
* 保存:update(String sql,Object... args)
* 修改:update(String sql,Object... args)
* 删除:update(String sql,Object... args)
  • 例子：

User类

package cn.spring3.demo2;

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

UserDao类

package cn.spring3.demo2;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class UserDao extends JdbcDaoSupport{

    public void add(User user) {
        String sql="insert into user values(null,?)";
        this.getJdbcTemplate().update(sql, user.getName());
    }

    public void update(User user) {
        String sql="update user set name= ? where id= ?";
        this.getJdbcTemplate().update(sql, user.getName(),user.getId());
    }

    public void delete(User user) {
        String sql="delete from user where id= ?";
        this.getJdbcTemplate().update(sql, user.getId());
    }

}

测试类：

package cn.spring3.demo2;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations="classpath:applicationContext1.xml")
public class StringTest1 {
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;
    //增
    @Test
    public void demo1(){
        User user = new User();
        user.setName("one");
        userDao.add(user);
    }
    //修改
    @Test
    public void demo2(){
        User user = new User();
        user.setId(2);
        user.setName("two");
        userDao.update(user);
    }
    //删除
    @Test
    public void demo3(){
        User user = new User();
        user.setId(3);
        userDao.delete(user);
    }
}

查询:

  • 简单查询(单一类型查询):

    • select count(*) from user; --- queryForInt(String sql);
    • select name from user where id = ?; --- queryForObject(String sql,Class clazz,Object... args);
  • 复杂查询:(返回对象,和对象集合)
    • select * from user where id = ? --- queryForObjectString sql,RowMapper<T> rowMapper,Object... args);
    • select * from user; --- query(String sql,RowMapper<T> rowMapper,Object... args);

UserDao类添加方法

public int findCount(){
        String sql = "select count(*) from user";
        return this.getJdbcTemplate().queryForInt(sql);
    }

    public String findNameById(User user){
        String sql = "select name from user where id= ?";
        return this.getJdbcTemplate().queryForObject(sql, String.class, user.getId());
    }

测试类编写：

//简单查询1
    @Test
    public void demo4(){
        System.out.println(userDao.findCount());
    }

    //简单查询2
    @Test
    public void demo5(){
        User user = new User();
        user.setId(2);
        System.out.println(userDao.findNameById(user));
    }

复杂查询
UserDao类添加方法

class UserRowMapper implements RowMapper<User>{
        /*
         * rc:结果集
         * rowNum：行号
         */
        public User mapRow(ResultSet rs, int rownum) throws SQLException {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            return user;
        }

    }

    public User findById(int id){
        String sql = "select * from user where id= ?";
        User user = this.getJdbcTemplate().queryForObject(sql,new UserRowMapper(), id);
        return user;
    }

或者用内部类的方式：

public User findById(int id){
        String sql = "select * from user where id = ?";
        return this.getJdbcTemplate().queryForObject(sql, new RowMapper<User>(){
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                return user;
            }
        }, id);
    }

    public List<User> find(){
        String sql = "select * from user ";
        return this.getJdbcTemplate().query(sql, new RowMapper<User>(){
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                return user;
            }
        });
    }

编写测试类：

//复杂查询
    @Test
    public void demo6(){
        User user = userDao.findById(2);
        System.out.println(user);
    }

多条查询
UserDao

public List<User> findAll(){
        String sql = "select * from user";
        return this.getJdbcTemplate().query(sql,new UserRowMapper());
    }

编写测试类：

// 复杂查询2
    @Test
    public void demo7() {
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
    }

转载于:https://blog.51cto.com/4534309/2112489

weixin_34227447
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring JdbcTemplate查询实例
06-11
Spring JdbcTemplate是Spring框架中用于简化数据库操作的一个重要组件，它是Spring对JDBC的轻量级封装，旨在提供一种结构良好、易于使用的SQL执行机制，同时保持了JDBC的灵活性。在本实例中，我们将深入探讨Spring ...
spring-jdbcTemplate实例工程
04-21
《深入解析Spring JdbcTemplate》 Spring JDBC Template是Spring框架中用于简化JDBC操作的一个核心组件，它是Spring对JDBC API的封装，旨在提供一个更加简洁、健壮且可测试的数据库访问层。在这个实例工程中，我们...
JdbcTemplate的模板第二种方式
Kato_op的博客
05-09 190
Spring的JdbcTemplate的模板第二种方式 通过继承JdbcDaoSupport来JdbcTemplate模板对象 JdbcDaoSupport 是 spring 框架为我们提供的一个类，该类中定义了一个 JdbcTemplate 对象，我们可 以直接获取使用，但是要想创建该对象，需要为其提供一个数据源 public abstract class JdbcDaoSuppor...
Spring --14.Spring中Dao使用JdbcTemplate的二种方式
一叶知秋
11-15 517
在Dao中使用JdbcTemplate有二种方式： (1)、直接Dao中声明jdbcTemplate、通过set方法注入值 (2)让Dao继承JdbcDaoSupport 1、直接在Dao中声明JdbcTemplate。通过set方法注入JdbcTemplate属性的值 applicationContext.xml 把Dao配置到Spring中 &lt;?xml version="1....
【Spring】基础入门篇(十一) SpringJDBC之JdbcTemplate
不想当架构师的程序员不是好程序员
08-29 487
Spring·基础入门篇(十一) SpringJDBC之JdbcTemplate 1. JdbcTemplate 概述 它是 Spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。 Spring 框架为我们提供了很多的操作模板类。 操作关系型数据的： JdbcTemplate HibernateTemplate 操作 nosql 数据库的： RedisTemplat...
SpringJdbcTemplate基本使用
weixin_42436233的博客
03-23 922
SpringJdbcTemplate 1、JdbcTemplate基本使用 1.1 概述 原始繁琐的JDBC API对象的封装；操作模板如下：JdbcTemplate和HibernateTemplate，操作nosql数据库RedisTemplate，消息队列JmsTemplate 1.2 JDBCTemplate开发步骤 1）导入spring-jdbc和spring-tx坐标 2）创建数据库和实体 3）创建jdbcTemplate对象 4）执行数据库操作 1.3 测试 public class JdbcT
Spring JdbcTemplate类
swadian2008的博客
01-13 655
Spring 针对数据库开发提供了 JdbcTemplate 类，该类封装了 JDBC，支持对数据库的所有操作。 在 Spring 中，JDBC 的相关信息在配置文件中完成，其配置文件如下所示。 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http:/www.w3.org/2001/XMLSchem
Spring JdbcTemplate
千里之行，始于足下
01-30 2229
Spring作为一个一站式框架，对开发中三层架构都有着企业级的解决方案，其中对应持久层的解决方案就是Spring JdbcTemplate。 今天就详细讲解Spring JdbcTemplate的配置与使用。
Spring JdbcTemplate使用
热门推荐
浅然的专栏
05-11 5万+
该篇博客主要阐述关于Spring中jdbcTemplate，jdbcTemplate大大方便了jdbc的一些重复性操作 一、jdbcTemplate更新数据库常用方法 update (更新数据) batchUpdate (批量更新数据库) queryForObject (查询单行) query （查询多行） queryForObject (单值查询)不同的 ...
Spring JdbcTemplate 案例详解教程
zp8126的专栏
03-20 1238
Spring JdbcTemplate 是 Spring Framework 中用于简化 JDBC 操作的一个轻量级封装工具类。它提供了一系列的方法来执行 SQL 查询、更新、批处理等操作，从而减轻了开发者手动处理 JDBC 的繁琐细节，例如关闭连接、处理异常、清理资源等。Spring提供的数据访问模板，提供了很多方便操作数据库的方法。
Spring JdbcTemplate基本使用
weixin_59496235的博客
08-20 195
无
Spring——JdbcTemplate
xiangqian0721的博客
09-06 922
（1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。（4）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象。（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作。2、使用 JdbcTemplate 实现查询返回某个值代码。2、调用 JdbcTemplate 方法实现查询返回集合。2、JdbcTemplate 实现查询返回对象。2、JdbcTemplate 实现批量添加操作。
Spring jdbcTemplate pom.xml
03-23
1.Spring4前 spring-jdbc包是独立的，4以后spring-jdbc 就已经没有了
基于注解的Spring JdbcTemplate
07-05
**基于注解的Spring JdbcTemplate** 在Java世界中，Spring框架是企业级应用开发的首选。Spring JDBC模絫提供了一种简洁的方式来处理数据库操作，而`Spring JdbcTemplate`是这个模絫的核心组件。本教程将深入探讨...
Spring JdbcTemplate整合使用方法及原理详解
08-18
Spring JdbcTemplate 整合使用方法及原理详解 Spring JdbcTemplate 是 Spring 框架中的一部分，提供了一个简单的方式来与数据库进行交互。它可以帮助开发者快速地执行数据库操作，无需关心底层的 JDBC 详细实现。...
【达梦数据库】导入导出过程中get DDL复现过程
weixin_47686079的博客
08-20 333
在处理问题的过程中，客户反馈在达梦数据库中导入导出分区表，get 表的DDL，不会出现表的所有分区信息，ORACLE数据库却会出现所有分区表，事实真的如此吗？
redis常用操作命令
diffiii
08-21 203
显示服务器时间 , 时间戳(秒), 微秒数。模糊查询以fine为前缀的key值。模糊查询以ha为后缀的key值。删除指定key，多个用空格隔开。当前数据库key的数量。登录redis客户端。退出redis客户端。
分布式事务：基本概念
玉汝于成
08-20 300
事务可以看做事一次大的活动，它由不同的小的活动组成，这些活动要么全部成功，要么全部失败。
【MySQL】表的增删查改
最新发布
muyuteacher的博客
08-21 839
在数据库管理中，CRUD（Create, Read, Update, Delete）是一组基本的操作，用于管理表中的数据。Create：创建新的记录或表。Read：检索表中的数据。Update：修改表中现有记录的数据。Delete：从表中移除记录。本文将对这四种操作进行详细介绍。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值