Spring——JdbcTemplate

已于 2022-02-18 16:39:30 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： 微服务核心：SSM+SpringBoot2+设计模式+MQ 文章标签： spring java intellij-idea
于 2021-12-13 21:39:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36879493/article/details/121915176
版权

JdbcTemplate

文章目录

1、JdbcTemplate（概念和准备）

1.1、什么是 JdbcTemplate？

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。

1.2、准备工作

（1）引入相关 jar 包

在这里插入图片描述

（2）在 spring 配置文件配置数据库连接池

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql://10.150.104.5:3306/user_db" />
    <property name="username" value="root" />
    <property name="password" value="Opfordream@0518" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

（3）配置 JdbcTemplate 对象，注入 DataSource

<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

（4）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

配置文件：

<!--开启组件扫描-->
<context:component-scan base-package="spring5"></context:component-scan>

Service：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import spring5.dao.BookDao;

@Service
public class BookService {
    //注入Dao
    @Autowired
    private BookDao bookDao;
}

Dao：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl {
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

2、JdbcTemplate 操作数据库（添加）

mysql> desc t_book;
+----------+--------------+------+-----+---------+-------+
| Field    | Type         | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| user_id  | int(20)      | NO   | PRI | NULL    |       |
| username | varchar(100) | NO   |     | NULL    |       |
| ustatus  | varchar(50)  | NO   |     | NULL    |       |
+----------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

（1）对应数据库创建实体类

public class Book {
    private String userid;
    private String username;
    private String ustatus;

    public void setUserid(String userid) {
        this.userid = userid;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

（2）编写 service 和 dao

  1. 在 dao 进行数据库添加操作
  2. 调用 JdbcTemplate 对象里面 update 方法实现添加操作，有两个参数：
    • 第一个参数： sql 语句
    • 第二个参数：可变参数，设置 sql 语句值
@Repository
public class BookDaoImpl implements BookDao{
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加的方法
    @Override
    public void add(Book book) {
        //1 创建sql语句
        String sql = "insert into t_book values(?,?,?)";
        //2 调用方法实现
        Object[] args = {book.getUserid(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
}

（3）测试代码

public class TestTemplate {
    @Test
    public void testAdd() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserid("1");
        book.setUsername("java");
        book.setUstatus("a");

        bookService.addBook(book);
    }
}

mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | java     | a       |
+---------+----------+---------+
1 row in set (0.00 sec)

3、JdbcTemplate 操作数据库（修改和删除）

@Override
public void updateBook(Book book) {
    //1 创建sql语句
    String sql = "update t_book set username=?, ustatus=? where user_id=?";
    //2 调用方法实现
    Object[] args = {book.getUsername(), book.getUstatus(), book.getUserid()};
    int update = jdbcTemplate.update(sql, args);
    System.out.println(update);
}

@Override
public void deleteBook(String id) {
    //1 创建sql语句
    String sql = "delete from t_book where user_id=?";
    //2 调用方法实现
    int update = jdbcTemplate.update(sql, id);
    System.out.println(update);
}

测试代码：

@Test
public void testUpdate() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    Book book = new Book();
    book.setUserid("1");
    book.setUsername("javaupup");
    book.setUstatus("at");

    bookService.updateBook(book);
}

mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | javaupup | at      |
+---------+----------+---------+
1 row in set (0.00 sec)

@Test
public void testDelete() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    String id = "1";

    bookService.deleteBook(id);
}

mysql> select * from t_book;
Empty set (0.00 sec)

4、JdbcTemplate 操作数据库（查询返回某个值）

（1）查询表里面有多少条记录，返回是某个值

mysql> select count(*) from t_book;
+----------+
| count(*) |
+----------+
|        0 |
+----------+
1 row in set (0.00 sec)

（2）使用 JdbcTemplate 实现查询返回某个值代码

使用 queryForObject 方法，有两个参数：

  • 第一个参数： sql 语句
  • 第二个参数：返回类型 Class
@Override
public int selectCount() {
    //1 创建sql语句
    String sql = "select count(*) from t_book;";
    //2 调用方法实现
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}

测试代码：

@Test
public void testCount() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    int count = bookService.findCount();
    System.out.println(count);	//0
}

5、JdbcTemplate 操作数据库（查询返回对象）

（1）场景：查询图书详情

（2）JdbcTemplate 实现查询返回对象：使用 queryForObject，有三个参数

  • 第一个参数： sql 语句
  • 第二个参数： RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
  • 第三个参数： sql 语句值
mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | javaupup | a       |
+---------+----------+---------+
1 row in set (0.00 sec)

@Override
public Book findBookInfo(String id) {
    //1 创建sql语句
    String sql = "select * from t_book where user_id=?;";
    //2 调用方法实现
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
    return book;
}

测试代码：

@Test
public void testOne() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    Book book = bookService.findOne("1");
    System.out.println(book);	//Book{userid='null', username='javaupup', ustatus='a'}
}

6、JdbcTemplate 操作数据库（查询返回集合）

（1）场景：查询图书列表分页…

（2）调用 JdbcTemplate 方法实现查询返回集合，使用 query，有三个参数

  • 第一个参数： sql 语句
  • 第二个参数： RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
  • 第三个参数： sql 语句值
mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | javaupup | a       |
|       2 | mysql    | b       |
+---------+----------+---------+
2 rows in set (0.00 sec)

@Override
public List<Book> findAllBook() {
    //1 创建sql语句
    String sql = "select * from t_book";
    //2 调用方法实现
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

测试代码：

@Test
public void testAll() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    List<Book> bookList = bookService.findAll();
    System.out.println(bookList);	
    //[Book{userid='null', username='javaupup', ustatus='a'}, Book{userid='null',username='mysql', ustatus='b'}]
}

7、JdbcTemplate 操作数据库（批量操作）

（1）批量操作：操作表里面多条记录

（2）JdbcTemplate 实现批量添加操作，使用 batchUpdate 方法，有两个参数：

  • 第一个参数： sql 语句
  • 第二个参数： List 集合，添加多条记录数据

不管是批量添加、修改还是删除，都使用这个方法。

7.1、JdbcTemplate 实现批量添加操作

service 类中：

public void batchAdd(List<Object[]> batchArgs) {
	return bookDao.batchAddBook(batchArgs);
}

Dao 类中：

@Override
public void batchAddBook(List<Object[]> batchArgs) {
    //1 创建sql语句
    String sql = "insert into t_book values(?,?,?)";
    //2 调用方法实现
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

测试代码：

@Test
public void testAddAll() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"3", "javaweb", "c"};
    Object[] o2 = {"4", "spring", "d"};
    Object[] o3 = {"5", "redis", "e"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    bookService.batchAdd(batchArgs);
    // [1, 1, 1]
}

mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | javaupup | a       |
|       2 | mysql    | b       |
|       3 | javaweb  | c       |
|       4 | spring   | d       |
|       5 | redis    | e       |
+---------+----------+---------+
5 rows in set (0.00 sec)

7.2、JdbcTemplate 实现批量修改操作

@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
    //1 创建sql语句
    String sql = "update t_book set username=?, ustatus=? where user_id=?";
    //2 调用方法实现
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(ints);
}

