Reliabiliti adalah aset platform kewangan dan analisis yang besar.Ketika kami merancang semula platform perniagaan, kami belajar bahawa perkara utama yang membuat pelanggan tidak berpuas hati bukan prestasi atau antara muka pengguna; ia adalah kesilapan yang tidak diperbaiki yang menghancurkan proses. dalam Spring Boot atau corak serupa dalam kerangka kerja lain, pastikan bahawa sistem bertindak seperti yang diharapkan apabila mereka berada di bawah tekanan. @ControllerAdvice Why This Matters Apabila anda mencipta REST APIs dalam , anda akan dengan cepat menghadapi masalah ini: Spring Boot “ ” How do I handle errors neatly without writing repetitive try-catch blocks everywhere? Bayangkan mempunyai Setiap orang boleh gagal dengan , input yang tidak sah, atau sumber yang hilang. Alih-alih mengembalikan jejak stack yang kacau, anda mahu . 50+ endpoints Pengecualian Null Pointer consistent, meaningful, and client-friendly error responses Itulah di mana masuk - ia menyatukan semua pengurusan ralat di satu tempat. Mari kita lihat untuk membina ini langkah demi langkah, dengan contoh dunia sebenar. @ControllerAdvice how Use Case — User Management REST API Kami akan mencipta a yang menyokong: simple User API 
 
 
 
 
 
 Fetching users 
 
 Creating users 
 
 
 Simulating failures for testing Our goal → build a   that returns clean JSON responses. unified global error-handling layer Step 1: Project Setup Dependencies (Maven): <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
 This brings in web + validation support. Then create your main app: @SpringBootApplication
public class ExceptionHandlerDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(ExceptionHandlerDemoApplication.class, args);
    }
}
 Step 2: Define the Entity — User.java @Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    @NotBlank(message = "Name cannot be blank")
    private String name;
    @Min(value = 18, message = "Age must be at least 18")
    private int age;
}
 • Mengapa : **Kami menambah pengesahan mudah supaya Spring boleh mengaktifkan Metode Argument Not Valid Pengecualian secara automatik apabila input tidak sah. Step 3: Custom Exception for Missing Data public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}
public class InvalidRequestException extends RuntimeException {
    public InvalidRequestException(String message) {
        super(message);
    }
}
 • Mengapa : ** Untuk mewakili keadaan "pengguna tidak ditemui" dengan bersih bukannya pengecualian umum. Step 4: Build the Controller @RestController
@RequestMapping("/api/users")
public class UserController {
    // Simple GET that throws ResourceNotFoundException for id > 100
    @GetMapping("/{id}")
    public String getUser(@PathVariable("id") @Min(1) Integer id) {
        if (id > 100) {
            throw new ResourceNotFoundException("User with id " + id + " not found");
        }
        return "User-" + id;
    }
    // Create user example to demonstrate validation
    public static record CreateUserRequest(
            @NotBlank(message = "name is required") String name,
            @Min(value = 18, message = "age must be >= 18") int age) {}
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public String createUser(@RequestBody @Valid CreateUserRequest body) {
        if ("bad".equalsIgnoreCase(body.name())) {
            throw new InvalidRequestException("Name 'bad' is not allowed");
        }
        return "created:" + body.name();
    }
    // Endpoint to force a server error for demo
    @GetMapping("/boom")
    public void boom() {
        throw new IllegalStateException("simulated server error");
    }
}
 • Mengapa : **Kami mewujudkan senario yang realistik - tidak didapati, kesilapan pengesahan, dan kesilapan runtime - yang pengendali global kami akan menguruskan. Step 5: Create a Standard Error Model @Data
@AllArgsConstructor
@NoArgsConstructor
public class ErrorResponse {
    private OffsetDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private List<FieldError> fieldErrors;}
 • Mengapa : ** Semua API mesti mengembalikan kesilapan dalam struktur yang sama - ini meningkatkan pemantauan dan debugging dalam pengeluaran. Step 6: Implement @ControllerAdvice (Global Handler) @ControllerAdvice
