使用 JSONDoc 記錄 Spring Boot RESTful API

原創 molashaonian 2020-02-26 05:47

這個博文可以分爲兩部分：第一部分我將編寫一個Spring Boot RESTful API，第二部分將介紹如何使用JSONDoc來記錄創建的API。做這兩個部分最多需要15分鐘，因爲使用Spring Boot創建一個API非常簡單快捷，並且使用JSONDoc Spring Boot啓動器和UI webjar進行記錄也是如此。我將跳過這個例子的測試創建，因爲主要目標是如何記錄API而不是編寫和測試它。

編寫API

我們首先根據快速入門的原型創建Maven項目



並聲明API所需的依賴關係：

  • spring-boot-starter-web
  • spring-boot-starter-data-jpa
  • h2
我還添加了 Lombok 保持我的代碼更乾淨。所得的pom看起來像這樣：
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.example</groupId>
	<artifactId>jsondoc-shelf</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>jsondoc-shelf</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
	
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<version>1.2.0.RELEASE</version>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
			<version>1.2.0.RELEASE</version>
		</dependency>
		
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<version>1.3.176</version>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.14.8</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
			<scope>test</scope>
		</dependency>
		
	</dependencies>
</project>
這個應用程序將是一個管理簡單貨架的服務的集合。將有兩個實體：
  • Book
  • Author

創建 Entities 和 Controllers

爲此，我將創建通常的組件來管理持久層和控制器層：

  • 一個包名爲model將包含Book和Author
  • 一個包名爲repository將包含BookRepository和AuthorRepository
  • 一個包名爲controller將包含BookController和AuthorController

對於這個例子，我將跳過 Service 層。我還將創建一個DatabasePopulator類，實現CommandLineRunner，以便在啓動時將在內存數據庫中存在一些數據。我們來看看實體，存儲庫和控制器的代碼：

Entities
package org.example.shelf.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import lombok.Data;
import lombok.EqualsAndHashCode;

@Entity
@Data
@EqualsAndHashCode(exclude = "id")
public class Book {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	@Column(name = "title")
	private String title;

	@ManyToOne
	@JoinColumn(name = "author_id")
	private Author author;

}
package org.example.shelf.model;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.ToString;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
@Data
@NoArgsConstructor
@ToString(exclude = "books")
@EqualsAndHashCode(of = "name")
public class Author {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	@Column(name = "name")
	private String name;

	@JsonIgnore
	@OneToMany(mappedBy = "author", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	private List<Book> books = new ArrayList<Book>();
	
}
Repositories
package org.example.shelf.repository;

import org.example.shelf.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;

public interface BookRepository extends JpaRepository<Book, Long> {

}
package org.example.shelf.repository;

import org.example.shelf.model.Author;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

public interface AuthorRepository extends JpaRepository<Author, Long> {

}
Controllers
package org.example.shelf.controller;

import java.util.List;

import org.example.shelf.flow.ShelfFlowConstants;
import org.example.shelf.model.Book;
import org.example.shelf.repository.BookRepository;
import org.jsondoc.core.annotation.Api;
import org.jsondoc.core.annotation.ApiBodyObject;
import org.jsondoc.core.annotation.ApiMethod;
import org.jsondoc.core.annotation.ApiPathParam;
import org.jsondoc.core.annotation.ApiResponseObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
@RequestMapping(value = "/books", produces = MediaType.APPLICATION_JSON_VALUE)
public class BookController {
	
	@Autowired
	private BookRepository bookRepository;
	
	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	public Book findOne(@PathVariable Long id) {
		return bookRepository.findOne(id);
	}
	
	@RequestMapping(method = RequestMethod.GET)
	public List<Book> findAll() {
		return bookRepository.findAll();
	}
	