测试代码：

@Test
public void testUpdateAll() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"javawebLi", "c3", "3"};
    Object[] o2 = {"springLi", "d4", "4"};
    Object[] o3 = {"redisLi", "e5", "5"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    bookService.batchUpdate(batchArgs);
}

mysql> select * from t_book;
+---------+-----------+---------+
| user_id | username  | ustatus |
+---------+-----------+---------+
|       1 | javaupup  | a       |
|       2 | mysql     | b       |
|       3 | javawebLi | c3      |
|       4 | springLi  | d4      |
|       5 | redisLi   | e5      |
+---------+-----------+---------+
5 rows in set (0.00 sec)

7.3、JdbcTemplate 实现批量删除操作

@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
    //1 创建sql语句
    String sql = "delete from t_book where user_id=?";
    //2 调用方法实现
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(ints);
}

测试代码：

@Test
public void testDeleteAll() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    BookService bookService = context.getBean("bookService", BookService.class);

    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"3"};
    Object[] o2 = {"4"};
    batchArgs.add(o1);
    batchArgs.add(o2);

    bookService.batchDelete(batchArgs);
}

mysql> select * from t_book;
+---------+----------+---------+
| user_id | username | ustatus |
+---------+----------+---------+
|       1 | javaupup | a       |
|       2 | mysql    | b       |
|       5 | redisLi  | e5      |
+---------+----------+---------+
3 rows in set (0.00 sec)

