1. Java基础异常处理

1.1 Exception类和RuntimeException类

在Java中，异常是程序运行过程中发生的错误或意外情况，异常可以打断正常的程序流程。Java的异常层次结构中，Throwable类是所有错误和异常的父类，分为两个主要子类：Error和Exception。

• Exception类：表示程序可以合理预期并且可以捕获和处理的异常情况。
• RuntimeException类：是Exception的子类，表示在运行时抛出的异常。这些异常是由编程错误（例如非法的参数传递或违反数组边界）引起的，不需要显式处理。

1.2 受检异常（Checked Exception）和非受检异常（Unchecked Exception）

Java中的异常分为两类：受检异常和非受检异常。

• 受检异常（Checked Exception）：

  • 受检异常是指在编译时由编译器强制检查的异常。如果某个方法可能会抛出受检异常，则必须显式捕获或声明抛出这些异常。
  • 常见的受检异常：IOException、SQLException、ClassNotFoundException等。

• 非受检异常（Unchecked Exception）：

  • 非受检异常是RuntimeException及其子类，编译器不强制要求程序员捕获或声明它们。这些异常通常是由于编程错误引发的，程序员可以选择不显式处理。
  • 常见的非受检异常：NullPointerException、IllegalArgumentException、ArrayIndexOutOfBoundsException等。

1.3 try-catch-finally机制

Java使用try-catch-finally机制来处理异常，确保程序在出现异常时依然能够运行。

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 捕获异常后的处理代码
} finally {
    // 无论是否发生异常，最终都会执行的代码
}

• try块：放置可能会抛出异常的代码。
• catch块：捕获并处理异常。可以有多个catch块来处理不同类型的异常。
• finally块：无论是否抛出异常，finally中的代码都会执行，通常用于资源释放。

示例：finally块的作用及其在资源释放中的使用

finally块用于放置需要无论异常是否发生都要执行的代码，如关闭文件、数据库连接等资源。

FileReader reader = null;
try {
    reader = new FileReader("file.txt");
    // 进行文件操作
} catch (FileNotFoundException e) {
    System.out.println("文件未找到");
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

即使在try或catch块中发生异常，finally块中的代码也会执行，确保文件被关闭。

1.4 throws声明异常

如果方法不能处理某些异常，可以通过throws关键字在方法签名中声明该方法可能抛出的异常。

示例

public void readFile(String fileName) throws IOException {
    FileReader fileReader = new FileReader(fileName);
    // 其他代码
}

这样调用该方法时，调用者必须捕获或进一步声明处理这些异常。

• 声明异常：当一个方法（1）可能会产生异常但方法自身无法处理了，就需要通过throws来声明异常 
• 向上传递：当我定义的方法（2）中需要调用某个已经声明了某种异常的方法（1）但是我这个方法（2）不想要处理这个异常的时候，可以继续通过throws将这个异常声明在方法（2）上，将对这个异常的处理继续向上传递，交给调用这个方法（2）的方法处理。
• 捕获异常：当我们要调用该方法且无法声明异常向上传递的时候，就必须用try-catch这个机制对异常进行捕获与处理。

方法签名声明异常与方法内部手动抛出异常的区别 

throws IOException：这是方法签名的一部分，表明该方法可能抛出IOException，但这只是一个声明，方法内部并不会自动抛出异常。

throw new IOException(...)：这是在方法内部实际抛出异常的操作，当某个逻辑条件（如文件为空）发生时，主动抛出一个异常。

if (file.isEmpty()) {
    throw new IOException("文件为空，无法上传");
}

在文件上传过程中，文件为空是一个业务逻辑错误，所以我们需要手动抛出异常来表示这个错误，并触发相应的错误处理机制。

1.5 自定义异常

你可以根据业务需求创建自定义异常类，通常继承自Exception或RuntimeException。

1.5.1 继承Exception类

 创建一个受检异常类，调用者需要处理它。

public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}

1.5.2 继承RuntimeException类

 创建一个非受检异常类，不强制要求调用者处理。

public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
}

1.5.3 调用自定义异常

public void performOperation(int value) {
    if (value < 0) {
        throw new CustomUncheckedException("值不能为负数");
    }
}

1.6 总结

• Exception和RuntimeException是Java异常体系的核心。
• 受检异常必须捕获或声明，非受检异常可以选择处理。
• try-catch-finally是处理异常的主要机制，finally用于资源释放。
• throws用于声明方法可能抛出的异常。
• 可以通过继承Exception或RuntimeException类创建自定义异常。

2. Spring Boot中的异常处理机制

2.1 @ExceptionHandler注解

@ExceptionHandler注解是Spring MVC提供的，用于在控制器中定义处理特定异常的方法。当控制器中的某个方法抛出异常时，Spring会捕获异常并将其交给对应的@ExceptionHandler方法来处理。

在Controller中使用@ExceptionHandler处理特定的异常

你可以在控制器中使用@ExceptionHandler处理特定的异常类型。例如，处理NullPointerException：

@RestController
public class MyController {

    @GetMapping("/example")
    public String example() {
        // 这里可能抛出异常
        throw new NullPointerException("空指针异常！");
    }

    // 通过 @ExceptionHandler 捕获 NullPointerException 异常
    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNullPointerException(NullPointerException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                             .body("捕获到空指针异常: " + ex.getMessage());
    }
}

• 这里的@ExceptionHandler方法捕获了NullPointerException，返回了一个带有自定义消息的错误响应，并设置了HTTP状态码为400 Bad Request。

2.2 @ControllerAdvice注解

@ControllerAdvice注解用于实现全局范围的异常处理。它可以集中处理整个应用程序中的异常，而不需要在每个控制器中重复编写异常处理逻辑。

使用@ControllerAdvice实现全局异常处理