public class GlobalExceptionHandler {
    private final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    // Handle custom validation exceptions
    @ExceptionHandler(InvalidRequestException.class)
    public ResponseEntity<ErrorResponse> handleInvalidRequest(InvalidRequestException ex, HttpServletRequest req) {
        log.debug("InvalidRequestException: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(body);
    }
    // Resource not found -> 404
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex, HttpServletRequest req) {
        log.debug("ResourceNotFoundException: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(body);
    }
    // Validation errors from @Valid on request bodies
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex, HttpServletRequest req) {
        log.debug("Validation failed: {}", ex.getMessage());
        List<ErrorResponse.FieldError> fieldErrors = ex.getBindingResult().getFieldErrors().stream()
                .map(fe -> new ErrorResponse.FieldError(fe.getField(), fe.getRejectedValue(), fe.getDefaultMessage()))
                .collect(Collectors.toList());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), "Validation failed", req.getRequestURI());
        body.setFieldErrors(fieldErrors);
        return ResponseEntity.badRequest().body(body);
    }
    // Type mismatch for method args (?id=abc)
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<ErrorResponse> handleTypeMismatch(MethodArgumentTypeMismatchException ex, HttpServletRequest req) {
        log.debug("Type mismatch: {}", ex.getMessage());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(), ex.getMessage(), req.getRequestURI());
        return ResponseEntity.badRequest().body(body);
    }
    // No handler found (404 for unmatched endpoints)
    @ExceptionHandler(NoHandlerFoundException.class)
    public ResponseEntity<ErrorResponse> handleNoHandler(NoHandlerFoundException ex, HttpServletRequest req) {
        log.debug("NoHandlerFound: {} {}", ex.getHttpMethod(), ex.getRequestURL());
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(), "Endpoint not found", req.getRequestURL().toString());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(body);
    }
    // Generic fallback
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAll(Exception ex, HttpServletRequest req) {
        log.error("Unhandled exception: ", ex);
        ErrorResponse body = new ErrorResponse(OffsetDateTime.now(), HttpStatus.INTERNAL_SERVER_ERROR.value(),
                HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "An internal error occurred", req.getRequestURI());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
    }
}
 Why: 
 
 
 
 @ControllerAdvice → Menjadikan ia global di seluruh kawalan. @ExceptionHandler → Menangkap jenis pengecualian tertentu. Pembantu buildResponse() menyimpan kod DRY dan bersih. Step 7: Test Scenarios   GET /api/users/1 Kode Tanggapan: 200 -Sukses » » » » GET /api/users/999 Kode Jawapan: 404 Resource Not Found » » » » Validation Error POST / API / Pengguna {"name":"", "age": 15} Response: » » » » Unexpected Error GET /api/pengguna/boom » » » » Why This Approach Works in Real Projects 
 
 
 
 
 
 
 
 
 
 Problem 
 Solution 
 
 
 
 Too many try-catch blocks 
 Centralized handling with @ControllerAdvice 
 
 
 
 Inconsistent responses 
 Unified ErrorResponse structure 
 
 
 
 Hard to debug 
 Standardized messages with timestamps and paths 
 
 
 
 Client confusion 
 Clear, meaningful messages for each failure type Terlalu banyak blok tempahan Pengendalian bersentralisasi dengan @ControllerAdvice Jawapan yang tidak konsisten Struktur Penyelesaian Kesilapan Bersatu Sukar untuk debug Mesej standard dengan timestamp dan laluan Pelanggan kebingungan Pesan yang jelas dan bermakna untuk setiap jenis kegagalan Real-World Usage Scenarios 
 
 
 
 
 API Perbankan: Pastikan kesilapan pengesahan (seperti nombor akaun yang tidak sah) tidak menjejaskan perkhidmatan. E-dagang: Mengendalikan produk-tidak ditemukan atau kesalahan pembayaran dengan sopan. Data Microservices: Mengembalikan mesej berstruktur apabila data input gagal pengesahan. API Gateway: Tanggapan yang konsisten di pelbagai microservices. Final Thoughts Dengan menggabungkan @ControllerAdvice, @ExceptionHandler, dan model Jawapan Kesilapan yang mudah, anda mendapat: 
 
 
 
 Kod yang bersih Pengalaman API yang konsisten Memudahkan debugging dalam pengeluaran Ia adalah salah satu corak reka bentuk yang paling mudah tetapi paling berkuasa dalam pembangunan Spring Boot.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Audio ini dihasilkan dalam bahasa asal cerita!

Reka bentuk sistem API yang boleh dipercayai: Pengurusan pengecualian dengan pengawal Spring Boot

About Author

KOMEN

GANTUNG TANDA

ARTIKEL INI DIBENTANGKAN DALAM

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps