返回介绍
文江博客 开发文档 Spring Boot 从入门到实战 文章详情

4.1 访问 SQL 数据库

发布于 2025-04-21 20:58:44 字数 15546 浏览 0 评论 0 收藏

SQL 数据库主要指关系型数据库。本节主要讲解 Spring Boot 集成 MySQL 数据库的相关操作。Spring 框架为 MySQL 数据库提供了广泛的技术支持，从封装了 JDBC 操作的 JdbcTemplate，到支持 ORM 技术的 Hibernate 等。Spring Data 是 Spring 的一个子项目，它提供了 Repository 接口，可以通过函数名直接完成 SQL 语句的查询。

4.1.1 JdbcTemplate 模板类

Java 的 javax.sql.DataSource 接口提供了处理数据库连接的标准方法，通过配置一个连接池提供数据库连接，Spring Boot 可以完成一些自动配置。首选 HikariCP 连接池，也可使用 Tomcat 连接池，如果这两个连接池都不可用，则使用 DBCP2。当然，开发者也可以自定义连接池，如采用阿里巴巴的 Druid 等。

Spring Boot 提供了自动配置，因此开发者只需在配置文件中添加数据库的配置信息即可。Spring Boot 提供了多种类型的连接池，如 spring.datasource.hikari.*、spring.datasource.tomcat.*和 spring.datasource.dbcp2.*等。

注意：如果不指定 spring.datasource.url 属性，则 Spring Boot 会自动配置内嵌的数据库。

一个简单的 DataSoruce 配置如下：

spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.tomcat.max-wait=10000
spring.datasource.tomcat.max-active=50
spring.datasource.tomcat.test-on-borrow=true

原生的 JDBC 操作数据库需要自己创建连接，使用完之后还需要手动关闭。Spring 框架为了提高开发效率，对 JDBC 进行了封装，即提供了 JdbcTemplate 类。JdbcTemplate 是一个模板类，提供了操作数据库的基本方法，如插入、更新、删除及查询等操作，同时还封装了一些固定操作，如连接的创建与关闭。JdbcTemplate 类提供了回调接口的方式，用于实现一些可变操作，如 ConnectionCallback 可以返回一个连接，StatementCallback 可以返回一个 Statement，还可以在回调接口做一些映射关系的逻辑处理。

JdbcTemplate 模板类提供了以下几种类型的方法：

  • execute() 方法：可以执行任何 SQL 语句，一般多用于执行 DDL（做数据定义）类型的语句。
  • update() 方法：执行新增、修改、删除等语句。
  • query() 方法：执行与查询相关的语句。
  • call() 方法：执行与数据库存储过程和函数相关的语句。

下面通过一个简单的示例展示 JdbcTemplate 的操作。

（1）定义一张 user 表，结构如下：

