SpringBoot整合Swagger2实现自动生成API(含源码)

最新推荐文章于 2023-09-04 10:06:35 发布
最新推荐文章于 2023-09-04 10:06:35 发布
阅读量1k 收藏 3
点赞数
分类专栏： SpringBoot 文章标签： SpringBoot Swagger2 自动生成API
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kangswx/article/details/98874580
版权

  1. 相信无论是前端还是后端开发，都或多或少地被接口文档折磨过。前端经常抱怨后端给的接口文档与实际情况不一致。后端又觉得编写及维护接口文档会耗费不少精力，经常来不及更新。

  2. 你只需要按照Swagger的规范去定义接口及接口相关的信息。再通过Swagger衍生出来的一系列项目和工具，就可以做到生成各种格式的接口文档，生成多种语言的客户端和服务端的代码，以及在线接口调试页面等等。

  3. 开发新版本或者迭代版本的时候，只需要更新Swagger描述文件，就可以自动生成接口文档和客户端服务端代码，做到调用端代码、服务端代码以及接口文档的一致性。

  4. 通过在项目中引入Swagger，可以扫描相关的代码，生成该描述文件，进而生成与代码一致的接口文档和客户端代码。这种通过代码生成接口文档的形式，在后面需求持续迭代的项目中，显得尤为重要和高效。

  5. 下面介绍SpringBoot整合Swagger生成API文档的过程

  6. 新建一个SpringBoot工程springboot-swagger2

  7. 引入相关的Maven依赖

    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Swagger2依赖 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.6.1</version>
    </dependency>
    <!-- Swagger2依赖 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.6.1</version>
    </dependency>
    <!-- Mybatis依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.0</version>
    </dependency>
    <!-- druid依赖 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
    <!-- mysql依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

  8. 在数据库中建立测试的表，SQL脚本如下

    DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `birthday` datetime DEFAULT NULL,
  `comment` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4;

  9. 新建Mybatis配置文件 resources\mybatis\config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--配置命名规则-->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases>
</configuration>

  10. 修改配置文件application.properties为application.yml，并添加下面的配置项

    server:
  port: 8081

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

mybatis:
  config-location: classpath:mybatis/config.xml
  mapper-locations: classpath*:mybatis/mapper/**/*.xml

  11. 新建Swagger2的配置类

    package com.kangswx.springbootswagger2.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

@Configuration
public class Swagger2 {

    /**
     * 生成API对象
     * @return
     */
    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //controller包的路径,生成controller对应的API文档
                .apis(RequestHandlerSelectors .basePackage("com.kangswx.springbootswagger2.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 生成API描述信息
     * @return
     */
    public ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("Spring整合Swagger2的API")
                .description("简单优雅的rest风格，https://blog.csdn.net/kangswx")
                .termsOfServiceUrl("https://blog.csdn.net/kangswx")
                .version("1.0")
                .build();
    }
}

  12. 新建User的实体类

    import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {

    private Integer id;

    private String username;

    private String password;

    private Integer age;

    private Date birthday;

    private String comment;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username == null ? null : username.trim();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password == null ? null : password.trim();
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment == null ? null : comment.trim();
    }

}

  13. 新增UserMapper接口

    import com.kangswx.springbootswagger2.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Repository
@Mapper
public interface UserMapper {

