前言技术swagger两种使用方法

一：swagger是什么？

1、是一款让你更好的书写api文档规范且完整的框架。

2、提供描述、生产、消费和k可视化RESTful Web Service。

3、是由庞大工具集合支撑的形式化规范。这个集合涵盖了从终端用户接口、底层代码库到商业API管理的方方面面。

1. 前后端分离的特点

前后端分离是的前端与后端之间的职责更加明确

后台：负责业务处理

前端：负责显示逻辑

在这种情况下，前端和后端可以分别交付给专业的开发人员去做，所以是必须要定义前后端直接的对接接口，否则各自为是则项目无法集成，这时就需要一个文档来定义统一的接口。

2. 在没有swagger之前

在没有swagger之间，我们可以使用word，excel等功能来书写接口定义文档，但又有一个弊端，即：在接口发送改变时需要及时的同步接口文档，否则实际的接口与接口文档不相符，则接口文件就失去了作用，甚至会起到反作用。

3. swagger的作用

根据在代码中使用自定义的注解来生成接口文档，这个在前后端分离的项目中很重要。这样做的好处是在开发接口时可以通过swagger将接口文档定义好，同时也方便以后的维护。

4. swagger的优点

号称时最流行的API框架

接口文档在线生成，避免同步的麻烦

可以支持在线对接口执行测试

支持多语言

5. 集成swagger

打开https://mvnrepository.com/ ，查找springbox，在pom.xml中导入如下图标出的依赖

导入依赖

<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>

编写sawgger的配置类

package com.zking.mini_program.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;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

//跟着spring一起启动
@Configuration
//打开swagger功能
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.zking.mini_program.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("SwaggerDemo API DOC")
                .description("SwaggerDemo API DOC")
                .version("1.0")
                .termsOfServiceUrl("https://www.hmf.com")
                .build();
    }

}

注意：该配置类需要根据自己的项目修改，如以下配置

paths 指定需要生成文档的url规则

title 文档标题

description 描述

开发一个controller用于测试

package com.zking.mini_program.controller;

import com.zking.mini_program.pojo.User;
import com.zking.mini_program.util.response.ResponseResult;
import io.swagger.annotations.*;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/hello")
@Api(tags = "测试Swagger")
@SuppressWarnings("all")
public class HelloController {

    @ApiOperation(value = "欢迎信息")
    @GetMapping("/hello")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", value = "名称", dataType = "string", paramType = "query", required = true),
            @ApiImplicitParam(name = "msg", value = "消息", dataType = "string", paramType = "query", required = true)
    })
    public ResponseResult<?> hello(String name, String msg) {
        return ResponseResult.success();
    }

    @PostMapping("/register")
    @ApiOperation("注册用户接口")
    @ApiResponses({
            @ApiResponse(code = 10001, message = "Exception 01"),
            @ApiResponse(code = 10002, message = "Exception 02"),
            @ApiResponse(code = 10003, message = "Exception 03")
    })
    public ResponseResult<?> register(@RequestBody User user) {
        return ResponseResult.success();
    }

    @PutMapping("/edit")
    @ApiOperation("修改用户信息")
    public ResponseResult<?> edit(User user) {
        return ResponseResult.success();
    }

    @DeleteMapping("/delete/{id}")
    @ApiOperation("删除用户")
    @ApiImplicitParam(name = "id", value = "用户ID", dataType = "string", paramType = "path", required = true)
    public ResponseResult<?> delete(@PathVariable("id") String id) {
        return ResponseResult.success();
    }

}

启动服务，验证集成效果

服务启动后，访问：http://localhost:8080/swagger-ui.html

6. swagger常用注解

注解	位置	作用	参数
@Api	类	标识这个类是swagger的资源	tags：说明该类的作用，参数是个数组，可以填多个。
value="该参数没什么意义，在UI界面上不显示，所以不用配置"
description = "用户基本信息操作"
@ApiOperation	方法	表示一个http请求的操作	value="方法的用途和作用"
notes="方法的注意事项和备注"
tags：说明该方法的作用，参数是个数组，可以填多个。
格式：tags={"作用1","作用 2"}
@ApiParam	方法，参数	对参数使用说明（如：说明或是否必填等）	value="用户名" 描述参数的意义
name="name" 参数的变量名
required=true 参数是否必选
@ApiModel	类	表示对类进行说明，用于参数用实体类接收，一般用在 DTO上	description="描述实体的作用"
@ApiModelProperty	方法，字段	表示对model属性的说明	value="用户名" 描述参数的意义
name="name" 参数的变量名
required=true 参数是否必选
@ApiIgnore	类，方法，参数	表示这个方法或者类被忽略	无
@ApiImplicitParams	方法	包含多@ApiImplicitParam
@ApiImplicitParam	方法	表示单独的请求参数	name="参数名称"
value="参数说明"
dataType="数据类型"
paramType="query" 表示参数放在哪里

