SpringBoot开发Restful风格的接口实现CRUD功能

一、前言

我们都知道SpringBoot的出现使得在开发web项目的时候变得更加方便、快捷。之前写过一篇文章是如何快速搭建一个springboot项目：SpringBoot入门：使用IDEA和Eclipse构建第一个SpringBoot项目。本文则介绍下如何基于SpringBoot开发Restful风格的接口实现来CRUD功能。

二、概念

什么是SpringBoot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。
简单的来说就是，只需几个jar和一些简单的配置，就可以快速开发项目。引用下SpringBoot实战这本书里面的话：

这里没有配置，没有web.xml，没有构建说明，甚至没有应用服务器，但这就是整个应用程序了。SpringBoot会搞定执行应用程序所需的各种后勤工作，你只要搞定应用程序的代码就好。

假如我们想简单的开发一个对外的接口，那么只需要以下代码就可以了。

一个主程序启动springBoot----核心

@SpringBootApplication
public class Application {
     
  public static void main(String[] args) {
     
    SpringApplication.run(Application.class, args);
  }
}

控制层代码：

@RestController
public class HelloController {
     
    @RequestMapping("/hello")
    public String hello() {
       
        return "Hello World";
    }
 }

成功启动主程序之后，编写控制层，然后在浏览器输入 http://localhost:8080//hello
便可以查看信息。

什么是Restful风格接口

Restful(Representational State Transfer)风格的API是一种软件架构风格，设计风格而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
在Restful风格中，用户请求的url使用同一个url而用请求方式：get，post，delete，put…等方式对请求的处理方法进行区分，这样可以在前后台分离式的开发中使得前端开发人员不会对请求的资源地址产生混淆和大量的检查方法名的麻烦，形成一个统一的接口。
Restful风格接口的规定如下

GET（SELECT）：从服务器查询，可以在服务器通过请求的参数区分查询的方式。POST（CREATE）：在服务器新建一个资源，调用insert操作。
PUT（UPDATE）：在服务器更新资源，调用update操作。
PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源，调用delete语句。

三、实战—基于SpringBoot开发一个Restful接口

1、开发前的准备工作

1.1 添加相关依赖

这里我的相关pom文件的配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.springboot</groupId>
    <artifactId>springbootdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootdemo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring Boot Mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.0</version>
        </dependency>
        <!-- MySQL 连接驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.39</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!--运用SpringBoot 插件  使用spring-boot-devtools模块的应用,当classpath中的文件有改变时，会自动重启！-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.2 创建相关数据库和表

首先，需要在MySql中创建一个数据库和一张数据库的名称为jdbc，表名称为 user，建表语句脚本如下:

