JAVA Spring Boot 整合JDBC学习笔记

最新推荐文章于 2024-03-05 10:36:57 发布
最新推荐文章于 2024-03-05 10:36:57 发布
阅读量364 收藏 1
点赞数
分类专栏： 文章回收站 文章标签： java
本文内容如有侵权，请及时内信我删除。博客内容仅供学习参考，不可用于其他用途。转载请注明本文作者：乌药ice
本文链接：https://blog.csdn.net/qq_41138935/article/details/107326335
版权
1.新建Maven工程（使用spring Initializr）
2.pom.xml文件中添加相关依赖
<!--Thymeleaf启动器坐标-->
<dependency>    
    <groupId>org.springframework.boot</groupId>    
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!--JDBC启动器-->
<dependency>    
    <groupId>org.springframework.boot</groupId>    
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--MYSQL数据库启动器坐标-->
<dependency>    
    <groupId>mysql</groupId>    
    <artifactId>mysql-connector-java</artifactId>                                    <version>8.0.16</version>
</dependency>

依赖来自 https://mvnrepository.com

3.配置数据源
  • pom.xml文件中添加Druid
<!--Druid数据源依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.22</version>
</dependency>
  • 新建配置文件jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=root
  • 创建配置类

config包下新建JdbcConfiguration.java类文件

@Configuration
@PropertySource("classpath:/jdbc.properties")         // 加载指定的Properties配置文件
public class JdbcConfiguration {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    //    实例化Druid
    @Bean
    public DataSource getDataSourse(){
        DruidDataSource source = new DruidDataSource();
        source.setUsername(this.username);
        source.setPassword(this.password);
        source.setUrl(this.url);
        source.setDriverClassName(this.driverClassName);
        return source;
    }
}
  • 编写Controller

新建controller包，然后创建UsersController.java类文件

@Controller
public class UsersController {
    @Autowired
    private DataSource dataSource;

    @GetMapping("/showInfo")
    public String showinfo(){
        return "ok";
    }

}
  • 通过@ConfigurationProperties注解读取配置信息

@PropertySource是属于springframework的注解
@ConfigurationProperties是属于springboot的注解

1.在config包下创建JdbcProperties.java类文件

@ConfigurationProperties(prefix = "jdbc")        //是spring boot的注解，不能读取其他配置文件，prefix设置读取配置文件的前缀
public class JdbcProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.JdbcConfiguration配置文件中配置

使用@Autowired注解

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)     //指定加载那个配置信息属性类
public class JdbcConfiguration {

    @Autowired
    private JdbcProperties jdbcProperties;

    //    实例化Druid
    @Bean
    public DataSource getDataSourse(){
        DruidDataSource source = new DruidDataSource();
        source.setUsername(this.jdbcProperties.getUsername());
        source.setPassword(this.jdbcProperties.getPassword());
        source.setUrl(this.jdbcProperties.getUrl());
        source.setDriverClassName(this.jdbcProperties.getDriverClassName());
        return source;
    }
}

通过构造方法进行注解

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)     //指定加载那个配置信息属性类
public class JdbcConfiguration {

    private JdbcProperties jdbcProperties;

    /**
     * 使用构造方法进行注解
     */
    public JdbcConfiguration(JdbcProperties jdbcProperties){
        this.jdbcProperties = jdbcProperties;
    }


    //    实例化Druid
    @Bean
    public DataSource getDataSourse(){
        DruidDataSource source = new DruidDataSource();
        source.setUsername(this.jdbcProperties.getUsername());
        source.setPassword(this.jdbcProperties.getPassword());
        source.setUrl(this.jdbcProperties.getUrl());
        source.setDriverClassName(this.jdbcProperties.getDriverClassName());
        return source;
    }
}

通过形参进行注解

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)     //指定加载那个配置信息属性类
public class JdbcConfiguration {

    @Bean
    public DataSource getDataSourse(JdbcProperties jdbcProperties){
        DruidDataSource source = new DruidDataSource();
        source.setUsername(jdbcProperties.getUsername());
        source.setPassword(jdbcProperties.getPassword());
        source.setUrl(jdbcProperties.getUrl());
        source.setDriverClassName(jdbcProperties.getDriverClassName());
        return source;
    }
}

2.1 @ConfigurationProperties注解的优雅使用方式

@Configuration
public class JdbcConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource getDataSourse(){
        DruidDataSource source = new DruidDataSource();

        return source;
    }
}