header 请求参数的获取：@RequestHeader

query 请求参数的获取：@RequestParam

path（用于restful接口）请求参数的获取：@PathVariable

body（不常用）

form（不常用）

defaultValue="参数的默认值

" required="true" 表示参数是否必须传

更全面的信息可以参考官方说明文档：
swagger-annotations 1.3.10 API

API 名称

[GET] http:

测试接口

请求参数

Headers

java8介绍

简化线程等类似操作

//创建线程(原来)
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("r1 coming....");
}
};
new Thread(r1).start();



new Thread(()->{
System.out.println("r2 coming....");
}).start();

完成集合流数据处理

菜单数据库操作

List<Dish> menu = Arrays.asList(
new Dish("猪肉", false, 800),
new Dish("牛肉", false, 700),
new Dish("肌肉", false, 400),
new Dish("薯条", true, 530),
new Dish("米饭", true, 350),
new Dish("时令水果", true, 120),
new Dish("披萨", true, 550),
new Dish("对虾", false, 300),
new Dish("三文鱼", false, 450)
);



//取出所有素食(原来)
List<Dish> other = new ArrayList<Dish>();
for (Dish dish : menu) {
if (dish.isVegetarian()) {
other.add(dish);
}
}


List<Dish> other = menu.stream()
.filter(Dish::isVegetarian)
.collect(Collectors.toList());

函数式编程

不断变化的需求

使用提供的菜品集合,完成以下需求

1. 编写方法获得所有素食的菜品

2. 编写方法获得卡路里大于500的菜品

3. 编写方法获得是素食但是卡路里大于500的菜品

/**
* 编写方法获得所有素食的菜品
*/
public List<Dish> findVegetarian(List<Dish> menu){
List<Dish> other=new ArrayList<Dish>();
for (Dish dish : menu) {
if (dish.isVegetarian()){
other.add(dish);
}
}
return other;
}




/**
* 编写方法获得卡路里大于500的菜品
*/
public List<Dish> findCalories(List<Dish> menu){
List<Dish> other=new ArrayList<Dish>();
for (Dish dish : menu) {
if (dish.getCalories()>500){
other.add(dish);
}
}
return other;
}




/**
* 编写方法获得是素食但是卡路里大于500的菜品
*/
public List<Dish> findCaloriesAndVegetarian(List<Dish> menu){
List<Dish> other=new ArrayList<Dish>();
for (Dish dish : menu) {
if (dish.getCalories()>500&& dish.isVegetarian()){
other.add(dish);
}
}
return other;
}

行为参数化

将决定权交给调用者(由调用者来决定条件)

分析整个菜品过滤的条件(boolean),并新建函数式接口(DishPredicate)

/**
* 过滤的决定条件
*
* @param dish 用于判断的元素
* @return 过滤结果
*/
boolean test(Dish dish);



/**
* 面对接口产生的过滤方法
*/
public static List<Dish> findInterface(List<Dish> menu, DishPredicate
dishPredicate) {
List<Dish> other = new ArrayList<Dish>();
for (Dish dish : menu) {
if (dishPredicate.test(dish)) {
other.add(dish);
}
}
return other;
}

使用接口进行接口进行判断代码的传递(优化之前的方法)

//1.取出所有的蔬菜
List<Dish> vegetarians = DishFilter.findInterface(menu, new DishPredicate() {
@Override
public boolean test(Dish dish) {
return dish.isVegetarian();
}
});
System.out.println(vegetarians);




//2.编写方法获得卡路里大于500的菜品
List<Dish> calories = DishFilter.findInterface(menu, new DishPredicate() {
@Override
public boolean test(Dish dish) {
return dish.getCalories()>500;
}
});
System.out.println(calories);




//3.编写方法获得是素食但是卡路里大于500的菜品
List<Dish> caloriesAndVegetarian = DishFilter.findInterface(menu, new
DishPredicate() {
@Override
public boolean test(Dish dish) {
return dish.getCalories() > 500 && dish.isVegetarian();
}
});
System.out.println(caloriesAndVegetarian);

函数式接口与lambda表达式

函数式接口: 接口中只有一个非default方法,可以加@FunctionalInterface,并且可以使用lambda简化

lamblda: 匿名函数的一种方式,它没有名称,但它有参数列表,函数主体,返回类型,可能还有一个可以抛出的异常列表

//1.取出所有的蔬菜
List<Dish> vegetarians = DishFilter.findInterface(menu, Dish::isVegetarian);
System.out.println(vegetarians);

思考衍生

如何创建多用的Predicate接口

@FunctionalInterface
public interface Predicate<T>{
boolean test(T t);
}



/**
* 面对接口产生的过滤方法
*/
public static <T> List<T> findCondition(List<T> list, Predicate<T> predicate) {
List<T> other = new ArrayList<T>();
for (T t : list) {
if (predicate.test(t)) {
other.add(t);
}
}
return other;
}