@ControllerAdvice结合@ExceptionHandler可以实现全局的异常捕获和处理。例如：

@ControllerAdvice
public class GlobalExceptionHandler {

    // 捕获全局的 NullPointerException 异常
    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNullPointerException(NullPointerException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                             .body("全局捕获空指针异常：" + ex.getMessage());
    }

    // 捕获全局的自定义异常
    @ExceptionHandler(CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("全局处理自定义异常: " + ex.getMessage());
    }
}

• @ControllerAdvice可以自动扫描所有控制器，捕获它们抛出的异常。
• 通过多个@ExceptionHandler方法，可以处理多种类型的异常。

如何捕获并处理不同类型的异常

在全局异常处理器中，你可以根据不同的异常类型编写多个@ExceptionHandler，分别捕获并处理不同的异常。例如：

@ControllerAdvice
public class GlobalExceptionHandler {

    // 捕获 NullPointerException 异常
    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity<String> handleNullPointerException(NullPointerException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                             .body("空指针异常: " + ex.getMessage());
    }

    // 捕获 IllegalArgumentException 异常
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                             .body("非法参数异常: " + ex.getMessage());
    }

    // 捕获自定义异常
    @ExceptionHandler(CustomException.class)
    public ResponseEntity<String> handleCustomException(CustomException ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("处理自定义异常: " + ex.getMessage());
    }
}

这种方式允许你针对不同类型的异常进行个性化处理，并返回不同的HTTP状态码和错误消息。

2.3 自定义统一的异常响应格式

在实际项目中，你可能希望在处理异常时，返回统一格式的错误响应，比如包含错误码、错误信息等。可以通过定义统一的错误响应格式来实现。

首先，定义一个统一的异常响应类，包含必要的字段，如错误码、错误信息等：

public class ErrorResponse {
    private int errorCode;
    private String message;

    public ErrorResponse(int errorCode, String message) {
        this.errorCode = errorCode;
        this.message = message;
    }

    // Getters 和 Setters
}

然后，在全局异常处理器中使用这个ErrorResponse类返回统一的错误响应：

这里需要注意到是要将ResponseEntity<>的<>中的类型补充为你所定义的异常相应类。

@ControllerAdvice
public class GlobalExceptionHandler {

    // 捕获自定义异常并返回统一的异常响应格式
    @ExceptionHandler(CustomException.class)
    public ResponseEntity<ErrorResponse> handleCustomException(CustomException ex) {
        ErrorResponse errorResponse = new ErrorResponse(1001, ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body(errorResponse);
    }

    // 捕获其他异常并返回统一的异常响应格式
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse(1000, "服务器内部错误");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body(errorResponse);
    }
}

在这里，ErrorResponse类用于返回统一格式的异常响应，包含错误码和错误信息。当抛出CustomException时，会返回一个带有错误码1001的响应。当抛出其他未处理的异常时，会返回默认的错误码1000和统一的错误消息。

3. 文件操作中的异常处理

在Spring Boot中，文件操作是常见的任务之一。在进行文件读取、写入等操作时，可能会遇到多种异常，例如IOException和FileNotFoundException。处理这些异常不仅可以确保应用的稳定性，还能通过自定义响应向用户返回友好的错误信息。

接下来，我们将详细讲解如何在文件操作中处理这些异常，并且结合Spring Boot的全局异常处理机制和自定义异常响应格式。

3.1 处理IOException

IOException是Java中处理输入输出操作时的通用异常，文件操作如读取、写入文件时都可能抛出该异常。常见的IOException类型包括文件未找到、读写错误等。

处理文件读取、写入时的IOException

在进行文件读取或写入操作时，通常需要使用try-catch来捕获和处理IOException。下面是一个简单的示例，展示如何在文件读取操作中处理IOException。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileService {

    // 读取文件的示例
    public void readFile(String fileName) {
        FileReader reader = null;
        try {
            reader = new FileReader(fileName);
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            // 捕获并处理IOException
            System.out.println("读取文件时发生IO异常: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close(); // 确保资源被正确关闭
                }
            } catch (IOException e) {
                System.out.println("关闭文件时发生异常: " + e.getMessage());
            }
        }
    }

    // 写入文件的示例
    public void writeFile(String fileName, String content) {
        FileWriter writer = null;
        try {
            writer = new FileWriter(fileName);
            writer.write(content);
        } catch (IOException e) {
            // 捕获并处理IOException
            System.out.println("写入文件时发生IO异常: " + e.getMessage());
        } finally {
            try {
                if (writer != null) {
                    writer.close(); // 确保资源被正确关闭
                }
            } catch (IOException e) {
                System.out.println("关闭文件时发生异常: " + e.getMessage());
            }
        }
    }
}

关键点：

• 在文件操作过程中，IOException可能随时抛出，因此必须使用try-catch-finally进行处理。
• finally块用于确保在操作结束后，资源如文件流能够被正确关闭，无论是否发生异常。
• 对于读取操作和写入操作都可能抛出IOException，需要在每个操作中进行捕获。

3.2 捕获FileNotFoundException等常见文件操作异常

FileNotFoundException是IOException的一个子类，通常在试图打开一个不存在的文件时抛出。例如，在读取文件之前，如果文件不存在或路径不正确，就会抛出此异常。