    int deleteByPrimaryKey(Integer id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);

}

  14. 新增UserMapper配置文件(resources\mybatis\mapper\UserMapper.xml)

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.kangswx.springbootswagger2.mapper.UserMapper" >
  <resultMap id="BaseResultMap" type="com.kangswx.springbootswagger2.entity.User" >
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="username" property="username" jdbcType="VARCHAR" />
    <result column="password" property="password" jdbcType="VARCHAR" />
    <result column="age" property="age" jdbcType="INTEGER" />
    <result column="birthday" property="birthday" jdbcType="TIMESTAMP" />
    <result column="comment" property="comment" jdbcType="VARCHAR" />
  </resultMap>

  <sql id="Base_Column_List" >
    id, username, password, age, birthday, comment
  </sql>

  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_user
    where id = #{id,jdbcType=INTEGER}
  </select>

  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_user
    where id = #{id,jdbcType=INTEGER}
  </delete>

  <insert id="insert" parameterType="com.kangswx.springbootswagger2.entity.User" >
    insert into t_user (id, username, password, 
      age, birthday, comment
      )
    values (#{id,jdbcType=INTEGER}, #{username,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, 
      #{age,jdbcType=INTEGER}, #{birthday,jdbcType=TIMESTAMP}, #{comment,jdbcType=VARCHAR}
      )
  </insert>

  <insert id="insertSelective" parameterType="com.kangswx.springbootswagger2.entity.User" >
    insert into t_user
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        id,
      </if>
      <if test="username != null" >
        username,
      </if>
      <if test="password != null" >
        password,
      </if>
      <if test="age != null" >
        age,
      </if>
      <if test="birthday != null" >
        birthday,
      </if>
      <if test="comment != null" >
        comment,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        #{id,jdbcType=INTEGER},
      </if>
      <if test="username != null" >
        #{username,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="age != null" >
        #{age,jdbcType=INTEGER},
      </if>
      <if test="birthday != null" >
        #{birthday,jdbcType=TIMESTAMP},
      </if>
      <if test="comment != null" >
        #{comment,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>

  <update id="updateByPrimaryKeySelective" parameterType="com.kangswx.springbootswagger2.entity.User" >
    update t_user
    <set >
      <if test="username != null" >
        username = #{username,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="age != null" >
        age = #{age,jdbcType=INTEGER},
      </if>
      <if test="birthday != null" >
        birthday = #{birthday,jdbcType=TIMESTAMP},
      </if>
      <if test="comment != null" >
        comment = #{comment,jdbcType=VARCHAR},
      </if>
    </set>
    where id = #{id,jdbcType=INTEGER}
  </update>

  <update id="updateByPrimaryKey" parameterType="com.kangswx.springbootswagger2.entity.User" >
    update t_user
    set username = #{username,jdbcType=VARCHAR},
      password = #{password,jdbcType=VARCHAR},
      age = #{age,jdbcType=INTEGER},
      birthday = #{birthday,jdbcType=TIMESTAMP},
      comment = #{comment,jdbcType=VARCHAR}
    where id = #{id,jdbcType=INTEGER}
  </update>
</mapper>

  15. 新增UserService接口

    import com.kangswx.springbootswagger2.entity.User;

public interface UserService {

    User getByid(Integer id);

    int updateUser(User user);

    int deleteUserById(Integer id);

    int addUser(User user);
}

  16. 新增UserServiceImpl实现类

    import com.kangswx.springbootswagger2.entity.User;
import com.kangswx.springbootswagger2.mapper.UserMapper;
import com.kangswx.springbootswagger2.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User getByid(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    @Override
    public int updateUser(User user) {
        return userMapper.updateByPrimaryKeySelective(user);
    }

    @Override
    public int deleteUserById(Integer id) {
        return userMapper.deleteByPrimaryKey(id);
    }

    @Override
    public int addUser(User user) {
        return userMapper.insert(user);
    }

}

  17. 新增UserController，并为每个接口添加Swagger注解信息

    import com.kangswx.springbootswagger2.entity.JsonData;
import com.kangswx.springbootswagger2.entity.User;
import com.kangswx.springbootswagger2.service.UserService;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询接口
     * @param id
     * @return
     */
    //ApiOperation生成的接口的API描述信息
    @ApiOperation(value = "查询用户信息", notes = "根据url的id来查询用户详细信息")
    //ApiImplicitParam生成的接口参数的API描述信息
    @ApiImplicitParam(name="id", value = "用户的id", required = true, dataType = "int", paramType = "path")
    @GetMapping(value = "{id}")
    public Object getById(@PathVariable int id){
        User user = userService.getByid(id);
        return JsonData.buildSuccess(user);
    }

    /**
     * 修改接口
     * @param user
     * @return
     */
    //ApiOperation生成的接口的API描述信息
    @ApiOperation(value = "修改用户信息", notes = "根据传入对象的非空字段值和id修改用户信息")
    //ApiImplicitParam生成的接口参数的API描述信息
    @ApiImplicitParam(name = "user", value = "用户对象", required = true, dataType = "Json", paramType = "body")
    @PutMapping()
    public Object updateUserById(@RequestBody User user){
        int ret = userService.updateUser(user);
        JsonData jsonData = null;
        if(ret > 0){
            jsonData = JsonData.buildSuccess("修改成功");
        } else {
            jsonData = JsonData.buildError("修改失败");
        }
        return jsonData;
    }

    /**
     * 添加接口
     * @param user
     * @return
     */
    //ApiOperation生成的接口的API描述信息
    @ApiOperation(value = "新增用户", notes = "将传入的用户对象添加到数据库")
    //ApiImplicitParam生成的接口参数的API描述信息
    @ApiImplicitParam(name = "user", value = "用户对象", required = true, dataType = "Json", paramType = "body")
    @PostMapping()
    public Object addUser(@RequestBody User user){
        int ret = userService.addUser(user);
        JsonData jsonData = null;
        if(ret > 0){
            jsonData = JsonData.buildSuccess("添加成功");
        } else {
            jsonData = JsonData.buildError("添加失败");
        }
        return jsonData;
    }

    /**
     * 删除接口
     * @param id
     * @return
     */
    //ApiOperation生成的接口的API描述信息
    @ApiOperation(value = "删除用户", notes = "根据url的id来删除数据库中对应的用户")
    //ApiImplicitParam生成的接口参数的API描述信息
    @ApiImplicitParam(name="id", value = "用户的id", required = true, dataType = "int", paramType = "path")
    @DeleteMapping("{id}")
    public Object deleteUser(@PathVariable int id){
        int ret = userService.deleteUserById(id);
        JsonData jsonData = null;
        if(ret > 0){
            jsonData = JsonData.buildSuccess("删除成功");
        } else {
            jsonData = JsonData.buildError("删除失败");
        }
        return jsonData;
    }

}

  18. 在启动类上添加MapperScan和EnableSwagger2的注解

    import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@MapperScan(basePackages = "com.kangswx.springbootswagger2.mapper")