CREATE TABLE `user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户 id',
  `user_name` varchar(128) NOT NULL COMMENT '用户昵称',
  `login_name` varchar(128) NOT NULL COMMENT '登录账户',
  `user_head_img` varchar(256) DEFAULT NULL COMMENT '用户头像',
  `last_login_time` int(11) DEFAULT NULL COMMENT '上次登录时间'
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

（2）使用 JdbcTemplate 需要依赖 spring-boot-starter-jdbc 和 mysql-connector-java 包。配置文件 application.yml 如下：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&character
Encoding=UTF8&characterSetResults=UTF8&serverTimezone=UTC
    username: root
    password: test1111
    driver-class-name: com.mysql.cj.jdbc.Driver

（3）定义实体类 User，代码如下：

//声明实体类 User
public class User {
    private Integer userId;                                     //用户 ID
    private String userName;                                    //用户名
    private String loginName;                                   //登录名
    private Integer lastLoginTime;                              //登录时间
    private String userHeadImg;                                 //用户头像
    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 == null ? null : userName.trim();
    }
    public String getLoginName() {
        return loginName;
    }
    public void setLoginName(String loginName) {
        this.loginName = loginName == null ? null : loginName.trim();
    }
    public Integer getLastLoginTime() {
        return lastLoginTime;
    }
    public void setLastLoginTime(Integer lastLoginTime) {
        this.lastLoginTime = lastLoginTime;
    }
    public String getUserHeadImg() {
        return userHeadImg;
    }
    public void setUserHeadImg(String userHeadImg) {
        this.userHeadImg = userHeadImg == null ? null : userHeadImg.
trim();
    }
}

（4）定义 Dao 层的类 UserDao，在其中使用 JdbcTemplate 操作 MySQL 数据库，代码如下：

//声明 UserDao
@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;  //JdbcTemplate 注入
    public String add(User user){
        //insert 语句
        String sql = "insert into user(user_name, login_name, last_
login_time, user_head_img) value (?, ?, ?, ?)";
        try {
          jdbcTemplate.update(sql,user.getUserName(),user.getLogin
Name(),user.getLastLoginTime(),user.getUserHeadImg());
            return "1";
        } catch (DataAccessException e) {
            e.printStackTrace();
            return "0";
        }
    }
    public User findOne(Integer userId){
        //查询语句
        String sql = "select * from user where user_id = " + userId;
        List<User> userList = jdbcTemplate.query(sql, new BeanProperty
RowMapper<>(User.class));
        return userList.get(0);
    }
    public String update(User user){
        //更新语句
        String sql = "update user set user_name = ?, login_name = ? where
user_id = ?";
        try {
            jdbcTemplate.update(sql, user.getUserName(), user.get
LoginName(), user.getUserId());
            return "1";
        } catch (DataAccessException e) {
            return "0";
        }
    }
    public String delete(Integer userId){
        //删除语句
        String sql = "delete from user where user_id = ?";
        try {
            jdbcTemplate.update(sql, userId);
            return "1";
        } catch (DataAccessException e) {
            return "0";
        }
    }
    public List<User> findAll(){
        //查询多条语句
        String sql = "select * from user";
        List<User> query = jdbcTemplate.query(sql, new BeanProperty
RowMapper<>(User.class));
        return query;
    }
}

（5）定义 Service 层的类 UserService，代码如下：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    //添加方法
    public String add(User user){
        return userDao.add(user);
    }
    //查询方法
   public User findOne(Integer userId){
        return userDao.findOne(userId);
    }
    //更新方法
    public String update(User user){
        return userDao.update(user);
    }
    //删除操作
    public String delete(Integer userId){
        return userDao.delete(userId);
    }
    //查询列表方法
    public List<User> findAll(){
        return userDao.findAll();
    }
}

（6）定义 Controller 层的类 HiController，代码如下：

@RestController
@RequestMapping("/hi")
public class HiController {
    @Autowired
    private UserService userService;
    //新增用户接口
    @PostMapping("/add")
    public String add(@RequestBody User user){
        return userService.add(user);
    }
    //查询用户接口
    @GetMapping("/findOne")
    public User findOne(Integer userId){
        return userService.findOne(userId);
    }
    //更新用户接口
    @PostMapping("/update")
    public String update(@RequestBody User user){
        return userService.update(user);
    }
    //删除用户接口
    @DeleteMapping("/delete")
    public String delete(Integer userId){
        return userService.delete(userId);
    }
    //查询多条用户信息接口
    @GetMapping("/findAll")
    public List<User> findAll(){
        return userService.findAll();
    }
}

启动服务后，可以使用 Postman 以 POST 方式访问 http://localhost:8080/hi/add 接口，在请求 Body 中增加如下信息：

{
  "userName":"张三",
  "loginName":"zhangsan",
  "lastLoginTime":"1599032640",
  "userHeadImg":"https://image.xxx.com/xxx.jpg"
}

访问 http://localhost:8080/hi/findAll 接口，即可查看刚才插入的用户信息。同样，访问 http://localhost:8080/hi/update 接口可以更新用户信息，访问 http://localhost:8080/ hi/delete?userId=130 接口可以删除用户信息。

4.1.2 Spring Data JPA 组件

当开发一个小型项目或者一些工具时可以使用 JdbcTemplate 模板类，如果开发的是一个大型项目，推荐使用实现了 ORM 持久化的框架，如 Hibernate 或 MyBatis。本节主要介绍集成了 Hibernate 的 Spring Data JPA 组件，它基于 ORM 框架，实现了 JPA 标准并简化了持久层操作，可以让开发人员用极其简单的方式完成对数据库的访问与操作。

Spring Data JPA 同样实现了基本的 CRUD 方法，如增、删、改、查等。如果有个性化的查询，则需要自定义 SQL 语句。Spring Data JPA 提供了以下几个核心接口：

  • Repository 接口；
  • CrudRepository 接口，继承自 Repository；
  • PagingAndSortingRepository 接口，继承自 CrudRepository；
  • JpaRepository 接口，继承自 PagingAndSortingRepository。

Spring Data JPA 提供了很多注解来声明 Entity 实体类，如表 4.1 所示。

表 4.1 Spring Data JPA 注解

066-1

下面给出一个 Spring Data JPA 示例，Spring Boot 工程依赖 spring-boot-starter-data-jpa 模块。

（1）修改 application.yml 配置文件，代码如下：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&character
Encoding=UTF8&characterSetResults=UTF8&serverTimezone=UTC
    username: root
    password: test1111
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
    ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

注意：spring.jpa.hibernate.ddl-auto 的 update 属性用于根据 model 类自动更新表结构。

（2）声明实体类 UserEntity，代码如下：

//定义 UserEntity 类
@Entity
@Table(name="user")                                             //表名
@Data
public class UserEntity {
    @Id                                                                         //声明主键
    //主键 ID 生成策略
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")                         //对应的列名 user_id
    private Integer userId;
    @Column(name="user_name")                       //对应的列名 user_name
    private String userName;
    @Column(name="login_name")                      //对应的列名 login_name
    private String loginName;
    @Column(name="last_login_time")                 //对应的列名 last_login_time
    private Integer lastLoginTime;
    @Column(name="user_head_img")                   //对应的列名 user_head_img
    private String userHeadImg;
}

（3）声明 Dao 层的类 UserRepository，该类继承自 JpaRepository，代码如下：

//继承 JpaRepository
@Repository
public interface UserRepository extends JpaRepository<UserEntity,
Integer> {
}

如果默认情况下无法满足查询需求，可以通过 @Query 注解来解决这个问题。例如下面的示例：

@Repository
public interface UserRepository extends JpaRepository<UserEntity,
Integer> {
    //自定义查询语句
    @Query(value = "select * from user where user_id = ?", nativeQuery
= true)
    UserEntity queryByUserId(Integer userId);
}

如果需要更新，则需要注解 @Modifying。

（4）声明 Controller 层的类，代码如下：

@RestController
@RequestMapping("/hi")
public class HiController {
    @Autowired
    private UserRepository userRepository;  //注入 UserRepository 对象
    @GetMapping("/jpa/findOne")
    public UserEntity jpaFindOne(Integer userId) {
        //根据 userId 查询
        Optional<UserEntity> optional = userRepository.findById(userId);
        if (optional.isPresent()) {
            return optional.get();
        } else {
            return null;
        }
    }
    @GetMapping("/jpa/findAll")
    public Page<UserEntity> jpaFindAll() {
        //分页查询
        Pageable pageable = PageRequest.of(1,2, Sort.by(Sort.Direction.
DESC,"userId"));
        userRepository.findAll();
        Page<UserEntity> page = userRepository.findAll(pageable);
        return page;
    }
    @PostMapping("/jpa/add")
    public UserEntity jpaAdd(@RequestBody UserEntity userEntity) {
        //新增用户
        UserEntity uEntity = userRepository.save(userEntity);
        return uEntity;
    }
    @PostMapping("/jpa/update")
    public UserEntity jpaUpdate(@RequestBody UserEntity userEntity) {
        //更新语句
        UserEntity uEntity = userRepository.saveAndFlush(userEntity);
        return uEntity;
    }
    @DeleteMapping("/jpa/delete")
    @Transactional
    public String jpaDelete(Integer userId){
        //根据 userId 删除信息
        userRepository.deleteById(userId);
        return "1";
    }
    @GetMapping("/jpa/query")
    public UserEntity jpaQuery(Integer userId) {
        //自定义查询语句
        UserEntity userEntity = userRepository.queryByUserId(userId);
        return userEntity;
    }
}

同样使用 Postman 进行测试，访问 http://localhost:8080/hi/jpa/findAll、http://localhost: 8080/hi/jpa/update、http://localhost:8080/hi/jpa/delete?userId=2 接口，完成查询、更新和删除等操作。

4.1.3 Spring Boot 集成 MyBatis

MyBatis 同样是一款优秀的持久层框架，支持使用简单的 XML 文件或注解来配置和映射原生信息，从而将接口和 Java 的 POJO 对象映射成数据库中的记录。

Spring Boot 也提供了 MyBatis 的集成模块，即 mybatis-spring-boot-starter。

（1）通过 MyBatis 提供的 mybatis-generator 插件工具，可以帮助开发人员自动生成 POJO 类、Mapper 文件和 DAO 类。具体的 generatorConfig.xml 配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration
1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="MySQL2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
            <property name="addRemarkComments" value="true" />
        </commentGenerator>
        <!--数据源-->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/
test_db?useUnicode=true&amp;characterEncoding=UTF8&amp;character
SetResults=UTF8&amp;serverTimezone=UTC"
                        userId="root"
                        password="test1111">
        </jdbcConnection>
        <javaTypeResolver >
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>
        <javaModelGenerator targetPackage="com.example.springboot.
model"
                            targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <sqlMapGenerator targetPackage="com.example.springboot.mapper"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.
example.springboot.mapper"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <table tableName="user">
        </table>
    </context>
</generatorConfiguration>

执行插件命令：

mvn org.mybatis.generator:mybatis-generator-maven-plugin:1.3.2:
generate

即可生成对应的 User 类、UserMapper.xml 及 UserMapper 类。

（2）生成 Dao 层的类 UserMapper，代码如下：

//定义 UserMapper 类
public interface UserMapper {
    long countByExample(UserExample example);
    int deleteByExample(UserExample example);
    int deleteByPrimaryKey(Integer userId);
    int insert(User record);
    int insertSelective(User record);
    List<User> selectByExample(UserExample example);
    User selectByPrimaryKey(Integer userId);
    int updateByExampleSelective(@Param("record") User record, @Param
("example") UserExample example);
    int updateByExample(@Param("record") User record, @Param("example")
UserExample example);
    int updateByPrimaryKeySelective(User record);
    int updateByPrimaryKey(User record);
}

（3）在启动类上添加 @MapperScan 注解，可以自动注入相关的 mapper 类。具体代码如下：

//扫描 mapper 类
@MapperScan("com.example.springboot.mapper")

（4）生成 Controller 层的类 HiController，通过 MyBatis 的方式获取，代码如下：

@RestController
@RequestMapping("/hi")
public class HiController {
    @Resource
    private UserMapper userMapper;
    @GetMapping("/mybatis/findOne")
    public User mybatisFindOne(Integer userId) {
        //查询操作
        User user = userMapper.selectByPrimaryKey(userId);
        return user;
    }
}

重新启动应用，在浏览器中访问 http://localhost:8080/hi/mybatis/findOne?userId=1，即可查询对应的信息。

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。
列表为空，暂无数据
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。