附：所有类的代码

<?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:component-scan base-package="spring5"></context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql://10.150.104.5:3306/user_db" />
        <property name="username" value="root" />
        <property name="password" value="Opfordream@0518" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>

    <!--创建JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

package spring5.entity;

public class Book {
    private String userid;
    private String username;
    private String ustatus;

    public void setUserid(String userid) {
        this.userid = userid;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }

    public String getUserid() {
        return userid;
    }

    public String getUsername() {
        return username;
    }

    public String getUstatus() {
        return ustatus;
    }

    @Override
    public String toString() {
        return "Book{" +
                "userid='" + userid + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + ustatus + '\'' +
                '}';
    }
}

package spring5.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import spring5.dao.BookDao;
import spring5.entity.Book;

import java.util.List;

@Service
public class BookService {
    //注入Dao
    @Autowired
    private BookDao bookDao;

    //添加的方法
    public void addBook(Book book) {
        bookDao.add(book);
    }

    //修改的方法
    public void updateBook(Book book) {
        bookDao.updateBook(book);
    }

    //删除的方法
    public void deleteBook(String id) {
        bookDao.deleteBook(id);
    }

    //查询表记录的方法
    public int findCount() {
        return bookDao.selectCount();
    }

    //查询表记录数
    public Book findOne(String id) {
        return bookDao.findBookInfo(id);
    }

    //查询返回集合
    public List<Book> findAll() {
        return bookDao.findAllBook();
    }

    //批量添加
    public void batchAdd(List<Object[]> batchArgs) {
        bookDao.batchAddBook(batchArgs);
    }

    //批量修改
    public void batchUpdate(List<Object[]> batchArgs) {
        bookDao.batchUpdateBook(batchArgs);
    }

    //批量删除
    public void batchDelete(List<Object[]> batchArgs) {
        bookDao.batchDeleteBook(batchArgs);
    }
}

package spring5.dao;

import spring5.entity.Book;

import java.util.List;

public interface BookDao {
    //添加的方法
    void add(Book book);

    void updateBook(Book book);

    void deleteBook(String id);

    int selectCount();

    Book findBookInfo(String id);

    List<Book> findAllBook();

    void batchAddBook(List<Object[]> batchArgs);

    void batchUpdateBook(List<Object[]> batchArgs);

    void batchDeleteBook(List<Object[]> batchArgs);
}

package spring5.dao;

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 spring5.entity.Book;

import java.util.Arrays;
import java.util.List;

@Repository
public class BookDaoImpl implements BookDao{
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加的方法
    @Override
    public void add(Book book) {
        //1 创建sql语句
        String sql = "insert into t_book values(?,?,?)";
        //2 调用方法实现
        Object[] args = {book.getUserid(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void updateBook(Book book) {
        //1 创建sql语句
        String sql = "update t_book set username=?, ustatus=? where user_id=?";
        //2 调用方法实现
        Object[] args = {book.getUsername(), book.getUstatus(), book.getUserid()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void deleteBook(String id) {
        //1 创建sql语句
        String sql = "delete from t_book where user_id=?";
        //2 调用方法实现
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    @Override
    public int selectCount() {
        //1 创建sql语句
        String sql = "select count(*) from t_book;";
        //2 调用方法实现
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

    @Override
    public Book findBookInfo(String id) {
        //1 创建sql语句
        String sql = "select * from t_book where user_id=?";
        //2 调用方法实现
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

    @Override
    public List<Book> findAllBook() {
        //1 创建sql语句
        String sql = "select * from t_book";
        //2 调用方法实现
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

    @Override
    public void batchAddBook(List<Object[]> batchArgs) {
        //1 创建sql语句
        String sql = "insert into t_book values(?,?,?)";
        //2 调用方法实现
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        //1 创建sql语句
        String sql = "update t_book set username=?, ustatus=? where user_id=?";
        //2 调用方法实现
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(ints);
    }

    @Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        //1 创建sql语句
        String sql = "delete from t_book where user_id=?";
        //2 调用方法实现
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(ints);
    }
}

package spring5.Test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring5.entity.Book;
import spring5.service.BookService;

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

public class TestTemplate {
    @Test
    public void testAdd() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserid("1");
        book.setUsername("java");
        book.setUstatus("a");

        bookService.addBook(book);
    }

    @Test
    public void testUpdate() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserid("1");
        book.setUsername("javaupup");
        book.setUstatus("at");

        bookService.updateBook(book);
    }

    @Test
    public void testDelete() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        String id = "1";

        bookService.deleteBook(id);
    }

    @Test
    public void testCount() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        int count = bookService.findCount();
        System.out.println(count);
    }

    @Test
    public void testOne() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = bookService.findOne("1");
        System.out.println(book);
    }

    @Test
    public void testAll() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Book> bookList = bookService.findAll();
        System.out.println(bookList);
    }

    @Test
    public void testAddAll() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3", "javaweb", "c"};
        Object[] o2 = {"4", "spring", "d"};
        Object[] o3 = {"5", "redis", "e"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);
    }

    @Test
    public void testUpdateAll() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"javawebLi", "c3", "3"};
        Object[] o2 = {"springLi", "d4", "4"};
        Object[] o3 = {"redisLi", "e5", "5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchUpdate(batchArgs);
    }

    @Test
    public void testDeleteAll() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3"};
        Object[] o2 = {"4"};
        batchArgs.add(o1);
        batchArgs.add(o2);