	@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	@ResponseStatus(value = HttpStatus.CREATED)
	public ResponseEntity<Void> save(@RequestBody Book book, UriComponentsBuilder uriComponentsBuilder) {
		bookRepository.save(book);
		
		HttpHeaders headers = new HttpHeaders();
		headers.setLocation(uriComponentsBuilder.path("/books/{id}").buildAndExpand(book.getId()).toUri());
		return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}
	
	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public void delete(@PathVariable Long id) {
		Book book = bookRepository.findOne(id);
		bookRepository.delete(book);
	}

}
package org.example.shelf.controller;

import java.util.List;

import org.example.shelf.flow.ShelfFlowConstants;
import org.example.shelf.model.Author;
import org.example.shelf.repository.AuthorRepository;
import org.jsondoc.core.annotation.Api;
import org.jsondoc.core.annotation.ApiBodyObject;
import org.jsondoc.core.annotation.ApiMethod;
import org.jsondoc.core.annotation.ApiPathParam;
import org.jsondoc.core.annotation.ApiResponseObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
@RequestMapping(value = "/authors", produces = MediaType.APPLICATION_JSON_VALUE)
public class AuthorController {

	@Autowired
	private AuthorRepository authorRepository;

	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	public Author findOne(@PathVariable Long id) {
		return authorRepository.findOne(id);
	}

	@RequestMapping(method = RequestMethod.GET)
	public List<Author> findAll() {
		return authorRepository.findAll();
	}

	@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	@ResponseStatus(value = HttpStatus.CREATED)
	public ResponseEntity<Void> save(@RequestBody Author author, UriComponentsBuilder uriComponentsBuilder) {
		authorRepository.save(author);
		
		HttpHeaders headers = new HttpHeaders();
		headers.setLocation(uriComponentsBuilder.path("/authors/{id}").buildAndExpand(author.getId()).toUri());
		return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}

	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public void delete(@PathVariable Long id) {
		Author author = authorRepository.findOne(id);
		authorRepository.delete(author);
	}

}
Database populator
package org.example.shelf;

import org.example.shelf.model.Author;
import org.example.shelf.model.Book;
import org.example.shelf.repository.AuthorRepository;
import org.example.shelf.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DatabasePopulator implements CommandLineRunner {
	
	@Autowired
	private AuthorRepository authorRepository;
	
	@Autowired
	private BookRepository bookRepository;
	
	public void run(String... arg0) throws Exception {
		Author horbny = new Author();
		horbny.setId(1L);
		horbny.setName("Nick Horby");
		
		Author smith = new Author();
		smith.setId(2L);
		smith.setName("Wilbur Smith");
		
		authorRepository.save(horbny);
		authorRepository.save(smith);
		
		Book highFidelty = new Book();
		highFidelty.setId(1L);
		highFidelty.setTitle("High fidelty");
		highFidelty.setAuthor(horbny);
		
		Book aLongWayDown = new Book();
		aLongWayDown.setId(2L);
		aLongWayDown.setTitle("A long way down");
		aLongWayDown.setAuthor(horbny);

		Book desertGod = new Book();
		desertGod.setId(3L);
		desertGod.setTitle("Desert god");
		desertGod.setAuthor(smith);
		
		bookRepository.save(highFidelty);
		bookRepository.save(aLongWayDown);
		bookRepository.save(desertGod);
	}

}
現在是編寫主類來運行應用程序的時候了。Shelf在這種情況下，我會稱之爲Spring Boot，這很簡單：

package org.example.shelf;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@EnableAutoConfiguration
@EnableJpaRepositories
@ComponentScan
public class Shelf {
	
