前言

在 Spring Boot 中,对于数据访问层,无论是关系型数据库(SQL)还是非关系型数据库(No

SQL),其底层均采用 Spring Data 的方式进行处理。

Spring 框架对数据库的操作在 JDBC 上做了深层次的封装,通过 依赖注入 将 DataSource 注册到 JdbcTemplate 中,使得我们能够轻易的完成对象关系映射。而且 JDBC 有着如下的特点:

  1. 相较于其他 ORM 框架,JDBC 的速度无疑是最快的;
  2. 配置简单,几乎用不额外配置;
  3. 学习成本低;

整合 JDBC

依赖配置

创建一个 Spring Boot 项目,在 pom.xml 引入 Web 模块、 SQL 模块以及 Jdbc Template 的依赖;

  1. <!-- Web 模块依赖 -->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-web</artifactId>
  5. </dependency>
  6. <!-- SQL 模块依赖 -->
  7. <dependency>
  8. <groupId>mysql</groupId>
  9. <artifactId>mysql-connector-java</artifactId>
  10. <scope>runtime</scope>
  11. </dependency>
  12. <!-- Jdbc Template 模块依赖 -->
  13. <dependency>
  14. <groupId>org.springframework.boot</groupId>
  15. <artifactId>spring-boot-starter-jdbc</artifactId>
  16. </dependency>

数据库准备

  1. 数据库创建及输入插入

准备一张 user 表,有 idnameage 三个属性,其中 id 为主键且自增,然后插入三条数据;

  1. CREATE DATABASE springboot;
  2. USE springboot;
  3. CREATE TABLE `user` (
  4. `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  5. `name` varchar(50) DEFAULT NULL COMMENT '姓名',
  6. `age` int(11) DEFAULT NULL COMMENT '年龄',
  7. PRIMARY KEY (`id`)
  8. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
  9. INSERT INTO user values (1,"村雨遥",25);
  10. INSERT INTO user values (2,"张三",26);
  11. INSERT INTO user values (3,"李四",27);
  1. 数据源配置

application.properties 中加入如下配置用于连接数据库(Spring Boot 默认自动配置 DataSource,且优先采用 HikariCP 连接池 );

  1. # 数据库配置
  2. spring.datasource.url=jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC&userUnicode=true&characterEncoding=utf-8
  3. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  4. spring.datasource.username=root
  5. spring.datasource.password=123456
  6. # 连接池
  7. # spring.datasource.type = HikariCP

实体类

  1. package com.cunyu.pojo;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. import org.springframework.stereotype.Component;
  6. /**
  7. * @author : cunyu
  8. * @version : 1.0
  9. * @className : Author
  10. * @date : 2020/7/29 16:20
  11. * @description : User 实体类
  12. */
  13. @Component
  14. @Data
  15. @AllArgsConstructor
  16. @NoArgsConstructor
  17. public class User {
  18. private Long id;
  19. private String name;
  20. private Integer age;
  21. }

service 层

  1. package com.cunyu.service;
  2. import com.cunyu.pojo.User;
  3. import java.util.List;
  4. /**
  5. * @author : cunyu
  6. * @version : 1.0
  7. * @className : UserService
  8. * @date : 2020/7/29 21:12
  9. * @description : TODO
  10. */
  11. public interface UserService {
  12. /**
  13. * @param
  14. * @return
  15. * @description 获取所有数据列表
  16. * @date 2020/7/29 21:57
  17. * @author cunyu1943
  18. * @version 1.0
  19. */
  20. public List<User> getList();
  21. }
  1. package com.cunyu.service.Impl;
  2. import com.cunyu.pojo.User;
  3. import com.cunyu.service.UserService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.core.RowMapper;
  7. import org.springframework.stereotype.Service;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.util.List;
  11. /**
  12. * @author : cunyu
  13. * @version : 1.0
  14. * @className : UserServiceImpl
  15. * @date : 2020/7/29 21:13
  16. * @description : TODO
  17. */
  18. @Service
  19. public class UserServiceImpl implements UserService {
  20. private final JdbcTemplate jdbcTemplate;
  21. public UserServiceImpl(JdbcTemplate jdbcTemplate) {
  22. this.jdbcTemplate = jdbcTemplate;
  23. }
  24. @Override
  25. public List<User> getList() {
  26. String sql = "SELECT id, name, age FROM user";
  27. return (List<User>) jdbcTemplate.query(sql, new RowMapper<User>() {
  28. @Override
  29. public User mapRow(ResultSet resultSet, int i) throws SQLException {
  30. User user = new User();
  31. user.setId(resultSet.getLong("id"));
  32. user.setName(resultSet.getString("name"));
  33. user.setAge(resultSet.getInt("age"));
  34. return user;
  35. }
  36. });
  37. }
  38. }

controller 层

  1. package com.cunyu.controller;
  2. import com.cunyu.pojo.User;
  3. import com.cunyu.service.UserService;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  11. import org.springframework.web.servlet.ModelAndView;
  12. import java.util.List;
  13. /**
  14. * @author : cunyu
  15. * @version : 1.0
  16. * @className : UserController
  17. * @date : 2020/7/29 16:22
  18. * @description : UserController
  19. */
  20. @RequestMapping("/user")
  21. @RestController
  22. public class UserController {
  23. private static final Logger logger = LoggerFactory.getLogger(UserController.class);
  24. private final UserService userService;
  25. public UserController(UserService userService) {
  26. this.userService = userService;
  27. }
  28. @GetMapping("/list")
  29. public List<User> getUsers() {
  30. logger.info("从数据库读取数据");
  31. return userService.getList();
  32. }
  33. }

结果

启动 Spring Boot,然后访问 http://localhost:8080/user/list,如果出现下面的内容,则说明整合 JDBC 成功;

Spring Boot 整合 JDBC Template - 图1

Spring Boot 整合 JDBC Template - 图2

总结

以上就是 Spring Boot 整合 JDBC 的具体过程了,如果本文对你有所帮助,还请帮忙点个赞再走呀!