从配置文件application.properties处直接读取信息

配置文件配置数据源

在 Spring Boot 1.x 版本中的spring-boot-starter-jdbc 启动器中默认使用的是org.apache.tomcat.jdbc.pool.DataSource 作为数据源
在 Spring Boot 2.x 版本中的 spring-boot-starter-jdbc 启动器中默认使用的是com.zaxxer.hikariDataSource 作为数据源

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

MySQL8.0的配置文件

spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

增删查改部分

实现添加用户功能
1.数据库添加Users数据表
2.创建实体类

在包下新建pojo文件夹，新建Users类，代码如下：

public class Users {
    private Integer userid;
    private String username;
    private String usersex;

    public Integer getUserid() {
        return userid;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getUsersex() {
        return usersex;
    }

    public void setUsersex(String usersex) {
        this.usersex = usersex;
    }
}
创建页面

在templates文件夹下新建addUser.html文件，代码如下：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<link rel="shortcut icon" href="../resources/favicon.ico" th:href="@{/static/favicon.ico}">
<head>
    <meta charset="UTF-8">
    <title>添加用户</title>
</head>
<body>
    <form th:action="@{/user/addUser}" method="post">
        <input type="text" name="username" /><br/>
        <input type="text" name="usersex" /><br/>
        <input type="submit" value="提 交"/>
    </form>
</body>
</html>
创建UsersController

在Controller文件夹下新建UsersController.java，代码如下：

package com.bjsxt.springbootjdbc.controller;

import com.bjsxt.springbootjdbc.pojo.Users;
import com.bjsxt.springbootjdbc.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.sql.DataSource;
import java.util.List;

/**
 * ClassName:    UsersController
 * Package:    com.bjsxt.springbootjdbc.controller
 * Description:
 * Datetime:    2020/7/10   10:48
 * Author:   wybing(wybingcom@126.com)
 */

@Controller
@RequestMapping("/user")
public class UsersController {
    @Autowired
    private UsersService usersService;
    /**
     * 添加用户
     */
    @PostMapping("addUser")
    public String addUser(Users users){
        try{
            this.usersService.addUser(users);
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }
        return "redirect:/ok";
    }

    @GetMapping("findUserAll")
    public String findUserAll(Model model){
        List<Users> list = null;
        try{
            list = this.usersService.findUsersAll();
            model.addAttribute("list",list);
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }
        return "showUsers";
    }

    @GetMapping("/preUpdateUser")
    public String preUpdateUser(Integer id,Model model){
        try{
            Users user = this.usersService.findUserById(id);
            model.addAttribute("user",user);
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }

        return "updateUser";
    }

    @PostMapping("/updateUser")
    public String updateUser(Users users){
        try{
            this.usersService.modifyUser(users);
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }
        return "redirect:/ok";
    }

    @GetMapping("/delateUser")
    public String updateUser(Integer id){
        try{
            this.usersService.dropUser(id);
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }
        return "redirect:/ok";
    }
}
创建PageController

在Controller文件夹下新建PageController.java，代码如下：

package com.bjsxt.springbootjdbc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * ClassName:    PageController
 * Package:    com.bjsxt.springbootjdbc.controller
 * Description:     页面跳转Controller
 * Datetime:    2020/7/10   17:04
 * Author:   wybing(wybingcom@126.com)
 */

@Controller
public class PageController {
    /**
     * 页面跳转方法
     */
    @RequestMapping("/{page}")
    public String showPage(@PathVariable String page){
        return page;
    }
}
创建Service

新建Service文件夹，在该文件夹下新建UsersService.java文件，代码如下：

package com.bjsxt.springbootjdbc.service;

import com.bjsxt.springbootjdbc.pojo.Users;

import java.util.List;

/**
 * ClassName:    UsersService
 * Package:    com.bjsxt.springbootjdbc.service
 * Description:     接口
 * Datetime:    2020/7/10   17:17
 * Author:   wybing(wybingcom@126.com)
 */
public interface UsersService {
    void addUser(Users users);
    List<Users> findUsersAll();
    Users findUserById(Integer id);
    void modifyUser(Users users);
    void dropUser(Integer id);
}

创建持久层：在Service文件夹下创建impl文件夹，在该文件夹下新建UsersServiceImpl.java文件，代码如下：

package com.bjsxt.springbootjdbc.service.impl;

import com.bjsxt.springbootjdbc.dao.UsersDao;
import com.bjsxt.springbootjdbc.pojo.Users;
import com.bjsxt.springbootjdbc.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * ClassName:    UsersServiceImpl
 * Package:    com.bjsxt.springbootjdbc.service.impl
 * Description:     接口实现类
 * Datetime:    2020/7/10   17:20
 * Author:   wybing(wybingcom@126.com)
 */
@Service
public class UsersServiceImpl implements UsersService {
    @Autowired
    private UsersDao  usersDao;

    /**
     * 添加用户
     * @param users
     */
    @Override
    @Transactional
    public void addUser(Users users){
        this.usersDao.insertUsers(users);
    }

    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> findUsersAll() {
        return this.usersDao.selectUsersAll();
    }

    /**
     * 预更新查询
     * @param id
     * @return
     */
    @Override
    public Users findUserById(Integer id) {
        return this.usersDao.selectuserById(id);
    }

    /**
     * 更新用户
     * @param users
     */
    @Override
    @Transactional  //CURD操作最好加上
    public void modifyUser(Users users) {
        this.usersDao.updateUsers(users);
    }

    /**
     * 删除用户
     * @param id
     */
    @Override
    @Transactional
    public void dropUser(Integer id) {
        this.usersDao.deleteUserById(id);
    }
}
创建数据访问层

在项目包下新建dao文件夹，在该文件夹下新建UsersDao.java文件，代码如下：

package com.bjsxt.springbootjdbc.dao;

import com.bjsxt.springbootjdbc.pojo.Users;

import java.util.List;

/**
 * ClassName:    UsersDao
 * Package:    com.bjsxt.springbootjdbc.dao
 * Description:
 * Datetime:    2020/7/10   17:23
 * Author:   wybing(wybingcom@126.com)
 */
public interface UsersDao {
    void insertUsers(Users users);
    List<Users> selectUsersAll();
    Users selectuserById(Integer id);
    void updateUsers(Users users);
    void deleteUserById(Integer id);
}

在dao文件夹下新建impl文件夹，在该文件夹下新建文件UsersDaolmpl.java

package com.bjsxt.springbootjdbc.dao.impl;

import com.bjsxt.springbootjdbc.dao.UsersDao;
import com.bjsxt.springbootjdbc.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * ClassName:    UsersDaoImpl
 * Package:    com.bjsxt.springbootjdbc.dao.impl
 * Description:     持久层
 * Datetime:    2020/7/10   17:24
 * Author:   wybing(wybingcom@126.com)
 */
@Repository
public class UsersDaoImpl  implements UsersDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 添加用户
     * @param users
     */
    @Override
    public void insertUsers(Users users){
        String sql = "insert into users(username,usersex) values (?,?)";
        this.jdbcTemplate.update(sql,users.getUsername(),users.getUsersex());
    }

    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll() {
        String sql = "select * from users";
        /**
         * 查询返回多个数据，使用RowMapper
         */
        return this.jdbcTemplate.query(sql, new RowMapper<Users>() {
            /**
             * 对结果集的映射
             * @param resultSet
             * @param i
             * @return
             * @throws SQLException
             */
            @Override
            public Users mapRow(ResultSet resultSet, int i) throws SQLException {
                Users users = new Users();
                users.setUserid(resultSet.getInt("userid"));
                users.setUsername(resultSet.getString("username"));
                users.setUsersex(resultSet.getString("usersex"));
                return users;
            }
        });
    }

    /**
     * 预更新用户查询
     * @param id
     * @return
     */
    @Override
    public Users selectuserById(Integer id) {
        Users user = new Users();
        /**
         * 查询返回单个对象，使用RowCallbackHandler
         */
        String sql = "select * from users where userid = ?";
        // 第一种方法
//        this.jdbcTemplate.query(sql,new RowCallbackHandler(){
//            @Override
//            public void processRow(ResultSet resultSet) throws SQLException{
//                user.setUserid(resultSet.getInt("userid"));
//                user.setUsersex(resultSet.getString("usersex"));
//                user.setUsername(resultSet.getString("username"));
//            }
//        });
        // 第二种方法
        Object[] arr = new Object[]{id};
        this.jdbcTemplate.query(sql, arr, new RowCallbackHandler() {
            @Override
            public void processRow(ResultSet resultSet) throws SQLException {
                user.setUserid(resultSet.getInt("userid"));
                user.setUsersex(resultSet.getString("usersex"));
                user.setUsername(resultSet.getString("username"));
            }
        });
        return user;
    }

    /**
     * 更新用户
     * @param users
     */
    @Override
    public void updateUsers(Users users) {
        String sql = "update users set username = ?,usersex = ? where userid = ?";
        this.jdbcTemplate.update(sql,users.getUsername(),users.getUsersex(),users.getUserid());

    }

    /**
     * 删除用户
     * @param id
     */
    @Override
    public void deleteUserById(Integer id) {
        String sql = "delete from users where userid = ?";
        this.jdbcTemplate.update(sql,id);
    }
}

以上代码来自视频教程
https://www.bilibili.com/video/BV1sc411h7pN

乌药ice
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot学习笔记
03-21
Thymeleaf 国际化 整合MyBatis，JDBC
SpringBoot高级篇JdbcTemplate之数据查询下篇
weixin_33743880的博客
04-23 999
SpringBoot高级篇JdbcTemplate之数据查询上篇 讲了如何使用JdbcTemplate进行简单的查询操作，主要介绍了三种方法的调用姿势 queryForMap, queryForList, queryForObject 本篇则继续介绍剩下的两种方法使用说明 queryForRowSet query I. 环境准备 环境依然借助前面一篇的配置，链接如： 190407-Sprin...
springboot整合JDBC--查询返回指定的对象集合(JdbcTemplate的query)
yuzheh521的博客
04-29 1594
1.实体类实现RowMapper接口,并重写mapRow方法 import org.springframework.jdbc.core.RowMapper;//倒入包 import java.sql.ResultSet; import java.sql.SQLException; public class tbUser implements RowMapper { private lon...
springboot整合jdbc--spring-data-jdbc入门
最新发布
qq_62377885的博客
03-05 1046
JDBC(Java Data Base Connectivity):提供了一组Java程序访问关系数据库的API,使ava程序可以与任何支持SQL标准的数据库交互。JDBC优点·简洁的SQL处理·针对大型数据的良好性能·接口语法简单·非常适合小型应用程序JDBC缺点·SQL语句以硬编码写于代码中，不利于维护移植需了解并掌握数据库技术·需手动实现封装·大型项目维护复杂，编程开销大ORM，即对象关系映射（Object-Relational Mapping）
SpringBoot 中使用 JdbcTemplate 访问关系型数据库
姜皓的博客
12-16 325
SpringBoot 中使用 JdbcTemplate 访问关系型数据库1）数据模型和 Repository 层设计2）使用 JdbcTemplate 操作数据库使用 JdbcTemplate 实现查询使用 JdbcTemplate 实现插入使用 SimpleJdbcInsert 简化数据插入过程3）小结 JDBC 规范是 Java 领域中使用最广泛的数据访问标准，目前市面上主流的数据访问框架都是构建在 JDBC 规范之上。因为 JDBC 是偏底层的操作规范，所以关于如何使用 JDBC 规范进行关系型数据访
基于Spring Boot应用JdbcTemplate操作数据库(查增改删)
zhangbeizhen18的博客
08-06 1816
记录：289 场景：基于Spring Boot应用JdbcTemplate操作数据库。包括查、增、改、删操作。对应SQL关键字是select、insert into、update、delete。
Spring JdbcTemplate.queryForObject()
allway2的博客
10-30 7828
Spring是JDBC核心包中的中心类。它简化了 JDBC 与 Spring 的使用，并有助于避免常见错误。在此页面上，我们将学习使用它的方法。JdbcTemplate.queryForObject不同参数的方法。执行给定的 SQL 并返回所需类型的对象。查询给定的 SQL 以从 SQL 创建预准备语句和要绑定到查询的参数列表，需要一个结果对象。查询给定的 SQL 以从 SQL 创建预准备语句和要绑定到查询的参数列表，需要一个结果对象。
spring boot整合sharding jdbc5.2.0分库分表demo
11-01
实现其包含的内置算法以及自定义算法，包含demo的文档及注释
Spring boot整合MinIO客户端实现文件管理
06-27
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和...Spring boot整合MinIO客户端实现文件管理
spring boot整合netty的实现方法
08-25
主要介绍了spring boot整合netty的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring boot 学习笔记（入门篇）
08-28
ing Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。这篇文章给大家带来了spring boot 入门学习笔记，需要的朋友参考下
Spring JdbcTemplate.queryForMap()
allway2的博客
10-30 4519
在本文中，我们将学习JdbcTemplate.queryForMap使用方法。它执行给定的SQL，将查询与给定的参数绑定。查询应为单行查询。此方法返回结果为Map。JdbcTemplate.queryForMap期望参数如下。执行静态 SQL 并返回Map。此方法使用 JDBC Statement，而不是 PreparedStatement。查询应为单行查询。结果将映射到 Map。列名是Map的键和列值是该Map键的值。
SpringBoot高级篇JdbcTemplate之数据查询上篇
weixin_33920401的博客
04-23 751
前面一篇介绍如何使用JdbcTemplate实现插入数据，接下来进入实际业务中，最常见的查询篇。由于查询的姿势实在太多，对内容进行了拆分，本篇主要介绍几个基本的使用姿势 queryForMap queryForList queryForObject I. 环境准备 环境依然借助前面一篇的配置，链接如： 190407-SpringBoot高级篇JdbcTemplate之数据插入使用姿势详解 或...
SpringBoot - 数据库操作之 JdbcTemplate 基本使用
small_love的专栏
12-27 1327
一、什么是JdbcTemplate JdbcTemplate是Spring提供的一套JDBC模板框架，利用AOP技术来解决直接使用JDBC时大量重复代码的问题。 JdbcTemplate虽然没有MyBatis那么灵活，但是比直接使用JDBC要方便很多 二、安装配置 1、在 pom.xml 文件中添加如下依赖 spring-boot-starter-jdbc：提供对JDBC数据库的支持 mysql-connector-java：MySQL数据库驱动 hikari：SpringBoot 自...
Springboot中数据库访问的两种方式之-JdbcTemplate
非凡技术
05-25 4652
目录 01、写在前面 02、项目依赖 03、创建模型脚本 04、读取数据库 05、Controller 06、开始测试 本文由bingo创作，授权我原创发布。 Tiger和他朋友们的原创技术文章，请关注wx “跟哥一起学python”，ID “tiger-python”。不止Python！！ 在大多数的项目开发中，我们都有把数据存入数据库和从数据库中读取的操作，所以与数据库打交道是必不可少的。 众所周知，spring提供了很多工具，我们拿来就可以用，使我们的项目开发更方便、快捷（..
spring boot jdbcTemplate简单查询的使用
zhaoyy0513的博客
03-31 842
本文参考自:https://blog.csdn.net/chenyezhou1/article/details/71122570 (1)基础的查询操作，因为jdbcTemplate不像mybatis那种有对应的映射关系，因此操作实体，需要手写函数 class UserRowMapper implements RowMapper<User> { publ...
Spring Boot 使用JdbcTemplate操作数据库
Sadlay的博客
11-04 1422
使用JdbcTemplate操作数据库 配置数据源 以MySQL作为自定义数据源。首先在pom.xml中去除对h2的依赖。保留spring-boot-starter-data-jpa的依赖，然后增加Mysql的依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artif...
对于JdbcTemplate#queryForObject()的使用
热门推荐
lqadam的博客
05-13 1万+
JdbcTemplate#queryForObject()的误用在我写的小工程中,我使用了,也仅使用了Spring,所以数据库访问相关的操作都是通过Spring的JdbcTemplate解决的,除了要码sql语句,还要填充Bean对象之外,其他感觉都不错.在这个过程中,我使用了JdbcTemplate的几个方法,其中对于queryForObject方法,我起初有一些误用,后来出错才改正,这里做一个记
【SpringBoot初级篇】JdbcTemplate常用方法
输入技术、输出想法
03-03 4861
1、查询记录条数 2、按条件查询记录条数，通过参数绑定 3、查询多个字段，返回一个 4、查询多条数据，每条数据都以形式返回，整个结果是 5、查询单条数据并通过映射成实体对象 6、查询对象集合 7、将字段到实体映射抽出来单独维护通常在应用中，字段到实体的映射只需要编写一份来维护，因此前边的两例中的映射可以单独抽出来成为一个类： 然后在使用的时候创建就行了： 8、插入数据并返回生成的主键 JdbcTemplate 插入、更新、删除 在中，数据的插入、更新、删除操作都是通过来完成的。1、插入单条数据 2、批量插入
Spring Boot Starter JDBC
05-04
Spring Boot Starter JDBC是一个Spring Boot Starter项目，它提供了使用JDBC（Java Database Connectivity）访问关系型数据库的依赖项和自动配置。 使用Spring Boot Starter JDBC，您可以轻松地访问各种关系型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

乌药ice

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

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

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

打赏作者

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

抵扣说明：

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

余额充值