	public static void main(String[] args) {
		SpringApplication.run(Shelf.class, args);
	}

}
通過運行這個類，我們可以實際驗證應用程序是否響應請求。您可以通過使用 curl 輕鬆測試 API 的工作：

curl -i http://localhost:8080/books/1
curl -i http://localhost:8080/books

curl -i http://localhost:8080/authors/1
curl -i http://localhost:8080/authors

用JSONDoc記錄API

這是有趣的和新的部分，即使用JSONDoc庫來註釋代碼並自動生成其文檔。要做到這一點，你必須聲明JSONDoc依賴關係，並在你的類中插入一些代碼。讓我們看看如何做到這一點：

聲明JSONDoc依賴關係

只需添加兩個依賴關係到pom文件：

<dependency>
	<groupId>org.jsondoc</groupId>
	<artifactId>spring-boot-starter-jsondoc</artifactId>
	<version>1.1.3</version>
</dependency>

<dependency>
	<groupId>org.jsondoc</groupId>
	<artifactId>jsondoc-ui-webjar</artifactId>
	<version>1.1.3</version>
</dependency>

在主類中啓用JSONDoc

使用JSONDoc啓動器，您可以通過添加@EnableJSONDoc到Shelf類中來啓用文檔生成，如下所示：

package org.example.shelf;

import org.jsondoc.spring.boot.starter.EnableJSONDoc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@EnableAutoConfiguration
@EnableJpaRepositories
@EnableJSONDoc
@ComponentScan
public class Shelf {
	
	public static void main(String[] args) {
		SpringApplication.run(Shelf.class, args);
	}

}

配置JSONDoc

接下來要做的是配置JSONDoc來掃描您的控制器，對象和流類。要做到這一點，只需添加一些條目到application.properties文件（src/main/resources如果你沒有它創建它）

jsondoc.version=1.0
jsondoc.basePath=http://localhost:8080
jsondoc.packages[0]=org.example.shelf.model
jsondoc.packages[1]=org.example.shelf.controller

文檔控制器

JSONDoc可以從Spring註釋中獲取幾個信息來構建文檔。無論如何，它是一個選擇加入的過程，這意味着JSONDoc將僅在使用自己的註釋註釋時才掃描類和方法。例如，要正確記錄BookController，這裏是如何使用JSONDoc註釋：

package org.example.shelf.controller;

import java.util.List;

import org.example.shelf.flow.ShelfFlowConstants;
import org.example.shelf.model.Book;
import org.example.shelf.repository.BookRepository;
import org.jsondoc.core.annotation.Api;
import org.jsondoc.core.annotation.ApiBodyObject;
import org.jsondoc.core.annotation.ApiMethod;
import org.jsondoc.core.annotation.ApiPathParam;
import org.jsondoc.core.annotation.ApiResponseObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
@RequestMapping(value = "/books", produces = MediaType.APPLICATION_JSON_VALUE)
@Api(description = "The books controller", name = "Books services")
public class BookController {
	
	@Autowired
	private BookRepository bookRepository;
	
	@ApiMethod
	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	public @ApiResponseObject Book findOne(@ApiPathParam(name = "id") @PathVariable Long id) {
		return bookRepository.findOne(id);
	}
	
	@ApiMethod
	@RequestMapping(method = RequestMethod.GET)
	public @ApiResponseObject List<Book> findAll() {
		return bookRepository.findAll();
	}
	
	@ApiMethod
	@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	@ResponseStatus(value = HttpStatus.CREATED)
	public @ApiResponseObject ResponseEntity<Void> save(@ApiBodyObject @RequestBody Book book, UriComponentsBuilder uriComponentsBuilder) {
		bookRepository.save(book);
		
		HttpHeaders headers = new HttpHeaders();
	    headers.setLocation(uriComponentsBuilder.path("/books/{id}").buildAndExpand(book.getId()).toUri());
		return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}
	
	@ApiMethod
	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public void delete(@ApiPathParam(name = "id") @PathVariable Long id) {
		Book book = bookRepository.findOne(id);
		bookRepository.delete(book);
	}

}
同樣的AuthorController。

文件對象

接下來要做的就是把一些JSONDoc註釋也需要被記錄在案，在這種情況下，對象Book和Author。這是Book類：

package org.example.shelf.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import org.jsondoc.core.annotation.ApiObject;
import org.jsondoc.core.annotation.ApiObjectField;

import lombok.Data;
import lombok.EqualsAndHashCode;

@Entity
@Data
@EqualsAndHashCode(exclude = "id")
@ApiObject
public class Book {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	@ApiObjectField(description = "The book's ID")
	private Long id;

	@Column(name = "title")
	@ApiObjectField(description = "The book's title")
	private String title;

	@ManyToOne
	@JoinColumn(name = "author_id")
	@ApiObjectField(description = "The book's author")
	private Author author;

}
而且在這種情況下Author也是如此。

檢查點：啓動應用程序

在開始記錄流程之前，讓我們啓動應用程序，看看會發生什麼：

  • 如果你去http://localhost:8080/jsondoc你會看到一個json，這是由JSONDoc生成的，它代表了基於控制器方法和模型對象上的註釋的文檔
  • 如果你去http://localhost:8080/jsondoc-ui.html你會看到JSONDoc UI。只需複製並粘貼http://localhost:8080/jsondoc到輸入字段中，並在清晰的用戶界面中獲取文檔

這是一個很好的時機，需要一些時間來探索界面，並在界面上玩API。

文件流

按照流程我的意思是一些API方法的後續執行，旨在實現一個目標，即可以購買一本書，或瀏覽目錄並獲取圖書詳細信息。在這種情況下，流程可能涉及幾種方法，API用戶可能需要知道哪個是正確的調用方法序列來實現目標。在這個例子中，我不能想到有意義的流程，但是讓我們假設我想要記錄瀏覽框架的方法順序，並通過我選擇的一本書獲取作者的細節，所以這個用例的結果流是就像是：

  • 獲取書籍清單
  • 選擇一本書並獲得其細節
  • 得到這本書的作者

要記錄此流程，您只需按照以下步驟操作：

  1. 創建一個包含應用程序流的類。此類僅用於文檔目的，不會在您的應用程序中實際使用。使用註釋來註釋這個類@ApiFlowSet，這使得JSONDoc瞭解在構建文檔時應該考慮到這個類。
  2. 在這個類中創建假的方法，註釋爲@ApiFlow。方法的正文以及它的返回類型和參數可以是void，因爲方法簽名服務器只是作爲@ApiFlow註釋的鉤子
  3. 決定標識JSONDoc產生文檔內的每一個API方法中，例如一個ID的findAll方法的BookController可有一個像IDBOOK_FIND_ALL
  4. 將這個ID內部ID的@ApiMethod註釋和內部 api methodid 的@ApiFlowStep註解
  5. 如果將流類放在一個單獨的包中，請記住application.properties使用該值更新該文件

我們來看看我是怎麼做到的 這是持有應用程序流程的類：

package org.example.shelf.flow;

import org.jsondoc.core.annotation.ApiFlow;
import org.jsondoc.core.annotation.ApiFlowSet;
import org.jsondoc.core.annotation.ApiFlowStep;

@ApiFlowSet
public class ShelfFlows {

	@ApiFlow(
		name = "Author detail flow",
		description = "Gets an author's details starting from the book's list",
		steps = {
			@ApiFlowStep(apimethodid = ShelfFlowConstants.BOOK_FIND_ALL),	
			@ApiFlowStep(apimethodid = ShelfFlowConstants.BOOK_FIND_ONE),	
			@ApiFlowStep(apimethodid = ShelfFlowConstants.AUTHOR_FIND_ONE)	
		}
	)
	public void authorDetailFlow() {

	}

}
這是包含註釋中要引用的方法ID的類：

package org.example.shelf.flow;

public class ShelfFlowConstants {
	
	// Book IDs
	public final static String BOOK_FIND_ALL = "BOOK_FIND_ALL";
	public final static String BOOK_FIND_ONE = "BOOK_FIND_ONE";
	public final static String BOOK_SAVE = "BOOK_SAVE";
	public final static String BOOK_DELETE = "BOOK_DELETE";

	// Author IDs
	public final static String AUTHOR_FIND_ALL = "AUTHOR_FIND_ALL";
	public final static String AUTHOR_FIND_ONE = "AUTHOR_FIND_ONE";
	public final static String AUTHOR_SAVE = "AUTHOR_SAVE";
	public final static String AUTHOR_DELETE = "AUTHOR_DELETE";

}
這是BookController，指定了id屬性後：

package org.example.shelf.controller;

import java.util.List;

import org.example.shelf.flow.ShelfFlowConstants;
import org.example.shelf.model.Book;
import org.example.shelf.repository.BookRepository;
import org.jsondoc.core.annotation.Api;
import org.jsondoc.core.annotation.ApiBodyObject;
import org.jsondoc.core.annotation.ApiMethod;
import org.jsondoc.core.annotation.ApiPathParam;
import org.jsondoc.core.annotation.ApiResponseObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

@RestController
@RequestMapping(value = "/books", produces = MediaType.APPLICATION_JSON_VALUE)
@Api(description = "The books controller", name = "Books services")
public class BookController {
	
	@Autowired
	private BookRepository bookRepository;
	
	@ApiMethod(id = ShelfFlowConstants.BOOK_FIND_ONE)
	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	public @ApiResponseObject Book findOne(@ApiPathParam(name = "id") @PathVariable Long id) {
		return bookRepository.findOne(id);
	}
	
	@ApiMethod(id = ShelfFlowConstants.BOOK_FIND_ALL)
	@RequestMapping(method = RequestMethod.GET)
	public @ApiResponseObject List<Book> findAll() {
		return bookRepository.findAll();
	}
	
	@ApiMethod(id = ShelfFlowConstants.BOOK_SAVE)
	@RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)
	@ResponseStatus(value = HttpStatus.CREATED)
	public @ApiResponseObject ResponseEntity<Void> save(@ApiBodyObject @RequestBody Book book, UriComponentsBuilder uriComponentsBuilder) {
		bookRepository.save(book);
		
		HttpHeaders headers = new HttpHeaders();
	    headers.setLocation(uriComponentsBuilder.path("/books/{id}").buildAndExpand(book.getId()).toUri());
		return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}
	
	@ApiMethod(id = ShelfFlowConstants.BOOK_DELETE)
	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public void delete(@ApiPathParam(name = "id") @PathVariable Long id) {
		Book book = bookRepository.findOne(id);
		bookRepository.delete(book);
	}

}
最後的application.properties文件，用新的包：

jsondoc.version=1.0
jsondoc.basePath=http://localhost:8080
jsondoc.packages[0]=org.example.shelf.model
jsondoc.packages[1]=org.example.shelf.controller
jsondoc.packages[2]=org.example.shelf.flow
現在是再次啓動應用程序的時候，轉到http://localhost:8080/jsondoc-ui.html，插入http://localhost:8080/jsondoc輸入框並獲取文檔。請享用！


資源

這是項目的結構：


鏈接

關注公衆號，分享乾貨，討論技術


發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

（二）java版spring boot 社交電子商務平臺-security簡單使用

security的簡單原理： 使用衆多的攔截器對url攔截，以此來管理權限。但是這麼多攔截器，不可能對其一一來講，主要講裏面核心流程的兩個。 首先，權限管理離不開登陸驗證的，所以登陸驗證攔截器AuthenticationProcessing

原創 2023-10-10 11:05:06

（三）java版spring cloud+spring boot+redis多租戶社交電子商務平臺-Spring Cloud實戰隨機端口

我們經常會需要啓動多個實例的情況來測試註冊中心、配置中心等基礎設施的高可用，也會用來測試客戶端負載均衡的調用等。但是，我們一個應用只能有一個端口號，這就使得在本機測試的時候，不得不爲同一個服務設置不同的端口來進行啓動。 在本地用不同端口啓動

原創 2023-10-10 11:05:04

idea 創建簡單的Spring boot項目

1、 2、 3、 4、 5、 6、 7、運行 HelloWorld 啓動後內置的Tomcat服務器也同時啓動起來了,然後在瀏覽器中輸入  localhost:8080/hello 

原創 2023-02-25 00:27:09

