Java_Spring：11. Spring 中的 JdbcTemplate

最新推荐文章于 2024-05-10 12:41:21 发布
最新推荐文章于 2024-05-10 12:41:21 发布
阅读量560 收藏
点赞数
分类专栏： 【笔记】Java_Spring 文章标签： java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiangTao_qjww/article/details/129829914
版权

目录

1 JdbcTemplate 概述

2 JdbcTemplate 对象的创建

3 spring 中配置数据源

3.1 环境搭建

3.2 编写 spring 的配置文件

3.3 配置数据源

3.3.1 配置 C3P0 数据源

3.3.2 配置 DBCP 数据源

3.3.3 配置 spring 内置数据源

3.4 将数据库连接的信息配置到属性文件中:

4 JdbcTemplate 的增删改查操作

4.1 前期准备

4.2 在 spring 配置文件中配置 JdbcTemplate

4.3 最基本使用

4.4 保存操作

4.5 更新操作

4.6 删除操作

4.7 查询所有操作

4.8 查询一个操作

4.9 查询返回一行一列操作

5 在 dao 中使用 JdbcTemplate

5.1 准备实体类

5.2 第一种方式：在 dao 中定义 JdbcTemplate

5.3 第二种方式：让 dao 继承 JdbcDaoSupport

  • 1 JdbcTemplate 概述

    • JdbcTemplate 是spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装，需要导入一个 spring-tx-5.0.2.RELEASE.jar（和事务相关）。
    • spring 框架为我们提供了很多的操作模板类。
      • 操作关系型数据的：
        • JdbcTemplate
        • HibernateTemplate
      • 操作 nosql 数据库的：
        • RedisTemplate
      • 操作消息队列的：
        • JmsTemplate

  • 2 JdbcTemplate 对象的创建

    • 参考源码：
    • public JdbcTemplate() {
}

public JdbcTemplate(DataSource dataSource) {
    setDataSource(dataSource);
    afterPropertiesSet();
}

public JdbcTemplate(DataSource dataSource, boolean lazyInit) {
    setDataSource(dataSource);
    setLazyInit(lazyInit);
    afterPropertiesSet();
}
    • 除了默认构造函数之外，都需要提供一个数据源。
    • 因为有set方法，依据依赖注入，可以在配置文件中配置这些对象。

  • 3 spring 中配置数据源

    • 3.1 环境搭建

    • 3.2 编写 spring 的配置文件

      • <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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">
</beans>

    • 3.3 配置数据源

      • C3P0 和 DBCP，要想使用这两数据源都需要导入对应的 jar 包。

      • 3.3.1 配置 C3P0 数据源

        • 导入"c3p0-0.9.2.1.jar"到工程的 lib 目录。在 spring 的配置文件中配置：
        • <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
    <property name="user" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

      • 3.3.2 配置 DBCP 数据源

        • 导入 "commons-dbcp.jar" 和 "commons-pool.jar" 到工程的 lib 目录。在 spring 的配置文件中配置：
        • <!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:// /spring_day02"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

      • 3.3.3 配置 spring 内置数据源

        • spring 框架也提供了一个内置数据源，就在 spring-jdbc-5.0.2.REEASE.jar 包中：
        • <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///spring_day02"></property>
    <property name="username" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

    • 3.4 将数据库连接的信息配置到属性文件中:

      • 【定义属性文件】
      • jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_day02
jdbc.username=root
jdbc.password=123
    • 【引入外部的属性文件】
      • 一种方式:
      • <!-- 引入外部属性文件： -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties"/>
</bean>
      • 另一种方式:
      • <context:property-placeholder location="classpath:jdbc.properties"/>

  • 4 JdbcTemplate 的增删改查操作

    • 4.1 前期准备

      • 创建数据库：
      • create database spring_day02;
use spring_day02;
      • 创建表：
      • create table account(
    id int primary key auto_increment,
    name varchar(40),
    money float
) character set utf8 collate utf8_general_ci;

    • 4.2 在 spring 配置文件中配置 JdbcTemplate

      • <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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">

    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day02"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

    • 4.3 最基本使用

      • public class JdbcTemplateDemo2 {
    
    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        jt.execute("insert into account(name,money)values('eee',500)");
    }
}

    • 4.4 保存操作

      • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //保存
        jt.update("insert into account(name,money)values(?,?)","fff",5000);
    }
}

    • 4.5 更新操作

      • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //修改
        jt.update("update account set money = money-? where id = ?",300,6);
    }
}

    • 4.6 删除操作

      • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //删除

        jt.update("delete from account where id = ?",6);
    }
}

    • 4.7 查询所有操作

      • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {
    
        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //查询所有
        List<Account> accounts = jt.query("select * from account where money > ? ", 
        new AccountRowMapper(), 500);
    
        for(Account o : accounts){
            System.out.println(o);
        }
    }
}

public class AccountRowMapper implements RowMapper<Account>{

    @Override
    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
        Account account = new Account();
        account.setId(rs.getInt("id"));
        account.setName(rs.getString("name"));
        account.setMoney(rs.getFloat("money"));
        return account;
    }
}

    • 4.8 查询一个操作

      • 使用 RowMapper 的方式：常用的方式 
        • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //查询一个
        List<Account> as = jt.query("select * from account where id = ? ", 
        new AccountRowMapper(), 55);
        System.out.println(as.isEmpty()?"没有结果":as.get(0));
    }
}
      • 使用 ResultSetExtractor 的方式:不常用的方式 
        • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {

        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //查询一个
        Account account = jt.query("select * from account where id = ?",
        new AccountResultSetExtractor(),3);
        System.out.println(account);
    }
}

    • 4.9 查询返回一行一列操作

      • public class JdbcTemplateDemo3 {

    public static void main(String[] args) {
        
        //1.获取 Spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据 id 获取 bean 对象
        JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbcTemplate");

        //3.执行操作
        //查询返回一行一列：使用聚合函数，在不使用 group by 字句时，都是返回一行一列。
        //最长用的就是分页中获取总记录条数
        Integer total = jt.queryForObject("select count(*) from account where money > ? ",Integer.class,500);

        System.out.println(total);     
    }

}

  • 5 在 dao 中使用 JdbcTemplate

    • 5.1 准备实体类

      • 账户的实体
      • public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
    
    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;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
    }
}

    • 5.2 第一种方式：在 dao 中定义 JdbcTemplate

      • 账户的接口
      • public interface IAccountDao {
    
    /**
    * 根据 id 查询账户信息
    * @param id
    * @return
    */
    Account findAccountById(Integer id);
    
    /**
    * 根据名称查询账户信息
    * @return
    */
    Account findAccountByName(String name);
        
    /**
    * 更新账户信息
    * @param account
    */
    void updateAccount(Account account);
}
      • 账户的持久层实现类
      • 此版本的 dao，需要给 dao 注入 JdbcTemplate
      • public class AccountDaoImpl implements IAccountDao {

    private JdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Account findAccountById(Integer id) {
        
        List<Account> list = jdbcTemplate.query("select * from account where id = ? ",new AccountRowMapper(),id);
        return list.isEmpty()?null:list.get(0);
    }

    @Override
    public Account findAccountByName(String name) {

        List<Account> list = jdbcTemplate.query("select * from account where name = ? ",new AccountRowMapper(),name);
        
        if(list.isEmpty()){
            return null;
        }

        if(list.size()>1){
            throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
        }

    return list.get(0);
    }

    @Override
    public void updateAccount(Account account) {

        jdbcTemplate.update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
    }
}
      • ​​​​​​​​​​​​​​配置文件
      • <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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">

    <!-- 配置一个 dao -->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">

        <!-- 注入 jdbcTemplate -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!-- 配置一个数据库的操作模板：JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource"
            class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>
      • ​​​​​​​​​​​​​​思考：
        • 此种方式有什么问题吗?
      • 答案：
        • 有个小问题。就是dao 有很多时，每个 dao 都有一些重复性的代码。下面就是重复代码：
        • private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
    this.jdbcTemplate = jdbcTemplate;
}
      • ​​​​​​​​​​​​​​能不能把它抽取出来呢？
      • 请看下一小节。

    • 5.3 第二种方式：让 dao 继承 JdbcDaoSupport

      • JdbcDaoSupport 是 spring 框架提供的一个类，该类中定义了一个 JdbcTemplate 对象，可以直接获取使用，但是要想创建该对象，需要为其提供一个数据源：具体源码如下：
      • public abstract class JdbcDaoSupport extends DaoSupport {

    //定义对象
    private JdbcTemplate jdbcTemplate;

    //set 方法注入数据源，判断是否注入了，注入了就创建 JdbcTemplate
    public final void setDataSource(DataSource dataSource) {
    
        if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {             
 
            //如果提供了数据源就创建 JdbcTemplate
            this.jdbcTemplate = createJdbcTemplate(dataSource);
            initTemplateConfig();
        }
    }

    //使用数据源创建 JdcbTemplate
    protected JdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    //当然，我们也可以通过注入 JdbcTemplate 对象
    public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        initTemplateConfig();
    }

    //使用 getJdbcTmeplate 方法获取操作模板对象
    public final JdbcTemplate getJdbcTemplate() {
        return this.jdbcTemplate;
    }
}
      • 账户的接口
      • public interface IAccountDao {

    /**
    * 根据 id 查询账户信息
    * @param id
    * @return
    */
    Account findAccountById(Integer id);

    /**
    * 根据名称查询账户信息
    * @return
    */

    Account findAccountByName(String name);
    /**
    * 更新账户信息
    * @param account
    */
    void updateAccount(Account account);
}
      • 账户的持久层实现类
      • 此版本 dao，只需要给它的父类注入一个数据源
      • public class AccountDaoImpl2 extends JdbcDaoSupport implements IAccountDao {

    @Override
    public Account findAccountById(Integer id) {
        
        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);

        return list.isEmpty()?null:list.get(0);
}

    @Override
    public Account findAccountByName(String name) {

        //getJdbcTemplate()方法是从父类上继承下来的。
        List<Account> list = getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
        if(list.isEmpty()){
        return null;
    }

    if(list.size()>1){
        throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
    }

    return list.get(0);
}

    @Override
    public void updateAccount(Account account) {
        //getJdbcTemplate()方法是从父类上继承下来的。
        getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
    }
}
      • ​​​​​​​​​​​​​​配置文件：
      • <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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">

    <!-- 配置 dao2 -->
    <bean id="accountDao2" class="com.itheima.dao.impl.AccountDaoImpl2">

        <!-- 注入 dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource"
            class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

