JdbcTemplate的使用

最新推荐文章于 2024-06-27 08:00:00 发布
最新推荐文章于 2024-06-27 08:00:00 发布
阅读量278 收藏
点赞数
分类专栏： spring 文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46569959/article/details/122768385
版权

在Spring 中可以使用 JdbcTemplate 进行数据库的管理操作。
Spring框架对JDBC 进行独立封装。很方便。

JdbcTemplate 的使用

导入依赖包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Spring</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>SpringDemo1</module>
        <module>springDemo2</module>
        <module>springDemo3</module>
        <module>springDemo4</module>
        <module>springDemo5</module>
        <module>springDemo6</module>
        <module>springDemo7</module>
        <module>springDemo8</module>
        <module>springDemo9</module>
        <module>springAop</module>
        <module>springaop2</module>
        <module>springAop3</module>
        <module>springAop4</module>
        <module>jdbc_Template</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

<!--        Spring的依赖包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
<!--        mysql的依赖包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>9.1</version>
        </dependency>
    </dependencies>

</project>

配置jdbc 的文件 jdbc.properties
在Spring配置文件中 配置 数据库的连接池
配置 JdbcTemplate 对象，注入数据源

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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="com.momo.dao,com.momo.service"/>

<!--    导入外部的配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

<!--    配置 JdbcTemplate 对象，注入数据源-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

实体类

package com.momo.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private int id;
    private String name;
    private String pwd;
}

dao层：

package com.momo.dao;

import com.momo.entity.User;

import javax.rmi.CORBA.Stub;
import java.util.List;

public interface UserDao {
    boolean save(User user);


    List<User> findAll();

    // 批量的增加
    public void bathAdd(List<Object[]> users);

}


package com.momo.dao.impl;


import com.momo.dao.UserDao;
import com.momo.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public boolean save(User user) {
        String sql = "insert into user(name,pwd) values(?,?)";
        // 增 删 改
        int i = jdbcTemplate.update(sql, user.getName(), user.getPwd());
        return i>0;
    }

    @Override
    public List<User> findAll() {
        String sql = "select * from user";
        System.out.println("=====>"+jdbcTemplate);
        // 只能做查询
        List<User> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return query;
    }

    @Override
    public void bathAdd(List<Object[]> users) {
        String sql =  "insert into user(name,pwd) values(?,?)";
        // 批量的增删改
        int[] ints = jdbcTemplate.batchUpdate(sql, users);
        System.out.println("=====>"+ints.length);
    }
}

service层

package com.momo.service;

import com.momo.entity.User;

import java.util.List;

public interface UserService {
    boolean save(User user);
    List<User> findAll();
    public void bathAdd(List<Object[]> users);
}


package com.momo.service.impl;

import com.momo.dao.UserDao;
import com.momo.entity.User;
import com.momo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public boolean save(User user) {
        return userDao.save(user);
    }

    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }

    @Override
    public void bathAdd(List<Object[]> users) {
        userDao.bathAdd(users);
    }
}

测试

package com.momo.test;

import com.momo.entity.User;
import com.momo.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.omg.PortableServer.LIFESPAN_POLICY_ID;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:springContext.xml"})
public class MyTest {

    @Autowired
    private UserService userService;

    @Test
    public void test(){
        System.out.println("=====>"+userService);
        List<User> all = userService.findAll();

        all.forEach(System.out::println);
    }


    @Test
    public void  Test(){

        boolean flag = userService.save(new User(0, "王五", "123321"));

        System.out.println(flag);
    }


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

        Object[] o1 = {"张三","123456"};
        Object[] o2 = {"李四","123456"};
        Object[] o3 = {"王五","123456"};