        bookService.batchDelete(batchArgs);
    }
}
前丨尘忆·梦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JdbcTemplate_ 操作数据库(2)
17902的博客
11-20 227
JdbcTemplate 操作数据库（添加） 1、对应数据库创建实体类 public class User{ private String userId; private String username; private String ustatus; public void setUserId(String userId){ this.userId = userId; } public void setUsername(String username){ this username =
Spring框架|JdbcTemplate介绍
热门推荐
匿名攻城狮
02-02 7万+
文章目录一、JdbcTemplate 概述二、创建对象的源码分析三、JdbcTemplate操作数据库 一、JdbcTemplate 概述 在之前的web学习中，学习了手动封装JDBCtemplate，其好处是通过(sql语句+参数)模板化了编程。而真正的JDBCtemplete类，是Spring框架为我们写好的。 它是 Spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单...
Spring系列六：JdbcTemplate
你好, 我在学java的博客
08-15 888
JdbcTemplate
Spring中的JdbcTemplate
weixin_45640168的博客
10-16 101
Spring中的JdbcTemplate一、JdbcTemplate 概述二级目录三级目录 一、JdbcTemplate 概述 1.1 JdbcTemplate概述 它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装，spring框架为我们提供了很多的操作模板类。 ① 操作关系型数据的： JdbcTemplate HibernateTemplate ② 操作nosql数据库的： RedisTemplate ③ 操作消息队列的： JmsTempla
Spring之JdbcTemplate
weixin_57895075的博客
12-15 92
JdbcTemplate
spring的jdbcTemplate小案例
09-10
在本文中，我们将深入探讨Spring框架中的一个核心组件——JdbcTemplate。JdbcTemplate是Spring提供的一种数据库操作工具，它简化了数据库访问，使开发者能够编写出更健壮、更易于维护的代码，避免了手动处理JDBC连接...
Spring SpringMvc JdbcTemplate NamedParameterJdbcTemplate
08-10
标题 "Spring SpringMvc JdbcTemplate NamedParameterJdbcTemplate" 涉及到的是Java开发中的关键框架——Spring，以及它在数据库操作中的两个重要组件：JdbcTemplate和NamedParameterJdbcTemplate。这两个工具是...
JdbcTemplate简单实例
06-02
Spring框架提供了一个强大的工具类——JdbcTemplate，它简化了与数据库交互的过程，帮助开发者避免了手动处理JDBC的繁琐工作，如连接管理、异常处理等。本文将深入探讨JdbcTemplate的基本用法和优势，并通过一个简单...
jdbcTemplate.jar
06-05
《Spring JDBC模板——jdbcTemplate.jar深度解析》 在Java编程领域，Spring框架以其强大的功能和易用性成为了开发者们的首选。而在Spring框架中，Spring JDBC是处理数据库操作的重要模块，它提供了一种更加简洁、...
jdbcTemplate-spring对jdbc的支持
03-22
标题 "jdbcTemplate-spring对jdbc的支持" 涉及到的是Spring框架中的一个核心组件——JdbcTemplate，它是Spring对Java数据库连接（JDBC）的一种封装，用于简化数据库操作。JdbcTemplate提供了一种模板方法模式，使得...
使用spring jdbc template简化jdbc数据库操作实例代码
09-30
使用spring jdbc template简化jdbc数据库操作实例代码，简化操作，包括详细测试例子。
Spring系列文章：Spring使用JdbcTemplate
最新发布
程序三两行
09-08 1342
JdbcTemplate是Spring提供的⼀个JDBC模板类，是对JDBC的封装，简化JDBC代码。当然，你也可以不⽤，可以让Spring集成其它的ORM框架，例如：MyBatis、Hibernate等。第一步：引入依赖。
Spring学习：JdbcTemplate
sssxlxwbwz的博客
02-15 742
一、JDBC 传统的JDBC代码如下所示： public static void main( String[] args ) { Connection con = null; // 定义一个MYSQL链接对象 PreparedStatement ps = null; // 语句对象 ResultSet rs = null; String sql = "SELECT * FROM country where ...
【Spring笔记-6】-JDBCTempdate
m0_64337991的博客
01-12 326
使用JDBCTemplate操作数据库进行增删改查
Spring的JDBCTemplate
wyz191的专栏
03-15 272
本文引自：http://www.blogjava.net/176142998/archive/2009/02/03/221507.html Spring的JDBCTemplate 当hql等查询方式不能满足性能或灵活性的要求，必须使用SQL时，大家有三种选择： 第一、使用Hibernate 的sql 查询函数，将查询结果对象转为Entity对象。 第二、使用Hibernate Session的...
Spring4.x学习笔记——JdbcTemplate基础操作
Sirm23333
04-22 1万+
一、相关概念 spring是一个一站式的框架，对不同持久层的技术都进行了封装（处理数据库技术，基本的crud操作即增删改查），如JDBC、Hibermate、MaBatis、JPA等。 二、spring对JDBC的封装使用步骤大体如下： 导入jar包 spring-jdbc、spring-tx 创建DriveManagerDataSource对象，对数据库进行配置 className...
jdbcTemplate 在spring 中Dao层，实现CRUD操作
qq847196660的博客
07-22 664
1.mave 下载相关jar <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version&g...
Spring中的JDBCTemplate使用（非常详细的配置过程）
mypanlong的专栏
07-21 4万+
Spring中的JDBCTemplate使用 数据库准备： 创建数据库 创建表： Java代码： 1、创建web 工程  springJdbcTemplate 2、添加Spring能力 在此需要将jdbc包也同时加入 3、配置上mysql的连接驱动(拷贝mysql驱动包，如果不拷贝报错很诡异) 在applicationContext.
两种使用Spring JdbcTemplate实现update或insert操作
我的世界我的梦
10-15 3万+
第一种方式，重载PreparedStatementCreator jdbcTemplate.update(new PreparedStatementCreator()...{    public PreparedStatement createPreparedStatement(Connection conn)...{        String sql="insert into us
Spring框架JdbcTemplate详解与事务控制
"这篇文档是关于Spring框架的教程，主要关注Spring 5的新特性，特别是JdbcTemplate的使用和事务管理。文档首先介绍了JdbcTemplate的基本概念，它是Spring对JDBC API的一种封装，提供了一系列操作数据库的模板方法。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值