捕获FileNotFoundException

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileService {

    public void readFile(String fileName) {
        try {
            FileReader reader = new FileReader(fileName);  // 文件不存在时将抛出FileNotFoundException
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (FileNotFoundException e) {
            // 捕获并处理FileNotFoundException
            System.out.println("文件未找到: " + fileName);
        } catch (IOException e) {
            // 捕获并处理其他IO异常
            System.out.println("读取文件时发生IO异常: " + e.getMessage());
        }
    }
}

关键点：

• FileNotFoundException是专门用于文件不存在或路径不正确的异常，需要在文件操作前捕获并处理。
• 文件操作的常见异常类型如FileNotFoundException应该单独捕获并给予明确的错误信息，提示用户文件路径可能有误。

3.3 全局文件异常处理

在Spring Boot中，使用@ControllerAdvice可以实现全局异常处理，将文件操作中的异常集中管理，避免在每个控制器中重复处理异常。通过@ControllerAdvice，可以统一处理与文件相关的异常，并返回自定义的错误响应。

使用@ControllerAdvice捕获文件相关的异常

假设我们有一个文件上传或下载功能，可能会抛出IOException或FileNotFoundException，我们可以在全局异常处理器中统一捕获这些异常。

示例：全局异常处理器

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.io.FileNotFoundException;
import java.io.IOException;

@ControllerAdvice
public class GlobalFileExceptionHandler {

    // 处理FileNotFoundException
    @ExceptionHandler(FileNotFoundException.class)
    public ResponseEntity<String> handleFileNotFoundException(FileNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                             .body("文件未找到: " + ex.getMessage());
    }

    // 处理IOException
    @ExceptionHandler(IOException.class)
    public ResponseEntity<String> handleIOException(IOException ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("文件操作失败: " + ex.getMessage());
    }
}

关键点：

• @ControllerAdvice注解用于定义全局异常处理器，它会自动捕获由控制器方法抛出的异常。
• @ExceptionHandler(FileNotFoundException.class)和@ExceptionHandler(IOException.class)用于捕获特定异常并处理。
• 使用ResponseEntity返回自定义的HTTP响应，可以设置状态码和错误信息，例如404文件未找到或500内部服务器错误。

3.4 自定义文件操作中的异常响应

为确保API返回给前端的信息友好且一致，通常可以为文件操作中的异常定义统一的响应格式。例如，在文件上传、下载过程中发生错误时，返回结构化的JSON响应，而不仅仅是简单的字符串。

定义自定义异常响应类

首先，定义一个通用的错误响应类：

public class ErrorResponse {
    private int status;
    private String message;

    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
    }

    // Getters and Setters
}

使用@ControllerAdvice返回自定义响应

在全局异常处理器中，返回ErrorResponse对象而不是简单的字符串响应：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.io.FileNotFoundException;
import java.io.IOException;

@ControllerAdvice
public class GlobalFileExceptionHandler {

    // 处理FileNotFoundException并返回自定义错误响应
    @ExceptionHandler(FileNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleFileNotFoundException(FileNotFoundException ex) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.NOT_FOUND.value(), "文件未找到: " + ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
    }

    // 处理IOException并返回自定义错误响应
    @ExceptionHandler(IOException.class)
    public ResponseEntity<ErrorResponse> handleIOException(IOException ex) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), "文件操作失败: " + ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

关键点：

• 自定义的ErrorResponse类可以包含多个字段，如状态码、错误消息，甚至是错误码或详细描述，确保前端能够根据统一格式处理错误响应。
• 在异常处理方法中，使用ResponseEntity<ErrorResponse>来返回自定义的异常响应对象。
• 这样可以保持API响应的一致性，尤其是在与前端协作时，错误格式规范化能带来更好的用户体验和调试效率。

3.5 示例：文件上传接口的异常处理

下面是一个完整的文件上传接口，结合了IOException的处理和全局异常响应。

文件上传控制器

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@RestController
public class FileController {

    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
        if (file.isEmpty()) {
            throw new IOException("文件为空，无法上传");
        }
        String filePath = "uploads/" + file.getOriginalFilename();
        File dest = new File(filePath);
        file.transferTo(dest); // 可能抛出IOException
        return ResponseEntity.status(HttpStatus.OK).body("文件上传成功: " + file.getOriginalFilename());
    }
}

全局异常处理器 

@ControllerAdvice
public class GlobalFileExceptionHandler {

    // 处理IOException并返回自定义响应
    @ExceptionHandler(IOException.class)
    public ResponseEntity<ErrorResponse> handleIOException(IOException ex) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), "文件上传失败: " + ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

4. 数据库操作中的异常处理

在Spring Boot中，数据库操作是应用程序的核心功能之一。无论是查询、插入、更新还是删除操作，都可能在数据库层面抛出异常。为了保证应用的健壮性和正确性，需要合理地处理这些异常，特别是在涉及事务回滚和数据库连接等关键场景时。接下来，我们详细讲解如何在Spring Data JPA中处理数据库操作中的异常。

4.1 Spring Data JPA中的常见异常

Spring Data JPA为我们提供了一套异常体系，主要通过DataAccessException类及其子类来表示各种数据库操作异常。JPA本身的异常如EntityNotFoundException也需要特别处理。

4.1.1 DataAccessException

DataAccessException是Spring中所有数据库相关异常的根异常。它是一个非受检异常，表示数据库操作失败，覆盖了常见的SQL、持久化、连接等问题。其常见的子类包括：

• DataIntegrityViolationException：表示违反数据库完整性约束，如主键冲突、外键约束等。
• QueryTimeoutException：表示查询超时。
• CannotAcquireLockException：表示无法获取数据库锁。
• DeadlockLoserDataAccessException：表示数据库死锁。
• EmptyResultDataAccessException：表示查询预期的结果为空。

4.1.2 EntityNotFoundException

EntityNotFoundException是JPA标准中的异常，通常在查询操作找不到实体对象时抛出。例如，通过findById获取某个对象，如果数据库中没有对应的记录，则可能抛出该异常。

import javax.persistence.EntityNotFoundException;
import org.springframework.dao.EmptyResultDataAccessException;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        try {
            return userRepository.findById(id).orElseThrow(() -> new EntityNotFoundException("用户未找到"));
        } catch (EntityNotFoundException e) {
            throw new RuntimeException("用户不存在: " + id);
        }
    }
}

4.2 处理数据库操作失败、连接超时、事务回滚等场景中的异常

4.2.1 处理数据库操作失败

在进行数据库操作时，可能出现连接问题、SQL语法错误等。通过捕获DataAccessException及其子类，可以有效处理各种数据库操作异常。

import org.springframework.dao.DataAccessException;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User createUser(User user) {
        try {
            return userRepository.save(user);
        } catch (DataAccessException e) {
            // 处理数据库异常
            throw new RuntimeException("数据库操作失败: " + e.getMessage(), e);
        }
    }
}

4.2.2 处理连接超时异常

数据库连接超时异常通常通过QueryTimeoutException或CannotAcquireLockException捕获，表示查询或事务操作超时或锁无法获取。

import org.springframework.dao.QueryTimeoutException;

public List<User> getUsers() {
    try {
        return userRepository.findAll();
    } catch (QueryTimeoutException e) {
        throw new RuntimeException("数据库查询超时: " + e.getMessage(), e);
    }
}

4.2.3 处理事务回滚

事务回滚时会抛出相应的异常，Spring通过@Transactional注解来自动管理事务。你可以配置事务在遇到特定异常时回滚，或者手动处理事务回滚中的异常。

import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.TransactionSystemException;

@Service
public class UserService {

    @Transactional
    public void updateUser(User user) {
        try {
            userRepository.save(user);
        } catch (TransactionSystemException e) {
            // 处理事务异常
            throw new RuntimeException("事务回滚失败: " + e.getMessage(), e);
        }
    }
}

4.3 事务异常处理

4.3.1 使用@Transactional管理事务异常

@Transactional是Spring用于管理事务的注解，它会确保在发生异常时，事务可以回滚。如果操作中抛出了异常（特别是运行时异常），Spring会自动回滚事务。

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void createOrder(Order order) {
        try {
            orderRepository.save(order);
            // 其他数据库操作
        } catch (DataAccessException e) {
            throw new RuntimeException("数据库操作失败，事务回滚: " + e.getMessage(), e);
        }
    }
}

4.3.2 如何在事务回滚时处理异常

默认情况下，@Transactional只会在非受检异常（unchecked exceptions）（例如RuntimeException）发生时回滚事务。如果你想在受检异常（如SQLException）发生时也回滚事务，可以通过设置rollbackFor属性来实现：

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

   @Transactional(rollbackFor = Exception.class)
public void createOrder(Order order) throws Exception {
    try {
        orderRepository.save(order);
        // 其他数据库操作
    } catch (SQLException e) {
        // 即使是受检异常，事务也会回滚
        throw new Exception("数据库错误导致事务回滚", e);
    }
}

}

4.3.3 手动触发事务回滚

在某些情况下，你可能需要根据业务逻辑手动触发事务回滚。这可以通过TransactionAspectSupport类中的setRollbackOnly方法来实现。

import org.springframework.transaction.interceptor.TransactionAspectSupport;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

@Transactional
public void createOrder(Order order) {
    try {
        orderRepository.save(order);
        // 根据业务条件触发回滚
        if (someCondition) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    } catch (Exception e) {
        throw new RuntimeException("业务逻辑异常，手动回滚事务", e);
    }
}

}

 需要手动触发事务回滚的场景：

1. 业务逻辑校验失败时需要回滚

在某些复杂的业务逻辑中，即使数据库操作本身是成功的，但由于业务规则未满足，仍然需要回滚事务。例如，订单创建成功，但由于库存不足或用户账户余额不足等业务逻辑不满足，此时你可能希望手动回滚事务。

2. 条件判断后需要回滚

在事务操作的过程中，如果遇到某些条件不满足，可以手动回滚事务。通常这些条件不是编程错误或异常，而是基于业务场景的判断。例如，支付过程中验证用户身份或授权，如果验证不通过，虽然数据库操作没有抛出异常，但也需要回滚事务。

3. 多次操作中，部分成功但需要整体失败时回滚

如果你在一个事务中执行多次数据库操作，有时虽然前面的操作成功了，但由于某个后续操作失败了，你需要回滚所有的已执行操作。例如，在一个用户注册流程中，你可能已经创建了用户记录，但由于发送邮件失败，你想要回滚之前的所有操作。

4. 数据库外部资源失败时回滚

有时，事务不仅涉及数据库操作，还包括其他外部资源的操作，比如调用远程API、文件上传等。如果这些外部资源操作失败，也可能希望回滚数据库的操作。例如，在支付系统中，先保存了订单信息，但由于远程支付接口失败，你需要回滚订单保存操作。

4.4 全局数据库异常处理

通过@ControllerAdvice可以对所有数据库相关的异常进行全局处理。这允许我们将数据库异常捕获并返回统一的错误响应。

@ControllerAdvice
public class GlobalDatabaseExceptionHandler {

    // 处理所有 DataAccessException 异常
    @ExceptionHandler(DataAccessException.class)
    public ResponseEntity<String> handleDataAccessException(DataAccessException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("数据库操作异常: " + e.getMessage());
    }

    // 处理 EntityNotFoundException 异常
    @ExceptionHandler(EntityNotFoundException.class)
    public ResponseEntity<String> handleEntityNotFoundException(EntityNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                             .body("实体未找到: " + e.getMessage());
    }
}

5. Rest API中的异常处理

在构建RESTful API时，异常处理是确保API健壮性和用户体验的重要组成部分。通过有效的异常处理机制，您可以捕获和管理应用程序中的错误，向客户端返回一致且有意义的错误响应。下面，我们将详细讲解在Spring Boot中如何处理REST API中的异常，包括在@RestController中处理异常、使用@RestControllerAdvice实现全局异常处理、自定义统一的异常响应格式以及创建自定义的异常处理器类。

5.1 @RestController中的异常处理（使用@ExceptionHandler）

@RestController是Spring MVC中用于创建RESTful Web服务的注解。与传统的@Controller不同，@RestController默认将方法返回值序列化为JSON或XML格式的响应体，而不需要额外的@ResponseBody注解。

在@RestController中，您可以使用@ExceptionHandler注解在控制器内部处理特定的异常。这种方式适用于只在特定控制器中处理异常的场景。

示例：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id)
                .orElseThrow(() -> new UserNotFoundException("用户未找到，ID: " + id));
    }

    // 在控制器内部处理UserNotFoundException
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }
}

说明：

• getUserById方法尝试通过ID查找用户，如果未找到则抛出UserNotFoundException。
• @ExceptionHandler(UserNotFoundException.class)方法捕获并处理UserNotFoundException，返回自定义的ErrorResponse和404 Not Found状态码。

5.2 使用@RestControllerAdvice处理REST API中的异常

当您希望在整个应用程序范围内统一处理异常时，@RestControllerAdvice是一个非常有效的工具。它结合了@ControllerAdvice和@ResponseBody，适用于RESTful API的全局异常处理。

什么是@RestControllerAdvice

@RestControllerAdvice是@ControllerAdvice的一个特化版本，专门用于RESTful Web服务。它允许您在全局范围内定义异常处理逻辑，并自动将返回值序列化为JSON或XML格式的响应体。

1. 定义统一的错误响应格式

// 1. 定义统一的错误响应格式
public class ErrorResponse {
    private int status;
    private String message;
    private long timestamp;

    public ErrorResponse() {}

    public ErrorResponse(int status, String message) {
        this.status = status;
        this.message = message;
        this.timestamp = System.currentTimeMillis();
    }

    // Getters 和 Setters
    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }
}

2. 创建全局异常处理器类，使用@RestControllerAdvice和@ExceptionHandler注解。 

// 2. 创建全局异常处理器类
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理自定义的UserNotFoundException
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    // 处理其他未捕获的异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGlobalException(Exception ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), "服务器内部错误");
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 处理特定的DataAccessException
    @ExceptionHandler(DataAccessException.class)
    public ResponseEntity<ErrorResponse> handleDataAccessException(DataAccessException ex) {
        ErrorResponse error = new ErrorResponse(HttpStatus.BAD_REQUEST.value(), "数据库操作异常");
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }
}

说明：

• ErrorResponse类：定义了统一的错误响应结构，包括状态码、错误消息和时间戳。
• GlobalExceptionHandler类：
  • 使用@RestControllerAdvice注解，使其成为全局的异常处理器。
  • 定义多个@ExceptionHandler方法，分别处理不同类型的异常，如UserNotFoundException、DataAccessException以及其他未捕获的Exception。
  • 每个异常处理方法返回一个ResponseEntity<ErrorResponse>，包含自定义的错误信息和相应的HTTP状态码。

5.3 自定义统一异常响应格式，返回标准化的错误信息

为了提高API的可维护性和用户体验，建议为所有错误响应定义一个统一的格式。这不仅使前端更容易解析错误信息，也确保了错误响应的一致性。

5.3.1 定义统一的错误响应类

前面已经介绍了一个简单的ErrorResponse类，下面是一个更完整的示例，包含更多的信息，如错误码、详细信息等。

public class ErrorResponse {
    private int status;
    private String error;
    private String message;
    private String path;
    private long timestamp;

    public ErrorResponse() {}

    public ErrorResponse(int status, String error, String message, String path) {
        this.status = status;
        this.error = error;
        this.message = message;
        this.path = path;
        this.timestamp = System.currentTimeMillis();
    }

    // Getters 和 Setters
    // ... 省略以节省空间
}

说明：

• status：HTTP状态码，例如404、500等。
• error：错误类型或名称，如Not Found、Internal Server Error等。
• message：详细的错误消息，描述具体的错误原因。
• path：请求的URI，帮助定位错误发生的位置。
• timestamp：错误发生的时间，通常以毫秒为单位的时间戳。

5.3.2 更新全局异常处理器以使用更详细的ErrorResponse

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(),
                ex.getMessage(),
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(CustomBusinessException.class)
    public ResponseEntity<ErrorResponse> handleCustomBusinessException(CustomBusinessException ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(),
                ex.getMessage(),
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(),
                "服务器内部错误",
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

说明：

• WebRequest参数：通过WebRequest获取请求的详细信息，如URI，方便在错误响应中包含请求路径。
• 每个异常处理方法都返回一个ErrorResponse对象，确保所有错误响应的结构一致。
• 可以根据不同的异常类型返回不同的HTTP状态码和错误消息，以便客户端根据需要进行处理。

5.4 综合示例

以下是一个综合的示例，展示如何在Spring Boot中实现REST API的异常处理，包括自定义异常类、统一的错误响应格式、全局异常处理器以及控制器中的异常抛出。

1. 定义自定义异常类

// UserNotFoundException.java
public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

// CustomBusinessException.java
public class CustomBusinessException extends RuntimeException {
    public CustomBusinessException(String message) {
        super(message);
    }
}

2. 定义统一的错误响应类

// ErrorResponse.java
public class ErrorResponse {
    private int status;
    private String error;
    private String message;
    private String path;
    private long timestamp;

    public ErrorResponse() {}

    public ErrorResponse(int status, String error, String message, String path) {
        this.status = status;
        this.error = error;
        this.message = message;
        this.path = path;
        this.timestamp = System.currentTimeMillis();
    }

    // Getters 和 Setters
    // 省略以节省空间
}

3. 创建控制器

// UserController.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    @Autowired
    private UserService userService;

    // 获取用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id)
                .orElseThrow(() -> new UserNotFoundException("用户未找到，ID: " + id));
    }

    // 创建用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        if (user.getName() == null || user.getName().isEmpty()) {
            throw new CustomBusinessException("用户名不能为空");
        }
        return userService.save(user);
    }
}

4. 创建服务层

// UserService.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.dao.DataAccessException;

import java.util.Optional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public Optional<User> findById(Long id) {
        try {
            return userRepository.findById(id);
        } catch (DataAccessException e) {
            throw new RuntimeException("数据库查询失败: " + e.getMessage(), e);
        }
    }

    public User save(User user) {
        try {
            return userRepository.save(user);
        } catch (DataAccessException e) {
            throw new RuntimeException("数据库保存失败: " + e.getMessage(), e);
        }
    }
}

5. 创建全局异常处理器

// GlobalExceptionHandler.java
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.WebRequest;

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理UserNotFoundException
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.NOT_FOUND.value(),
                HttpStatus.NOT_FOUND.getReasonPhrase(),
                ex.getMessage(),
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    // 处理CustomBusinessException
    @ExceptionHandler(CustomBusinessException.class)
    public ResponseEntity<ErrorResponse> handleCustomBusinessException(CustomBusinessException ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.BAD_REQUEST.value(),
                HttpStatus.BAD_REQUEST.getReasonPhrase(),
                ex.getMessage(),
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    // 处理DataAccessException
    @ExceptionHandler(DataAccessException.class)
    public ResponseEntity<ErrorResponse> handleDataAccessException(DataAccessException ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(),
                "数据库操作异常: " + ex.getMessage(),
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 处理所有其他异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex, WebRequest request) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(),
                "服务器内部错误",
                request.getDescription(false).replace("uri=", "")
        );
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

6. 测试API

• 获取用户：
  • 请求：GET /api/users/1
  • 场景：
    • 用户存在：返回用户数据。
    • 用户不存在：抛出UserNotFoundException，返回404 Not Found和错误响应。
• 创建用户：
  • 请求：POST /api/users，请求体包含用户数据。
  • 场景：
    • 用户名为空：抛出CustomBusinessException，返回400 Bad Request和错误响应。
    • 数据库保存失败：抛出RuntimeException，返回500 Internal Server Error和错误响应。

示例错误响应：

{
    "status": 404,
    "error": "Not Found",
    "message": "用户未找到，ID: 1",
    "path": "/api/users/1",
    "timestamp": 1697932800000
}

6. 异常日志记录

6.1 使用SLF4J记录日志

6.1.1 什么是SLF4J

SLF4J是Java中的一种日志记录抽象层，它允许开发人员在代码中使用统一的日志API，而实际的日志实现（如Logback或Log4j）可以在运行时通过配置文件来决定。这种方式提高了应用程序的灵活性。

6.1.2 SLF4J中的常见日志级别

SLF4J提供了多种日志级别，用于表示不同严重程度的日志信息：

• TRACE：最细粒度的信息，通常用于调试目的。
• DEBUG：用于调试应用程序，通常只在开发过程中使用。
• INFO：用于记录常规运行信息，表明程序按预期工作。
• WARN：用于记录警告信息，表明可能存在问题但程序可以继续运行。
• ERROR：用于记录错误信息，表明发生了严重的问题。

6.1.3 如何在异常处理中使用SLF4J记录日志

在异常处理过程中，记录异常日志有助于分析问题的原因。通常我们会在捕获异常后使用logger.error()记录错误信息，并将异常的堆栈信息一同记录下来。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    public User findUserById(Long id) {
        try {
            // 假设这里是查找用户的逻辑
            return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("用户未找到"));
        } catch (UserNotFoundException ex) {
            // 记录异常日志
            logger.error("查找用户时发生异常: 用户ID: {}", id, ex);
            throw ex;
        }
    }
}

在上述代码中：

• logger.error()：用于记录错误级别的日志信息。
• ex：记录异常的堆栈信息。
• 占位符 {}：SLF4J支持使用占位符来插入动态内容，如用户ID。

6.1.4 记录异常堆栈信息

在异常处理时，通常需要记录完整的异常堆栈信息，以便在后续排查问题时能够了解异常的根源。通过将异常对象传递给日志方法，可以记录堆栈信息：

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 记录异常的堆栈信息
    logger.error("发生了异常", e);
}

这里的logger.error("发生了异常", e)不仅会输出错误信息，还会记录异常的堆栈跟踪。

6.2 使用@Slf4j注解

Spring Boot与Lombok库集成非常好，Lombok提供了@Slf4j注解，帮助开发人员自动注入SLF4J的日志记录器，避免手动声明Logger对象。

6.2.1 什么是@Slf4j

@Slf4j是Lombok提供的一个注解，它通过注解方式自动注入SLF4J日志记录器，避免了手动创建Logger对象的繁琐。它会在编译时自动生成一个Logger类型的log字段。

6.2.2 @Slf4j的使用示例

要使用@Slf4j注解，首先需要引入Lombok库（如果项目中未使用Lombok）：

Maven依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
    <scope>provided</scope>
</dependency>

然后，在类上直接使用@Slf4j注解：

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j  // 自动生成log对象
@Service
public class UserService {

    public User findUserById(Long id) {
        try {
            // 假设这里是查找用户的逻辑
            return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("用户未找到"));
        } catch (UserNotFoundException ex) {
            // 使用log记录异常日志
            log.error("查找用户时发生异常: 用户ID: {}", id, ex);
            throw ex;
        }
    }
}

在这个例子中：

• @Slf4j注解为该类自动生成了log对象，开发人员可以直接使用log来记录日志，而不再需要手动声明Logger对象。
• 通过log.error()记录异常和堆栈信息。

6.3 在全局异常处理器中记录详细异常日志