        list.add(o1);
        list.add(o2);
        list.add(o3);
        userService.bathAdd(list);
    }
}
秦愿鹏
关注
专栏目录
spring&hibernate(01-简单构建)
Fengshunui的博客
03-13 321
pom.xml<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> </depe
java 使用jdbctemplate_jdbcTemplate使用方法实例解析
weixin_34194829的博客
02-27 3647
这篇文章主要介绍了jdbcTemplate使用方法实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代...
JdbcTemplate基本使用
01-27
DBC已经能够满足大部分用户最基本的需求，但是在使用JDBC时，必须自己来管理数据库资源如：获取PreparedStatement，设置SQL语句参数，关闭连接等步骤。 JdbcTemplate是Spring对JDBC的封装，目的是使JDBC更加易于使用。JdbcTemplate是Spring的一部分。JdbcTemplate处理了资源的建立和释放。他帮助我们避免一些常见的错误，比如忘了总要关闭连接。他运行核心的JDBC工作流，如Statement的建立和执行，而我们只需要提供SQL语句和提取结果。 在JdbcTemplate中执行SQL语句的方法大致分为3类： execute：可以执行所有S
Spring中jdbcTemplate的用法实例
qingyangwqh的专栏
03-07 1754
Spring中jdbcTemplate的用法实例 一、首先配置JdbcTemplate； 要使用Jdbctemplate 对象来完成jdbc 操作。通常情况下，有三种种方式得到JdbcTemplate 对象。        第一种方式：我们可以在自己定义的DAO 实现类中注入一个DataSource 引用来完 成JdbcTemplate 的实例化。也就是它是从外部“注入” D
详细分析JdbcTemplate的基本知识 | 拓展OracleJdbcTemplate（附Demo）
最新发布
码农研究僧的博客
06-27 2070
需要支持多种类型的数据库，或者不特定于某一种数据库，建议使用JdbcTemplate 主要与Oracle数据库交互，并且需要一些Oracle特有的功能优化，可以考虑使用OracleJdbcTemplate
jdbcTemplate使用
m0_58680865的博客
09-17 902
jdbcTemplate使用详解
jdbctemplate使用
学Java，找哪吒
07-28 1万+
欲速则不达，欲达则欲速！ 一、前言 微服务架构被提出很短的时间内，就被越来越多的开发人员推崇，简单来说其主要的目的是有效的拆分应用，实现敏捷开发和部署。本博客尝试介绍微服务架构的一些实施细节和要求，探询微服务架构的由来，并最终提供我们团队内部的有一些实践总结，希望对大家有帮助。 二、什么是微服务 传统的web开发方式，通过对比比较容易理解什么是Microservice Architectu...
jdbcTemplate使用方法实例解析
08-25
jdbcTemplate使用方法实例解析 jdbcTemplate是一个基于Spring JDBC抽象框架的核心类，提供了大量实用的方法来简化数据库操作。在本文中，我们将详细介绍jdbcTemplate的使用方法实例解析，以及其在实际开发中的应用...
SpringBoot  jdbctemplate使用方法解析
08-19
首先，要使用JdbcTemplate，我们需要在SpringBoot项目中引入相关的依赖。这里使用了阿里巴巴的Druid数据源（com.alibaba.druid-spring-boot-starter）以及MySQL的驱动（mysql-connector-java）。Druid是一个优秀的...
JdbcTemplate 的使用
lesileqin的博客
01-11 442
文章目录一、JdbcTemplate 简介二、使用JdbcTemplate的步骤三、JdbcTemplate的简单实现 一、JdbcTemplate 简介 JdbcTemplate是Spring框架对JDBC的简单封装，它提供了一个JdbcTemplate对象简化了JDBC的开发。 所以：懒是第一生产力！ 二、使用JdbcTemplate的步骤 1、导入jar包： mysql-connector-java-8.0.15.jar spring-beans-5.0.20.RELEASE.jar spring
Spring JdbcTemplate方法详解
热门推荐
萌萌的It人 www.itmmd.com
07-22 11万+
JdbcTemplate主要提供以下五类方法：execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；query方法及queryForXXX方法：用于执行查询相关语句；call方法：用于执行存储过程、函数相关语句。 JdbcTemplate
JDBC Template的使用
weixin_43167662的博客
09-16 271
1. 数据库连接池 2. Spring JDBC : JDBC Template ## 数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 2. 好处： 1. 节约资源 2. 用户访问高效 3. 实现： 1. 标准接口：DataSou...
JDBCTemplate的使用
Demon的博客
08-19 1万+
一、jar包的准备 还需要c3p0相关的包 如果使用的是 c3p0 jdbcTemplate 相关jar包5个 + c3p0 2个 + MySql驱动 1个 = 8个jar 如果使用的是 druid jdbcTemplate 相关jar包5个 + druid 1个 + MySql驱动 1个 = 7个jar 二、创建JdbcTemplate对象 API介绍 JdbcTemplat...
JDBC Template最基本的使用方法
m0_63295465的博客
01-05 1071
这篇文章主要介绍了JDBC Template基本使用方法,文中通过示例代码介绍的比较详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下。"insert into student(name,sex) values('关羽','女')","insert into student(name,sex) values('刘备','男')",jdbcTemplate.update(sql,new Object[]{"张飞","男"});--使用jdbcTemplate工具类-->
Spring JDBC
小明的博客
10-06 115
简介 Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。 步骤： 导入jar包 创建JdbcTemplate对象。依赖于数据源DataSource JdbcTemplate template = new JdbcTemplate(ds); 调用JdbcTemplate的方法来完成CRUD的操作 update():执行DML语句。增、删、改语句 queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value.
JdbcTemplate的使用讲解
刘小爱的博客
06-27 1969
竟然有Jdbc模板？那我还学那么多原理…
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秦愿鹏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值