Annuaire d'articles
Récemment, j'essayais d'écrire un blog personnel simple en utilisant le mode de séparation front-end et back-end. J'ai rencontré le problème de la structure de retour des données de l'interface. Je l'ai vérifié sur Internet et j'ai trouvé une méthode très utile. J'ai également rencontré dans le processus de reproduction.Il existe de nombreux pièges, qui sont spécialement enregistrés ici.
Créer un projet SpringBoot
Importez les dépendances suivantes
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
Encapsuler le résultat de retour
Créez un nouveau resultpackage et placez les classes liées à l'encapsulation du résultat dans ce package. Créez ReturnCodeune classe d'énumération. Comme il s'agit d'une démonstration, j'ai écrit deux valeurs de retour. En utilisation réelle, il devrait y avoir plus que ces deux types
@Getter
public enum ReturnCode {
RC200(200, "success"),
RC400(400, "fail");
private final int code;
private final String msg;
ReturnCode(int code, String msg){
this.code = code;
this.msg = msg;
}
}
Créer ResultDataune classe en tant qu'encapsulation du type de retour unifié
@Data
public class ResultData<T> {
private int code;
private String msg;
private T data;
public static <T> ResultData<T> success(T data) {
ResultData<T> resultData = new ResultData<>();
resultData.setCode(ReturnCode.RC200.getCode());
resultData.setMsg(ReturnCode.RC200.getMsg());
resultData.setData(data);
return resultData;
}
public static <T> ResultData<T> fail(int code, String msg) {
ResultData<T> resultData = new ResultData<>();
resultData.setCode(code);
resultData.setMsg(msg);
return resultData;
}
}
Implémenter l'encapsulation automatique des objets renvoyés
C'est return Result.success()trop , vous pouvez utiliser SpringBoot pour réaliser l'encapsulation automatique de l'objet renvoyé, créer ResponseAdviceet implémenter ResponseBodyAdvice<T>l'interface
@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
@Autowired
private ObjectMapper objectMapper;
@Override
public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
return true;
}
@SneakyThrows
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType,
Class<? extends HttpMessageConverter<?>> aClass,
ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
if (o instanceof String) {
return objectMapper.writeValueAsString(ResultData.success(o));
}
if (o instanceof ResultData) {
return o;
}
return ResultData.success(o);
}
}
gérer les exceptions
À ce stade, si une exception se produit et qu'il n'y a aucun moyen de la gérer, nous pouvons la capturer uniformément par le gestionnaire d'exception global. La plus grande commodité de l'utilisation du gestionnaire d'exception global est que vous n'avez plus besoin d'écrire du code à la main, de créer un nouveau package et créeztry...catch un gestionnaire d'exceptions global sous le packageerrorRestExceptionHandler
@Slf4j
@RestControllerAdvice
public class RestExceptionHandler {
@ExceptionHandler(Exception.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public ResultData<String> exception(Exception e) {
log.error("全局异常信息 ex={}", e.getMessage(), e);
return ResultData.fail(ReturnCode.RC400.getCode(), e.getMessage());
}
}
test
Ensuite, écrivez un contrôleur de test et écrivez deux méthodes pour tester s'il fonctionne correctement
@RestController
public class TestController {
@GetMapping("/right")
public String hello() {
return "Hello, SpringBoot!";
}
@GetMapping("/error")
public int error() {
return 9 / 0;
}
}
Utilisez l'outil de test d'interface Postman pour tester les deux interfaces séparément et vous obtiendrez les résultats attendus.