@SpringBootApplication
@EnableSwagger2     //启动Swagger2
public class SpringbootSwagger2Application {

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

}

  19. 启动SpringBoot项目，并访问 http://localhost:8081/swagger-ui.html

  20. 会看到Swagger生成的API文档

  21. 进行简单的测试，测试查询接口

    输入id的参数后，点击Try it out!就会看到查询的结果

  22. 测试添加

    点击Try it out!，返回结果为

  23. 测试删除

    返回结果为

  24. 至此，所有的功能测试正常， 上面的代码详见 SpringBoot整合Swagger2实现自动生成API

kangswx
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
使用Spring Boot自动发布和监视API
最佳 Java 编程
06-05 576
如果您正在沿着微服务风格的架构前进，那么您将需要接受的一个租户就是自动化。 这种架构风格介绍了许多活动部件。 如果成功，您的环境将具有大量服务API，企业可以将其用于应用程序开发和集成。 这意味着必须有一种方法可以发现可用的API文档。 需要在整个企业范围内有效地传达API信息，以显示使用API​​的位置，使用API​​的频率以及更改API的时间。 如果没有这种类型的监视，将阻碍甚至可能...
Spring boot集成Swagger2实现自动生成API文档
qq_36956015的博客
03-27 441
spring boot集成swagger2实现自动生成API文档，集成配置步骤（gradle管理jar包方式）如下： 添加swagger2的jar包 compile group: ‘io.springfox’, name: ‘springfox-swagger2’, version: ‘2.8.0’ compile group: ‘io.springfox’, name: ‘springfox...
源码级别Swagge2教学
09-15
该教学通过查看源码深入了解Swagger2的配置原理，能够真正理解Swagger2如何配置，为debug减少试探方向。 同时，该教程基于SpringBoot + web 项目，面向初学Swagger2的同学，使框架整合的理解更加透彻。
swagger-codegen-cli 生成springboot、java、springmvc代码
一人一屋淋雨声
05-12 3197
首先去github下载swagger相关项目，点击打开链接，下载之后我们将swagger-codegen-cli 打包命令如下：mvn clean package ，如果测试报错的话，我们加上跳过测试 -Dmaven.test.skip=true,之后你会发现打包成功，进入项目路径将swagger-codegen-cli的jar包拷出来，然后doc执行相关命令生产你想要的代码，但是再打包过程你下载...
API管理-定制yaml文件管理api并基于yaml文件生成client端、server端、springboot完整程序...
chuanaiqi5565的博客
07-02 792
1. api管理方式背景 随着项目团队不断地规范，开发流程的每一步都在不断的变化，变得更加高效并且方便管理；api管理也经历了不少的变化，主要变化从上到下演进： 编写后端接口api，从status的action到springmvc的@RequestMapping，这些框架的确可以帮我...
使用Swagger Codegen生成Python服务端客户端代码
RayPick的博客
07-10 1708
文件路径 swagger_client/configuration.py 可能需要将协议https改成http，否则会报SSL认证错误。我们自己创建一个python文件，我这里叫testray.py，需要放在跟setup.py这个文件同级目录下，也就是最外层，添加如下内容。我用的是virtualenv生成的虚拟环境运行的，其他虚拟化环境也一样，所以这里我只贴一下 virtualenv 的命令。原来的DefaultApi路径是错误的，无法import，所以需要改成我下图这样。生成的目录结构如下图所示。
SpringBoot集成Swagger2, 自动生成API接口文档
小白菜，追逐吧，坚持吧！
02-05 2388
Springboot作为当前流行的Java web开发脚手架，前后端分离已经逐渐成为互联网项目一种标准的开发方式，前端与后端交给不同的人员开发，越来越多的开发者在使用Springboot来构建企业级的RESTFul API接口。 这些接口不但会服务于传统的web端，也会服务于移动端。在实际开发过程中，这些接口还要提供给开发测试，项目开发中的沟通成本也随之升高，这部分沟通成本主要在于前端开发人...
springboot+swagger3+mybatis-plus3.5.1代码生成+druid+log4j2【最完美】的一次配置
12-21
在SpringBoot项目中集成Swagger3，我们可以使用`springfox-swagger2`和`springfox-swagger-ui`库，通过注解来定义API信息，然后Swagger UI界面会自动生成交互式的文档。 MyBatis-Plus是MyBatis的扩展，它提供了一些...
Springboot整合JWT,Swagger.zip
07-12
SpringBoot整合JWT与Swagger是现代Web开发中两个重要的技术组件，它们可以极大地提升应用程序的效率和易用性。JWT（Json Web Token）用于安全地在客户端和服务器之间传输信息，而Swagger则是用于构建RESTful API的...
SpringBoot+Mybatis+Swagger+mysql整合
12-06
在Spring Boot项目中，我们可以使用Springfox库来集成Swagger2，生成API的定义，并提供一个UI界面供测试。 4. **MySQL**: MySQL是一种流行的开源关系型数据库管理系统，广泛应用于Web应用。在本项目中，MySQL作为...
SpringBoot+Mybatis整合完整源码
04-02
【Spring Boot + Mybatis 整合详解】 Spring Boot 和 Mybatis 的整合是现代 Java 开发中的常见实践，它...在实际项目中，你可以根据需求进一步扩展，如集成 Swagger 进行 API 文档管理，或者引入 Redis 做缓存优化等。
SpringBoot+Mybatis+Redis+Netty4+Swagger2
06-10
标题 "SpringBoot+Mybatis+Redis+Netty4+Swagger2" 描述了一种常见的Java后端技术栈，用于构建高效、现代化的Web应用程序。这个组合涵盖了从快速开发框架到数据库访问、缓存管理、网络通信以及API文档化的各个方面。...
调试工具之Swagger 2和3 配置使用详解
最新发布
上善若泪
09-04 1521
Swagger目前是比较主流的RESTful风格的API文档工具，做过开发的人应该都用过它它提供了一套工具和规范，让开发人员能够更轻松地创建和维护可读性强、易于使用和交互的API文档（官方口吻）。desc: Swagger 官方网站。
swagger生成对应的客户端、服务端代码
Min_Monk的博客
03-14 3911
根据yaml文件生成对应的客户端、服务端代码 前言 ​ 对于早期的webservice接口，我们可以根据wsdl文件生成对应的客户端和服务端代码。那么同样的针对于Restful风格的接口，也有同样的根据可以生成对应的客户端和服务端代码。这里我主要讲解一种根据yaml描述文档生成客户端、服务端代码的方式是Swagger。 Swagger介绍 ​ 相信很多人对于Swagger并不...
SpringBoot项目中使用Swagger2及注解解释（详细）
热门推荐
m0_61820867的博客
08-14 1万+
描述springboot的swagger2的用法，配置到注解讲解，很详细
在线教育项目中swagger 使用笔记记录
weixin_46133437的博客
04-10 292
一、Swagger2介绍 前后端分离开发模式中，api文档是最好的沟通方式。 Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。 1及时性 (接口变更后，能够及时准确地通知相关前后端开发人员) 2规范性 (并且保证接口的规范性，如接口的地址，请求方式，参数及响应格式和错误信息) 3一致性 (接口信息一致，不会出现因开发人员拿到的文档版本不一...
Swagger-Condegen自动生成客户端服务端接口代码。
冉野 、
03-09 1万+
swagger2     swagger是一个统一前后端的好工具，可以用来规划客户端API的访问控制，可用来规划服务端的接口开发。通常情况下我们很羡慕那些基于WS/SOAP协议服务的人，他们可以很轻松的基于WSDL接口规范生成一个客户端的API,这样大大的简化了服务的调用。     如何使用swagger-codegen-cli来生成对应的客户端和服务端代码呢？接下来就是见证奇迹的时刻.1. 首先...
【Swagger2源码级教学】06统一认证
m0_55659498的博客
09-17 1784
​ 当我们需要用户带着token访问我的的接口时，Swagger2通过配置统一认证可以实现全局token认证。​ 我们继续关注Docket里面的方法，我们需要通过下面两个方法实现全局token认证，先看代码。​​。
SpringBoot整合Mybatis和PageHelper实现分页查询(含源码)
kangswx的博客
08-07 3492
PageHalper是Mybatis中的一个分页插件，支持众多的数据库，使用很简单 下面介绍SpringBoot整合Mybatis和PageHelper实现分页查询的功能 新建一个SpringBoot项目，项目的结构如下 添加下面的依赖 <dependencies> <dependency> <groupId>org.s...
springboot整合swagger2 3.0.0
08-18
要实现springboot整合swagger2 3.0.0版本，你需要按照以下步骤操作： 1. 创建一个maven项目并引入spring-boot-starter-web和springfox-boot-starter依赖。在pom.xml文件中添加以下代码： ```xml <groupId>org....
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值