为了确保在整个应用中统一处理异常并记录详细的日志，通常我们会在@ControllerAdvice或@RestControllerAdvice中实现全局异常处理器。在全局异常处理器中，可以记录所有未捕获异常的详细日志，包括异常类型、请求信息、堆栈信息等。

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;

@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleAllExceptions(Exception ex, WebRequest request) {
        // 使用log记录异常详细日志
        log.error("处理请求时发生异常，URI: {}，错误信息: {}", request.getDescription(false), ex.getMessage(), ex);

        return new ResponseEntity<>("服务器内部错误，请稍后再试", HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

说明：

• @ControllerAdvice用于全局异常处理。
• @ExceptionHandler(Exception.class)方法捕获所有未处理的异常，并记录详细的日志信息。
• logger.error()记录异常消息、请求URI和完整的异常堆栈信息。
• 通过@Slf4j注解，日志记录器log对象被自动注入，简化了日志的使用。

6.4 在不同级别记录日志

根据异常的严重程度和应用场景，可以选择不同的日志级别来记录日志：

• log.error()：用于记录严重异常或系统错误信息，例如数据库连接失败、重要业务流程中断等。
• log.warn()：用于记录警告信息，例如可能会导致问题但不影响当前操作的情况。
• log.info()：用于记录正常操作中的信息，例如记录API请求的成功信息或用户登录操作。
• log.debug()：用于开发调试时的细节信息，生产环境下可以禁用此级别的日志。

示例：

try {
    // 可能抛出异常的代码
} catch (SpecificException ex) {
    log.warn("警告：发生了特定异常，继续执行。原因：{}", ex.getMessage());
} catch (Exception ex) {
    log.error("发生了严重错误，系统将停止执行。原因：{}", ex.getMessage(), ex);
    throw ex;  // 重新抛出异常
}

6.5 日志记录的最佳实践

6.5.1 记录足够的上下文信息

当记录异常日志时，除了异常堆栈信息之外，还应该尽量记录与问题相关的上下文信息。这可以包括：

• 请求的URI：可以通过WebRequest.getDescription()获取。
• 请求参数：如果是REST API，可以记录请求的路径参数或查询参数。
• 用户相关信息：例如用户ID或用户名（前提是这些信息不是敏感数据），可以帮助跟踪哪个用户遇到了问题。

示例：

log.error("用户ID: {}, 请求URI: {}, 发生异常: {}", userId, request.getDescription(false), ex.getMessage(), ex);

6.5.2 避免记录敏感数据

日志不应包含敏感信息，如密码、银行卡号、身份信息等。这不仅会增加安全风险，还可能违反数据保护法规（如GDPR）。如果必须记录敏感操作，应该确保相关信息经过脱敏处理。

6.5.3 在异常日志中使用占位符提高效率

SLF4J支持使用占位符（{}）来替换日志信息中的动态数据。这种方式比直接字符串拼接性能更好，因为如果日志级别被禁用时（例如DEBUG级别日志在生产环境中禁用），占位符会被跳过，避免不必要的字符串拼接操作。

示例：

log.error("处理请求失败，请求ID: {}，异常信息: {}", requestId, ex.getMessage(), ex);

6.5.4 日志格式标准化

为了便于日志分析和工具处理，建议使用一致的日志格式。例如，在JSON格式日志中，通常会包含时间戳、日志级别、日志消息等字段。

示例：

log.error("时间: {}, 用户ID: {}, 请求路径: {}, 错误信息: {}", LocalDateTime.now(), userId, requestPath, ex.getMessage(), ex);

6.5.5 使用日志上下文（MDC）

MDC（Mapped Diagnostic Context）是一种日志增强功能，允许在不同的日志记录之间共享一些上下文信息，如请求ID、用户ID等。可以将这些信息存储在MDC中，在每条日志记录时自动添加。

1. 设置MDC上下文信息

你可以使用MDC.put(key, value)方法将某些上下文信息（如用户ID）存储在MDC中，这样在之后的每一条日志记录中，都会自动包含这些信息。

import org.slf4j.MDC;

public class UserService {

    public void processRequest(Long userId) {
        try {
            // 将用户ID存储到MDC上下文中
            MDC.put("userId", String.valueOf(userId));

            // 执行一些逻辑
            log.info("开始处理用户请求");

        } catch (Exception e) {
            log.error("处理用户请求时发生异常", e);
        } finally {
            // 确保请求结束后清理MDC上下文
            MDC.clear();
        }
    }
}

2. 日志输出自动包含MDC信息

一旦将用户ID存储到MDC中，所有后续的日志记录都会自动包含该用户ID，而你不需要在每条日志中手动传递它。具体效果取决于你使用的日志格式配置，比如：

创建logback-spring.xml

你可以在src/main/resources目录下创建一个logback-spring.xml文件来覆盖默认配置，并自定义日志输出。

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!-- 定义控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志格式：%X{} 用于输出MDC中的信息 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg [userId:%X{userId}, requestId:%X{requestId}]%n</pattern>
        </encoder>
    </appender>

    <!-- 设置root日志记录器，使用DEBUG级别，并输出到控制台 -->
    <root level="DEBUG">
        <appender-ref ref="STDOUT"/>
    </root>

</configuration>

在上面的日志配置中，%X{userId}会自动从MDC中获取用户ID并添加到日志中。输出的日志可能如下：

2024-10-21 10:30:00 [main] INFO  UserService - 开始处理用户请求 [userId:12345]

3. 清理MDC上下文

使用完MDC后，务必调用MDC.clear()来清理上下文信息，防止其他线程重用这些信息或导致数据污染，尤其是在多线程环境中。

finally {
    // 清理MDC信息
    MDC.clear();
}

7. 异常处理中的性能优化

在Java应用中，异常处理的代价相对较高，尤其是在频繁抛出异常的情况下会影响性能。因此，减少异常的开销是性能优化中的一个重要方面。接下来，我们将深入讨论如何通过避免频繁抛出异常和提前检查来降低异常处理的开销。

7.1. 避免频繁抛出异常带来的性能问题

异常是Java中用于处理程序运行时错误的一种机制，但其底层实现是通过创建异常对象并生成堆栈跟踪来实现的，这些操作都涉及到额外的资源消耗。异常抛出和捕获的过程远比普通的逻辑判断和分支操作耗时，因此频繁抛出异常会对性能产生负面影响。

7.1.1 异常的开销来自哪里？

抛出异常时，Java虚拟机（JVM）需要执行以下操作：

• 创建异常对象：当抛出异常时，系统需要创建一个新的异常对象，这个过程涉及内存分配。
• 捕获堆栈跟踪：异常的堆栈跟踪保存了程序执行到当前点的所有方法调用。这意味着JVM需要遍历当前线程的调用栈并生成详细的跟踪信息，这一操作是昂贵的，尤其是在调用链较深的情况下。
• 跳转到异常处理代码：当异常被抛出时，JVM需要跳过正常的执行路径，寻找并跳转到异常处理代码，这涉及额外的控制流跳转。

因此，如果在应用的关键路径中（如循环、批量处理等高频操作）频繁抛出异常，系统性能会显著下降。

7.1.2 避免将异常用于流程控制

异常的设计初衷是用于处理程序运行时的意外情况，而不是用于控制业务流程。将异常用于流程控制是一个常见的误用，尤其是在高频率调用中，会导致不必要的开销。

反例：通过异常控制流程

public int parsePositiveInteger(String input) {
    try {
        int value = Integer.parseInt(input);
        if (value <= 0) {
            throw new NumberFormatException();
        }
        return value;
    } catch (NumberFormatException e) {
        // 使用异常作为流程控制
        return -1;
    }
}

在这种情况下，NumberFormatException被频繁抛出和捕获来控制业务流程，这不仅增加了异常的开销，还导致代码的可读性变差。

优化：使用条件检查而非异常控制流

public int parsePositiveInteger(String input) {
    // 提前检查避免不必要的异常抛出
    if (input != null && input.matches("\\d+")) {
        int value = Integer.parseInt(input);
        if (value > 0) {
            return value;
        }
    }
    return -1;  // 通过正常流程处理错误
}

通过提前检查输入是否合法，避免抛出和捕获异常，可以显著减少性能开销。

7.1.3 在高频操作中避免异常

在高频操作（如循环、批量处理）中抛出异常对性能的影响尤为显著，因为每次抛出异常时，JVM都需要重复上述一系列昂贵的操作。尽量在高频操作中通过逻辑判断避免异常，是提高性能的有效措施。

反例：在循环中频繁抛出异常

for (int i = 0; i < items.size(); i++) {
    try {
        processItem(items.get(i));  // 可能抛出异常
    } catch (ItemProcessingException e) {
        // 捕获异常，处理错误
    }
}

如果每个循环迭代都可能抛出异常，尤其是当这个循环包含大量元素时，频繁的异常处理会拖慢程序的执行速度。

优化：提前检查避免异常

for (int i = 0; i < items.size(); i++) {
    if (isValidItem(items.get(i))) {  // 通过提前检查避免抛出异常
        processItem(items.get(i));
    } else {
        // 处理无效项
    }
}

通过在操作之前进行合法性检查，可以避免异常的抛出，从而优化性能。

7.2. 提前检查避免触发异常

提前检查是指在执行可能导致异常的操作之前，主动进行条件判断，避免异常的抛出。这种方法可以通过逻辑判断替代异常处理，减少系统的开销。

7.2.1 在空指针场景中提前检查

空指针异常（NullPointerException）是Java开发中最常见的异常之一。通过在操作之前检查对象是否为空，可以避免不必要的异常抛出。

反例：直接调用可能为null的对象

public void printUserName(User user) {
    System.out.println(user.getName());  // 如果user为null，会抛出NullPointerException
}

优化：提前检查避免空指针异常

public void printUserName(User user) {
    if (user != null) {
        System.out.println(user.getName());  // 只有在user不为null时才调用方法
    } else {
        System.out.println("用户不存在");
    }
}

7.2.2 使用Optional避免空指针异常

在某些情况下，特别是在返回值可能为空的场景下，可以使用Optional来避免空指针异常。Optional是Java 8引入的一个容器类，用于明确表达“值可能存在也可能不存在”的语义。

使用Optional处理空值

public Optional<User> findUserById(Long id) {
    User user = userRepository.findById(id);
    return Optional.ofNullable(user);  // 返回Optional以避免null
}

在调用端，可以使用Optional.isPresent()或Optional.ifPresent()来避免空指针异常：

Optional<User> userOpt = userService.findUserById(id);
userOpt.ifPresent(user -> System.out.println(user.getName()));  // 如果user存在，则输出其名称

7.2.3 检查输入合法性

在处理用户输入或外部数据时，通过提前检查数据的合法性，避免处理过程中抛出异常，这是一种常见且有效的性能优化手段。

反例：依赖异常处理非法输入

public void saveAge(String ageInput) {
    try {
        int age = Integer.parseInt(ageInput);
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
        // 保存年龄
    } catch (NumberFormatException | IllegalArgumentException e) {
        // 处理异常
    }
}

优化：提前验证输入

public void saveAge(String ageInput) {
    if (ageInput != null && ageInput.matches("\\d+")) {
        int age = Integer.parseInt(ageInput);
        if (age >= 0) {
            // 保存年龄
        } else {
            // 提示年龄不能为负数
        }
    } else {
        // 提示输入非法
    }
}

通过提前检查输入是否合法，避免在处理过程中抛出异常，可以显著提升性能，尤其是在输入验证操作频繁的情况下。