springboot集成swagger，並掃描多個包路徑

1、引入依賴 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>

原創 2021-09-10 21:35:14

springboot微服務的開發利器

一、微服務和微服務架構 1.1)什麼是微服務         把一個單一的應用程序劃分爲一組小 的服務，每個小的服務都會運行在自己的進程中，服務之間通過輕量級的通信機制（http的rest api）進行通信,那麼 一個個的小服務就是微服務。

原創 2021-09-10 21:35:12

WebSocket實現羣發和單聊--Springboot實現

一：WebSocket原理 1、要談WebSocket就不得不提起HTTP連接     WebSocket是HTML5出的東西（協議，就是大家一起約定好的東西），也就是說HTTP協議沒有變化，或者說沒關係，但HTTP是不支持持久連接的（

原創 2021-07-03 21:23:33

線程池參數原理及應用

線程池原理     Java創建一個線程很方便，只需new Thread()就可以， 但是當有多個任務需要進行進行處理時，頻繁的進行創建和啓用線程同樣需要系統開銷，也不利於管理，於是同mysql的連接池一樣，自然有對線程的管理池即線程池。

原創 2021-07-03 21:23:32

使用Swagger2構建Spring Boot RESTful AIP 文檔

    上一篇我們介紹瞭如何使用Spring Boot快速構建RESTful API “Spring Boot與RESTful API ” ，本篇則介紹一個配合Spring Boot快速構建RESTful文檔的工具     由於Spri

原創 2021-04-23 21:34:13

微服務（spring cloud配置中心）

Spring  cloud配置中心 用於集中配置數據管理，簡化微服務集羣環境下大量配置的更新工作。 1:理解bootstrap.yaml    它會在application之前加載，如果和application有同名屬性，先啓動的會被覆

原創 2021-01-30 10:55:25

springboot 系列教程四：springboot thymeleaf配置

thymeleaf介紹 thymeleaf 是新一代的模板引擎，在spring4.0中推薦使用thymeleaf來做前端模版引擎。簡單說是一個跟 Velocity、FreeMarker 類似的模板引擎，它可以完全替代 JSP 。相較與其他的

原創 2021-01-30 10:25:33

springboot 系列教程五：springboot data jpa使用詳解

首先了解JPA是什麼？ JPA(Java Persistence API)是Sun官方提出的Java持久化規範。它爲Java開發人員提供了一種對象-關係表關聯映射工具來管理Java應用中的關係數據。他的出現主要是爲了簡化現有的持久化開發工

原創 2021-01-30 10:25:32

springboot 系列教程一：基礎項目搭建

使用 spring boot 有什麼好處 其實就是簡單、快速、方便！平時如果我們需要搭建一個 spring web 項目的時候需要怎麼做呢？ 配置 web.xml，加載 spring 和 spring mvc 配置數據庫連接、配置 sp

原創 2021-01-30 10:25:32

JPA & Spring Data JPA詳解

JPA & Spring Data JPA 一、JPA 1. JPA是什麼 JPA（Java Persistence API）Java持久化 API，是一套基於ORM思想的規範。 ORM（Object Relational Map

稀里糊涂啊哈 2020-07-08 07:41:13

Spring Boot + Vue實現樹形結構

一、前言 開發過程中，涉及到多級菜單的應用，樹形結構比較常見，今天就做了一個Spring Boot + Vue + Element-UI 實現樹形結構的一個小demo。 Tree組件最適合的結構是無序列列表ul，創建一個遞歸組件Item表

素小暖 2020-07-08 06:49:16

Spring Cloud如何優雅打印日誌：slf4j+logback

最近在對項目的日誌進行優化，主要是如何減少不必要的日誌輸出，如何優化日誌輸出的性能， 以及當前code中，一些不規範的日誌輸出代碼的優化。基於此，對java日誌進行了一個系統的梳理。 今天這裏，主要分享一個點，乾貨！具體的理論就不再重複搬

春秋战国程序猿 2020-07-08 00:17:05