</beans>
      • ​​​​​​​​​​​​​​思考：
        • 两版 Dao 有什么区别呢？
      • 答案：
        • 第一种在 Dao 类中定义 JdbcTemplate 的方式，适用于所有配置方式（xml 和注解都可以）。
        • 第二种让 Dao 继承 JdbcDaoSupport 的方式，只能用于基于 XML 的方式，注解用不了。
JiangTao_xlili
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
code_jdbcTemplate:Spring启动+ jdbcTemplate
05-17
本项目为spring boot+jdbcTemplate,生成基本的增删改查方法使用方法配置gradle环境，导入项目，刷新依赖打开com.cc.code.build下的build文件，在generator方法填入必要参数,例如： public static void generator() ...
使用spring jdbc template简化jdbc数据库操作实例代码
09-30
使用spring jdbc template简化jdbc数据库操作实例代码，简化操作，包括详细测试例子。
JdbcTemplate的基本使用
weixin_40055163的博客
09-11 273
JdbcTemplate的基本使用 1 JdbcTemplate 概述 和入门 它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多的操作模板类。 操作关系型数据的： JdbcTemplate HibernateTemplate 操作 nosql 数据库的： RedisTemplate 操作消息队列的： JmsTemplate 持久层如图所示： JdbcTemplate的作用:它就是用于和数据库交互的，实现对表的CRUD操作。 1.打开I
spring-使用JdbcTemplate保存操作
weixin_34239169的博客
11-09 1179
一、创建spring项目 项目名称：spring101306二、在项目上添加jar包 1.在项目中创建lib目录 /lib 2.在lib目录下添加spring支持 commons-logging.jar junit-4.10.jar log4j.jar mysql-c...
【MySQL数据库】丨一文详解 JdbcTemplate(Spring中的CRUD)
最新发布
陈橘又青的博客
05-10 2万+
API介绍执行查询语句，返回一个List集合，List中存放的是RowMapper指定类型的数据。使用步骤定义Product类创建JdbcTemplate对象编写查询的SQL语句使用JdbcTemplate对象的query方法，并传入RowMapper匿名内部类在匿名内部类中将结果集中的一行记录转成一个Product对象API介绍执行查询语句，返回一个List集合，List中存放的是RowMapper指定类型的数据。
jdbctemplate 一个字段一个字段保存
qq_16690239的博客
01-24 372
controller @ResponseBody @RequestMapping(value = &amp;quot;/addOrUpdataJbxx.do&amp;quot;, method = {RequestMethod.POST}) public int save(@RequestBody Map&amp;amp;lt;String, Object&amp;amp;gt; map) { System.out.printl..
JDBC中--保存--方法详解
荒的博客
04-06 2719
实体类 package day03; /** * 实体类 * 用于表示数据库中表user */ public class User { private int id; private String name; private String password; private int money; private String email; private int deptno;
SpringBoot使用JdbcTemplate批量保存
weixin_30896825的博客
09-03 711
@Autowired DataSourceProperties dataSourceProperties; @Autowired ApplicationContext applicationContext; public List<SubjectKycFileVO> batch() { // JDB...
SpringJDBC.rar_SpringJDBC_jdbctemplate_jdbctemplate spring
09-14
在Java的Spring框架中，Spring JDBC（Java Database Connectivity）是一个重要的模块，用于简化数据库操作。Spring JDBC通过提供JdbcTemplate和SimpleJdbcTemplate等工具类，帮助开发者以更安全、更易于管理的方式与...
java-web-project.zip_jdbctemplate_js项目_spring jdbctemplate
09-23
标题中的"java-web-project.zip_jdbctemplate_js项目_spring jdbctemplate"表明这是一个Java Web项目，使用了Spring框架的JdbcTemplate模块，并且前端部分使用了JavaScript和Ajax技术。这个项目可能是为了演示如何在...
ssm_SpringCRUD2.zip_Java编程_Java__Java编程_Java_
08-09
在CRUD操作中，Spring的DAO支持和JdbcTemplate使得数据库操作变得更加简洁。 2. **Struts框架**：Struts是基于MVC（Model-View-Controller）设计模式的Web应用框架，它主要负责处理HTTP请求，控制应用程序流程。在...
spring_integration_jdbc.rar_spring jdbc
09-14
Spring Integration JDBC是Spring框架的一个重要模块，主要用于在Spring应用程序中集成数据库操作。它提供了一种简单而有效的方式来处理与数据库的交互，无需编写大量的JDBC模板代码。在本压缩包中，我们很可能会...
jdbc保存对象返回一个主键
09-20
jdbc保存对象返回一个主键
java spring jdbc_Spring中使用JDBC
weixin_29022115的博客
02-24 141
Spring中的数据库异常体系使用JDBC(不使用Spring)的时候，我们需要强制捕获SQLException，否则无法使用JDBC处理任何事情。SQLException表示尝试访问数据库的时候出现问题，但是这个异常却没有告诉我们哪里出错以及如何处理。可能出现SQLException的情况有：应用程序无法连接数据库查询的SQL有问题查询中的表，列不存在尝试插入或更新的数据违法数据库的约束还有其他...
java spring jdbc_JAVA-Spring 整合 JDBC
weixin_36372610的博客
02-12 168
一、回顾JDBC1.java操作关系型数据的API。导入相关数据库的驱动包后可以通过JDBC提供的接口来操作数据库。2.实现JDBC的六个步骤注册数据库驱动获取数据库连接获取传输器对象传输sql执行获取结果集对象遍历结果集获取信息关闭资源1 packagecn.tedu.jdbc;23 importjava.sql.Connection;4 ...
使用jdbcTemplate 保存图片 至数据库 以及 从数据库读取 保存到本地
进击的WLAY
06-14 2268
String picPath = ""; //@author wxd final Map map = new HashMap(); if( uploadRequest.getSize("file") > 0 ){ String name = uploadRequest.getFileName("file"); final Stri
两种使用Spring JdbcTemplate实现update或insert操作
热门推荐
我的世界我的梦
10-15 3万+
第一种方式，重载PreparedStatementCreator jdbcTemplate.update(new PreparedStatementCreator()...{    public PreparedStatement createPreparedStatement(Connection conn)...{        String sql="insert into us
说说如何在 Spring Boot 中使用 JdbcTemplate 读写数据
读万卷书，行万里路
09-26 1629
首先在 pom.xml 中引入依赖。 <!--jdbc--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <!--h2--> <dependency> <groupId&gt
数据库7JDBC——Spring JDBCTemplate的使用
baidu_38812804的博客
09-18 249
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发. 目的: 简化JDBC编程 需要导入jar包 JdbcTemplate 使用步骤: 1.导入jar包 2.创建JdbcTemplate对象,依赖于DataSource JdbcTemplate template = new JdbcTemplate(ds); 3.调用JdbcTemplate的方法来完成CRUD的操作 方法: update() 执行DML语句, 增删改语句 queryForMap() 查询结果将
java.lang.ClassNotFoundException: org.springframework.jdbc.core.JdbcTemplate
05-05
你需要在你的项目中添加 Spring JDBC 的依赖。 如果你正在使用 Maven，你可以在你的 `pom.xml` 文件中添加以下依赖： ``` <groupId>org.springframework <artifactId>spring-jdbc <version>5.3.9 ``` 如果你...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值