CREATE TABLE `user` (
 `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
 `email` varchar(255) NOT NULL COMMENT '邮箱',
 `password` varchar(255) NOT NULL COMMENT '密码',
 `username` varchar(255) NOT NULL COMMENT '姓名',
 PRIMARY KEY (`id`),
 UNIQUE KEY `email` (`email`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEF

表中插入数据：

INSERT INTO `user` VALUES ('1', '[email protected]', '123456', '张三');
INSERT INTO `user` VALUES ('2', '[email protected]', '234567', '李四');
INSERT INTO `user` VALUES ('3', '[email protected]', '345678', '王五');

1.3 数据库配置文件

接着需要使用application.properties进行一些自定义的配置，例如数据源的连接配置等等。我这里的配置文件如下：

## 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

## Mybatis 配置
# 配置为 com.pancm.bean 指向实体类包路径。
mybatis.typeAliasesPackage=com.springboot.bean
# 配置为 classpath 路径下 mapper 包下，* 代表会扫描所有 xml 文件。
mybatis.mapperLocations=classpath\:mapper/*.xml

2、实战开发—代码逻辑

成功创建好数据库、数据表以及下载好相应jar包、配置文件等这些准备工作之后。接下来正式进行SpringBoot项目的开发。

2.1 实体类

前面在数据库中创建了一张user表，这里先创建一个bean包然后该包下创建一个对应该表的User实体类，里面的字段对应user表的字段，代码如下：

package com.springboot.springbootdemo.bean;

public class User {
     

    private long id;
    private String email;
    private String password;
    private String username;


    public long getId() {
     
        return id;
    }

    public void setId(int id) {
     
        this.id = id;
    }

    public String getEmail() {
     
        return email;
    }

    public void setEmail(String email) {
     
        this.email = email;
    }

    public String getPassword() {
     
        return password;
    }

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

    public String getUsername() {
     
        return username;
    }

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

}

2.2 Dao层代码逻辑

在dao层的逻辑，hibernate和mybatis一般都有两种方式实现数据库的CRUD:

第一种是xml的mapper配置。

第二种是使用注解，@Insert、@Select、@Update、@Delete 这些来完成。

在这里我使用spring的JPA来完成基本的增删改查，也是基于注解的使用。关于springboot如何整合jpa可以参考这篇文章，以前有详细介绍过：SpringBoot整合JPA进行数据访问

首先新建一个dao包并在dao包下新建一个接口，命名为UserDao，代码如下：

package com.springboot.springbootdemo.dao;

import com.springboot.springbootdemo.bean.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**在接口上添加了这个注解表示这个接口是基于注解实现的CRUD**/
@Mapper
public interface UserDao {
     
    /**
     * 新增数据
     */
    @Insert("insert into user(id,email,password,username) values (#{id},#{email},#{password},#{username})")
    void addUser(User user);
    /**
     * 修改数据
     */
    @Update("update user set username=#{username},password=#{password} where id=#{id}")
    void updateUser(User user);
    /**
     * 删除数据
     */
    @Delete("delete from user where id=#{id}")
    void deleteUser(int id);
    /**
     * 根据id查询数据
     *
     */
    @Select("select id,email,password,username from user where username=#{userName}")
    User findByName(@Param("userName") String userName);
    /**
     * 查询所有数据
     */
    @Select("select id,email,password,username FROM user")
    List<User> findAll();
}

说明:

mapper : 在接口上添加了这个注解表示这个接口是基于注解实现的CRUD。

Results: 返回的map结果集，property 表示User类的字段，column 表示对应的数据库的字段。

Param:sql条件的字段。

Insert、Select、Update、Delete:对应数据库的增、查、改、删。

2.3 Service 层逻辑层

接着新建一个service包，然后在service包下新建一个userservice接口和UserServiceImpl类实现userservice接口，代码分别如下：代码如下：

UserService接口：

package com.springboot.springbootdemo.service;

import com.springboot.springbootdemo.bean.User;

import java.util.List;

public interface UserService {
     
    /**
     * 新增用户
     * @param user
     * @return
     */
    boolean addUser(User user);

    /**
     * 修改用户
     * @param user
     * @return
     */
    boolean updateUser(User user);


    /**
     * 删除用户
     * @param id
     * @return
     */
    boolean deleteUser(int id);

    /**
     * 根据名字查询用户信息
     * @param userName
     */
    User findUserByName(String userName);
    

    /**
     * 查询所有数据
     * @return
     */
    List<User> findAll();
}

UserServiceImpl实现类：

package com.springboot.springbootdemo.service;

import com.springboot.springbootdemo.bean.User;
import com.springboot.springbootdemo.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;

public class UserServiceImpl implements UserService {
     
    @Autowired
    private UserDao userDao;
    
    @Override
    public boolean addUser(User user) {
     
        boolean flag=false;
        try{
     
            userDao.addUser(user);
            flag=true;
        }catch(Exception e){
     
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public boolean updateUser(User user) {
     
        boolean flag=false;
        try{
     
            userDao.updateUser(user);
            flag=true;
        }catch(Exception e){
     
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public boolean deleteUser(int id) {
     
        boolean flag=false;
        try{
     
            userDao.deleteUser(id);
            flag=true;
        }catch(Exception e){
     
            e.printStackTrace();
        }
        return flag;
    }

    @Override
    public User findUserByName(String userName) {
     
        return userDao.findByName(userName);
    }

    @Override
    public List<User> findAll() {
     
        return userDao.findAll();
    }
}

2.4 Controller 控制层代码逻辑

新建一个controller包，然后新建一个usercontroller类，具体代码如下：

package com.springboot.springbootdemo.controller;
import com.springboot.springbootdemo.bean.User;
import com.springboot.springbootdemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping(value = "/do/user")
public class UserController {
     
    @Autowired
private UserService userService;

    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public boolean addUser(@RequestBody User user) {
     
        return userService.addUser(user);
    }

    @RequestMapping(value = "/user", method = RequestMethod.PUT)
    public boolean updateUser(@RequestBody User user) {
     
        return userService.updateUser(user);
    }

    @RequestMapping(value = "/user", method = RequestMethod.DELETE)
    public boolean delete(@RequestParam(value = "userId", required = true) int userId) {
     
        return userService.deleteUser(userId);
    }


    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public User findByUserName(@RequestParam(value = "userName", required = true) String userName) {
     
        return userService.findUserByName(userName);
    }


    @RequestMapping(value = "/userAll", method = RequestMethod.GET)
    public List<User> findByUserAge() {
     
        return userService.findAll();
    }
}

说明:

RestController：默认类中的方法都会以json的格式返回。

RequestMapping: 接口路径配置。

method : 请求格式。

RequestParam: 请求参数。

RequestBody：该注解用于定义请求正文内容类型，将参数自动解析成该类的一个实例。

2.5 Application 主程序

在创建springboot项目的时候下面的代码就默认生成：

package com.springboot.springbootdemo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.springboot.springbootdemo.dao")
public class SpringbootdemoApplication {
     
    public static void main(String[] args) {
     
        SpringApplication.run(SpringbootdemoApplication.class, args);
    }
}

说明：
SpringApplication从main方法启动Spring应用的类。
默认，它会执行以下步骤：
1.创建一个合适的ApplicationContext实例 （取决于classpath）。
2.注册一个CommandLinePropertySource，以便将命令行参数作为Spring properties。
3.刷新application context，加载所有单例beans。
4.激活所有CommandLineRunner beans。直接使用main启动该类，SpringBoot便自动化配置了。该类的一些注解说明。:

SpringBootApplication：开启组件扫描和自动配置。
MapperScan: mapper 接口类扫描包配置

三、测试

开发完上述代码之后，进行下代码测试，看是否实现了效果。先启动启动Application类，然后这里使用postman工具进行接口的测试，就不写前端代码了，在实际的开发过程中，现在很多的项目都是实现了前后端分离，所以一般前后端分开开发，通常后台的逻辑就需要自己进行接口测试，一般我们则使用postman。关于postman的教程可以参考：Postman接口测试图文教程。
首先启动postman，然后新建一个一个url地址，将测试地址输入进去，先来验证查询所有的数据逻辑：

http://localhost:8080/do/user/userAll

接下来测试删除数据：

http://localhost:8080/do/user/user?id=3

id为3的数据已经被删除了：

测试根据姓名查询数据：

http://localhost:8080/do/user/user?userName=张三

测试更新数据：

http://localhost:8080/do/user/user

数据库中id为2的数据已被更新：
测试新增数据：

http://localhost:8080/do/user/user

数据库中新增了id为3的数据：

四、尾声

以上就是springboot如何开发一个具有Restful风格的接口的全部内容，并且本文的源码已经同步至github，如果有需要可以下载。最后如果觉得本文写得不错，就点下赞和再看推荐给更多的人呗。
文原创首发于微信公众号【1024笔记】，原文传送门！有兴趣的可以微信搜索关注，后台回复关键字即可免费获取海量的编程相关的学习资源（电子书、视频、源码、完整项目、面试宝典），涵盖java、python、c、前端、人工智能、大数据、数据分析等等，有任何问题都可以后台留言交流讨论，希望能对你有帮助。