• Spring Boot JDBC访问数据库（十二）

            我们将学习如何在 Spring Boot 中使用 JDBC 进行数据访问。

    一、JDBC使用配置

    1 导入JDBC场景启动器

            Spring Boot 将日常企业应用研发中的各种场景都抽取出来，做成一个个的场景启动器（Starter），场景启动器中整合了该场景下各种可能用到的依赖，让用户摆脱了处理各种依赖和配置的困扰。
            想要在 Spring  Boot 中使用 JDBC 进行数据访问，第一步就是要在 pom.xml 中导入 JDBC 场景启动器：spring-boot-starter-data-jdbc，代码如下：

    1.        
    2.         <dependency>
    3.             <groupId>org.springframework.bootgroupId>
    4.             <artifactId>spring-boot-starter-data-jdbcartifactId>
    5.         dependency>

            查看 spring-boot-starter-data-jdbc 的依赖树，可以看到，该场景启动器默认引入了一个数据源：HikariCP，如下图所示:

    2 导入数据库驱动

            JDBC 的场景启动器中并没有导入数据库驱动，我们需要根据自身的需求引入所需的数据库驱动。例如，访问 MySQL 数据库时，需要导入 MySQL 的数据库驱动：mysql-connector-java，示例代码如下：

    1.         
    2.         <dependency>
    3.             <groupId>mysqlgroupId>
    4.             <artifactId>mysql-connector-javaartifactId>
    5.             <scope>runtimescope>
    6.         dependency>

    注意：Spring Boot 默认为数据库驱动程序做了版本仲裁，所以我们在导入数据库驱动时，可以不再声明版本。需要注意的是，数据库驱动的版本必须与数据库的版本相对应。 

    3 导入Web场景启动器

    1.         <dependency>
    2.             <groupId>org.springframework.bootgroupId>
    3.             <artifactId>spring-boot-starter-webartifactId>
    4.         dependency>

    4 在配置文件中配置数据库信息

    在application.xml配置文件中配置数据源：

    1. #数据源连接信息
    2. spring:
    3.     datasource:
    4.         username: root
    5.         password: 12345
    6.         url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8
    7.         driver-class-name: com.mysql.cj.jdbc.Driver

    关于Web场景启动器可以参考我的另一篇博客：

    Spring Boot spring-boot-starter-web（九）_人……杰的博客-CSDN博客

    二、项目举例

    1 项目框架

     2 代码实现

    MainApplication.java:

    1. package com.xj.main;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.context.annotation.ComponentScan;
    6.  
    7. @ComponentScan("com.xj")
    8. @SpringBootApplication
    9. public class MainApplication {
    10.     public static void main(String[] args) {
    11.         SpringApplication.run(MainApplication.class, args);
    12.     }
    13. }

    User.java:

    1. package com.xj.entity;
    2.  
    3.  
    4. public class User {
    5.  
    6.     private Long id;
    7.     //姓名
    8.     private String name;
    9.     //性别
    10.     private String gender;
    11.     //年龄
    12.     private Integer age;
    13.  
    14.     //无参构造方法
    15.     public User(){}
    16.  
    17.     //无参构造方法
    18.     public User(Integer age){
    19.         this.age = age;
    20.     }
    21.  
    22.     //有参构造方法
    23.     public User(String name, String gender, Integer age){
    24.         this.name = name;
    25.         this.gender = gender;
    26.         this.age = age;
    27.     }
    28.  
    29.     public Long getId() {
    30.         return id;
    31.     }
    32.  
    33.     public void setId(Long id) {
    34.         this.id = id;
    35.     }
    36.  
    37.     public String getName() {
    38.         return name;
    39.     }
    40.  
    41.     public void setName(String name) {
    42.         this.name = name;
    43.     }
    44.  
    45.     public String getGender() {
    46.         return gender;
    47.     }
    48.  
    49.     public void setGender(String gender) {
    50.         this.gender = gender;
    51.     }
    52.  
    53.     public Integer getAge() {
    54.         return age;
    55.     }
    56.  
    57.     public void setAge(Integer age) {
    58.         this.age = age;
    59.     }
    60.  
    61.     @Override
    62.     public String toString() {
    63.         return "User[ID:" + id + ", name:"+ name+", gender:" + gender + ", age:" + age + "]";
    64.     }
    65. }

    JdbcController.java:

    1. package com.xj.controller;
    2.  
    3. import com.xj.entity.User;
    4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
    5. import org.springframework.jdbc.core.JdbcTemplate;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.*;
    8. import java.util.List;
    9.  
    10. @ResponseBody
    11. @Controller
    12. @RequestMapping("/jdbc")
    13. public class JdbcController {
    14.  
    15.     private final JdbcTemplate template;
    16.  
    17.     public JdbcController(JdbcTemplate template) {
    18.         this.template = template;
    19.     }
    20.  
    21.  
    22.     @GetMapping
    23.     public List queryAllUser(){
    24.         //查询所有用户
    25.         String sql = "select * from user_table";
    26.         return template.query(sql, new Object[]{}, new BeanPropertyRowMapper<>(User.class));
    27.     }
    28.  
    29.     @GetMapping("/{id}")
    30.     public User getUserById(@PathVariable Long id){
    31.         //根据主键查询一个用户
    32.         String sql = "select * from user_table where ID = ?";
    33.         return template.queryForObject(sql, new Object[]{id}, new BeanPropertyRowMapper<>(User.class));
    34.     }
    35.  
    36.     @PostMapping
    37.     public int addUser(@RequestBody User user){
    38.         //添加用户
    39.         String sql = "insert into user_table(name, gender, age) value(?, ?, ?)";
    40.         return template.update(sql, user.getName(), user.getGender(), user.getAge());
    41.     }
    42.  
    43.     @PutMapping("/{name}")
    44.     public int editUserByName(@PathVariable String name,@RequestBody User user){
    45.         //根据姓名修改用户
    46.         String sql = "update user_table set age = ? where name = ?";
    47.         return template.update(sql, user.getAge(), name);
    48.     }
    49.  
    50.     @DeleteMapping("/{id}")
    51.     public int deleteUserById(@PathVariable Long id){
    52.         //根据ID删除用户
    53.         String sql = "delete from user_table where id = ?";
    54.         return template.update(sql, id);
    55.     }
    56. }

    JdbcTest.java:

    1. package com.xj.main;
    2.  
    3. import com.xj.entity.User;
    4. import org.junit.jupiter.api.Test;
    5. import org.slf4j.Logger;
    6. import org.slf4j.LoggerFactory;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.boot.test.context.SpringBootTest;
    9. import org.springframework.boot.test.web.client.TestRestTemplate;
    10. import org.springframework.boot.web.server.LocalServerPort;
    11. import org.springframework.core.ParameterizedTypeReference;
    12. import org.springframework.http.HttpMethod;
    13. import org.springframework.http.ResponseEntity;
    14. import org.springframework.jdbc.core.JdbcTemplate;
    15. import javax.sql.DataSource;
    16. import java.sql.SQLException;
    17. import java.util.List;
    18.  
    19.  
    20. @SpringBootTest(classes = MainApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    21. public class JdbcTest {
    22.  
    23.     private static final Logger log = LoggerFactory.getLogger(JdbcTest.class);
    24.  
    25.     //数据源组件
    26.     @Autowired
    27.     DataSource dataSource;
    28.     //用于访问数据库的组件
    29.     @Autowired
    30.     JdbcTemplate jdbcTemplate;
    31.  
    32.     @Autowired
    33.     private TestRestTemplate restTemplate;
    34.  
    35.     @LocalServerPort
    36.     private int port;
    37.  
    38.     //连接测试
    39.     @Test
    40.     void contextLoads() throws SQLException {
    41.         System.out.println("默认数据源为：" + dataSource.getClass());
    42.         System.out.println("数据库连接实例：" + dataSource.getConnection());
    43.         //访问数据库
    44.         Integer i = jdbcTemplate.queryForObject("SELECT count(*) from `user_table`", Integer.class);
    45.         System.out.println("user 表中共有" + i + "条数据。");
    46.     }
    47.  
    48.     @Test
    49.     void testJdbc() throws SQLException{
    50.         //查询所有用户
    51.         // TODO 如果是返回的集合,要用 exchange 而不是 getForEntity ，后者需要自己强转类型
    52.         ResponseEntity> response2 = restTemplate.exchange("http://localhost:" + port + "/jdbc", HttpMethod.GET, null, new ParameterizedTypeReference>() {
    53.         });
    54.         final List body = response2.getBody();
    55.         log.info("[查询所有] - [{}]\n", body);
    56.  
    57.         //根据主键查询一个用户
    58.         Long userId = body.get(0).getId();
    59.         ResponseEntity response3 = restTemplate.getForEntity("http://localhost:" + port + "/jdbc/{id}", User.class, userId);
    60.         log.info("[主键查询] - [{}]\n", response3.getBody());
    61.  
    62.         //添加一个用户
    63.         restTemplate.postForEntity("http://localhost:" + port + "/jdbc", new User("浮生若梦", "female", 23), Integer.class);
    64.         log.info("[添加用户成功]\n");
    65.  
    66.         //根据姓名修改用户
    67.         String name = body.get(0).getName();
    68.         restTemplate.put("http://localhost:" + port + "/jdbc/{name}", new User(18), name);
    69.         log.info("[修改用户成功]\n");
    70.  
    71.         //根据id删除用户
    72.         restTemplate.delete("http://localhost:" + port + "/jdbc/{id}", userId);
    73.         log.info("[删除用户成功]");
    74.     }
    75. }

    application.yml:

    1. #默认配置
    2. server:
    3.     port: 8080
    4.  
    5. #数据源连接信息
    6. spring:
    7.     datasource:
    8.         username: root
    9.         password: 12345
    10.         url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8
    11.         driver-class-name: com.mysql.cj.jdbc.Driver
    12.

    若想和前面的Spring Boot profile文件（六）知识相结合，配置文件application.yml也可以这样写：

    1. #默认配置
    2. server:
    3.     port: 8080
    4.  
    5. spring:
    6.     datasource: #数据源连接信息
    7.         username: root
    8.         password: 12345
    9.         url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8
    10.         driver-class-name: com.mysql.cj.jdbc.Driver
    11.     profiles:
    12.         active: dev #切换配置,指定使用哪个profile
    13.  
    14. ---
    15. #开发环境
    16. server:
    17.     port: 8081
    18.  
    19. spring:
    20.     config:
    21.         activate:
    22.             on-profile: dev
    23. ---
    24. #测试环境
    25. server:
    26.     port: 8082
    27.  
    28. spring:
    29.     config:
    30.         activate:
    31.             on-profile: test
    32. ---
    33. #生产环境
    34. server:
    35.     port: 8083
    36.  
    37. spring:
    38.     config:
    39.         activate:
    40.             on-profile: prod
    41.  
    42. logging:
    43.     config: classpath:logback-spring.xml #指定使用哪个日志配置文件

    pom.xml:

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>com.xj.studygroupId>
    8.     <artifactId>spring-boot-study-projectartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <parent>
    12.         <groupId>org.springframework.bootgroupId>
    13.         <artifactId>spring-boot-starter-parentartifactId>
    14.         <version>2.4.5version>
    15.         <relativePath/>
    16.     parent>
    17.  
    18.     <dependencies>
    19.         <dependency>
    20.             <groupId>org.springframework.bootgroupId>
    21.             <artifactId>spring-boot-starter-webartifactId>
    22.         dependency>
    23.  
    24.         <dependency>
    25.             <groupId>org.springframework.bootgroupId>
    26.             <artifactId>spring-boot-starter-testartifactId>
    27.             <scope>testscope>
    28.         dependency>
    29.  
    30.         
    31.         <dependency>
    32.             <groupId>org.springframework.bootgroupId>
    33.             <artifactId>spring-boot-starter-data-jdbcartifactId>
    34.         dependency>
    35.  
    36.         <dependency>
    37.             <groupId>org.springframework.bootgroupId>
    38.             <artifactId>spring-boot-configuration-processorartifactId>
    39.             <optional>trueoptional>
    40.         dependency>
    41.  
    42.         
    43.         <dependency>
    44.             <groupId>org.webjarsgroupId>
    45.             <artifactId>jqueryartifactId>
    46.             <version>3.6.0version>
    47.         dependency>
    48.  
    49.         
    50.         <dependency>
    51.             <groupId>org.springframework.bootgroupId>
    52.             <artifactId>spring-boot-starter-thymeleafartifactId>
    53.         dependency>
    54.  
    55.         
    56.         <dependency>
    57.             <groupId>mysqlgroupId>
    58.             <artifactId>mysql-connector-javaartifactId>
    59.             <scope>runtimescope>
    60.         dependency>
    61.     dependencies>
    62.  
    63.     
    64.     <build>
    65.         <plugins>
    66.             
    67.             <plugin>
    68.                 <groupId>org.springframework.bootgroupId>
    69.                 <artifactId>spring-boot-maven-pluginartifactId>
    70.                 <executions>
    71.                     <execution>
    72.                         <goals>
    73.                             <goal>repackagegoal>
    74.                         goals>
    75.                     execution>
    76.                 executions>
    77.             plugin>
    78.         plugins>
    79.     build>
    80. project>

    数据库user_table表:

    1. CREATE TABLE `user_table` (
    2.   `ID` bigint(10) NOT NULL AUTO_INCREMENT,
    3.   `NAME` varchar(50) DEFAULT NULL COMMENT '姓名',
    4.   `GENDER` varchar(10) DEFAULT NULL COMMENT '性别',
    5.   `AGE` int(11) DEFAULT NULL COMMENT '年龄',
    6.   `LAST_TIME` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    7.   `CREATE_TIME` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    8.   PRIMARY KEY (`ID`)
    9. ) ENGINE=InnoDB AUTO_INCREMENT=26 DEFAULT CHARSET=utf8;
    10.

     3 运行结果

    数据库user_table表：

    3.1 运行JdbcTest.contextLoads()方法测试数据库连通性

     3.2 运行JdbcTest.testJdbck()方法测试对表user_table增删改查操作

    三、参考

    1.Spring Boot JDBC访问数据库

    2.一起来学SpringBoot | 第五篇：使用JdbcTemplate访问数据库 | 鏖战八方 

  • 相关阅读:
    25张炫酷交互图表，一文入门Plotly
    智能优化算法Matlab源码大礼包领取
    【C++】C/C++内存管理（new和delete详解）
    Python学习：循环语句教程
    golang 解决invalid argument tmp (type interface {}) for len
    【LeetCode热题100】--15.三数之和
    携创教育：2022下半年自考延期省市有哪些？公告是什么？
    从制造到“智造”，看科聪控制系统如何赋能汽车行业智能生产
    MySQL Oracle区别
    个人博客系统
  • 原文地址：https://blog.csdn.net/qq_21370419/article/details/126425599