// 這就是咱項(xiàng)目的啟動(dòng)類(lèi)，@SpringBootApplication一貼，萬(wàn)事俱備
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        // 啟動(dòng)SpringBoot項(xiàng)目的固定寫(xiě)法，記不住就復(fù)制粘貼
        SpringApplication.run(DemoApplication.class, args);
    }
}

// 單獨(dú)用的情況很少見(jiàn)，一般這么寫(xiě)
@SpringBootConfiguration
public class CustomConfig {
    // 里面可以定義@Bean
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

// 比如不想用默認(rèn)的數(shù)據(jù)源自動(dòng)配置，就這么排除
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

// 配置RestTemplate的例子，這是咱開(kāi)發(fā)中經(jīng)常寫(xiě)的
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        // 可以在這里配置超時(shí)時(shí)間、攔截器等
        return builder
                .setConnectTimeout(Duration.ofSeconds(5))
                .setReadTimeout(Duration.ofSeconds(5))
                .build();
    }
}

@Configuration
public class ThreadPoolConfig {
    // 定義一個(gè)線程池bean，名字就是方法名threadPoolTaskExecutor
    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 核心線程數(shù)
        executor.setMaxPoolSize(10); // 最大線程數(shù)
        executor.setQueueCapacity(20); // 隊(duì)列容量
        executor.initialize();
        return executor;
    }
}

# application.yml里的配置
server:
  port: 8080
custom:
  name: 張三
  age: 25
  isVip: true
@RestController
public class ConfigController {
    // 讀取server.port
    @Value("${server.port}")
    private Integer port;
    // 讀取custom.name，還能加默認(rèn)值，要是配置里沒(méi)這個(gè)key，就用默認(rèn)值“李四”
    @Value("${custom.name:李四}")
    private String name;
    // 讀取布爾值
    @Value("${custom.isVip}")
    private Boolean isVip;
    @GetMapping("/config")
    public String getConfig() {
        return "端口：" + port + "，姓名：" + name + "，是否VIP：" + isVip;
    }
}

# application.yml里的數(shù)據(jù)庫(kù)配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo?useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
# 自定義的第三方接口配置
third:
  api:
    url: https://api.xxx.com
    appKey: abc123
    appSecret: xyz789
    timeout: 5000
// 數(shù)據(jù)庫(kù)配置實(shí)體類(lèi)
@ConfigurationProperties(prefix = "spring.datasource") // prefix指定配置的前綴
@Component // 要讓Spring掃描到這個(gè)類(lèi)，不然沒(méi)法綁定
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
    private String driverClassName; // 注意：配置里是driver-class-name，這里用駝峰命名也能對(duì)應(yīng)上
    // getters和setters必須有，不然沒(méi)法注入值
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    // 其他getter和setter省略...
}
// 第三方接口配置實(shí)體類(lèi)，還能加數(shù)據(jù)校驗(yàn)
@ConfigurationProperties(prefix = "third.api")
@Component
@Validated // 開(kāi)啟數(shù)據(jù)校驗(yàn)
public class ThirdApiProperties {
    @NotBlank(message = "接口URL不能為空") // 校驗(yàn)url不能為null或空字符串
    private String url;
    @NotBlank(message = "appKey不能為空")
    private String appKey;
    @NotBlank(message = "appSecret不能為空")
    private String appSecret;
    @Min(value = 1000, message = "超時(shí)時(shí)間不能小于1000毫秒") // 校驗(yàn)timeout至少1000
    private Integer timeout;
    // getters和setters省略...
}

# 自定義的custom.properties文件，放在resources目錄下
custom.phone=13800138000
custom.email=zhangsan@xxx.com
@Component
@PropertySource(value = "classpath:custom.properties", encoding = "UTF-8") // 指定文件路徑和編碼
@ConfigurationProperties(prefix = "custom")
public class CustomProperties {
    private String phone;
    private String email;
    // getters和setters省略...
}

// 開(kāi)發(fā)環(huán)境的數(shù)據(jù)源配置
@Configuration
@Profile("dev") // 只有當(dāng)激活dev環(huán)境時(shí)，這個(gè)配置才生效
public class DevDataSourceConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/dev_db?useSSL=false");
        config.setUsername("dev_root");
        config.setPassword("dev_123456");
        return new HikariDataSource(config);
    }
}

// 生產(chǎn)環(huán)境的數(shù)據(jù)源配置
@Configuration
@Profile("prod") // 激活prod環(huán)境時(shí)生效
public class ProdDataSourceConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://192.168.1.100:3306/prod_db?useSSL=true");
        config.setUsername("prod_root");
        config.setPassword("prod_xxxxxx");
        return new HikariDataSource(config);
    }
}

@Configuration
publicclass RedisConfig {

    // 只有當(dāng)RedisTemplate這個(gè)類(lèi)不存在時(shí)，才創(chuàng)建這個(gè)自定義的RedisTemplate bean
    @Bean
    @ConditionalOnMissingBean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 配置序列化方式
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        template.setValueSerializer(serializer);
        template.setKeySerializer(new StringRedisSerializer());
        return template;
    }
}

// 前后端分離項(xiàng)目的Controller，直接用@RestController
@RestController
@RequestMapping("/user") // 類(lèi)上的請(qǐng)求路徑前綴，所有方法都帶/user
publicclass UserController {

    // 處理GET請(qǐng)求，路徑是/user/{id}，{id}是路徑參數(shù)
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        // 模擬從數(shù)據(jù)庫(kù)查數(shù)據(jù)
        User user = new User(id, "張三", 25);
        return ResponseEntity.ok(user); // 返回200狀態(tài)碼和用戶數(shù)據(jù)
    }

    // 處理POST請(qǐng)求，路徑是/user，請(qǐng)求體是JSON格式的User對(duì)象
    @PostMapping
    public ResponseEntity<String> addUser(@RequestBody User user) {
        // 模擬保存用戶
        return ResponseEntity.status(HttpStatus.CREATED).body("用戶添加成功：" + user.getName());
    }
}

@RestController
@RequestMapping("/order") // 類(lèi)上的前綴，所有方法路徑都帶/order
publicclass OrderController {

    // 處理GET請(qǐng)求，路徑是/order，相當(dāng)于@RequestMapping(value = "/", method = RequestMethod.GET)
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public List<Order> getOrderList() {
        // 模擬查訂單列表
        List<Order> orders = Arrays.asList(
                new Order(1L, "訂單1", 100.0),
                new Order(2L, "訂單2", 200.0)
        );
        return orders;
    }

    // 處理POST請(qǐng)求，路徑是/order，相當(dāng)于@RequestMapping(value = "/", method = RequestMethod.POST)
    @RequestMapping(value = "/", method = RequestMethod.POST)
    public String createOrder() {
        return"訂單創(chuàng)建成功";
    }
}

@RestController
@RequestMapping("/user")
publicclass UserController {

    // 處理PUT請(qǐng)求，路徑是/user/{id}，全量更新用戶
    @PutMapping("/{id}")
    publicString updateUser(@PathVariable Long id, @RequestBody User user) {
        // 模擬更新，id是路徑參數(shù)，user是請(qǐng)求體里的更新數(shù)據(jù)
        return"用戶" + id + "更新成功，新信息：" + user.getName();
    }

    // 處理DELETE請(qǐng)求，路徑是/user/{id}，刪除用戶
    @DeleteMapping("/{id}")
    publicString deleteUser(@PathVariable Long id) {
        // 模擬刪除
        return"用戶" + id + "刪除成功";
    }
}

@GetMapping("/user/{id}/{name}") // 路徑里有兩個(gè)參數(shù)：id和name
public String getUserInfo(
        @PathVariable Long id, // 直接拿id，參數(shù)名和路徑里的{id}一致
        @PathVariable("name") String userName // 路徑里是{name}，變量名是userName，用value指定對(duì)應(yīng)關(guān)系
) {
    return "id：" + id + "，姓名：" + userName;
}

// 請(qǐng)求路徑：/user/list?page=1&size=10&keyword=張
@GetMapping("/user/list")
public String getUserList(
        @RequestParam(defaultValue = "1") Integer page, // 默認(rèn)值1，沒(méi)傳page就用1
        @RequestParam(defaultValue = "10") Integer size, // 默認(rèn)值10
        @RequestParam(required = false) String keyword // 可選參數(shù)，沒(méi)傳就是null
) {
    return "當(dāng)前頁(yè)碼：" + page + "，每頁(yè)條數(shù)：" + size + "，查詢關(guān)鍵詞：" + keyword;
}

// 請(qǐng)求體是JSON：{"name":"李四","age":30,"phone":"13900139000"}
@PostMapping("/user")
publicString addUser(@RequestBody@Valid User user) { // @Valid開(kāi)啟數(shù)據(jù)校驗(yàn)
    return"添加用戶成功：" + user.getName() + "，手機(jī)號(hào)：" + user.getPhone();
}

// User類(lèi)，加了數(shù)據(jù)校驗(yàn)注解
publicclass User {
    private Long id;

    @NotBlank(message = "姓名不能為空") // 姓名不能為null或空字符串
    privateString name;

    @Min(value = 18, message = "年齡不能小于18歲") // 年齡至少18
    private Integer age;

    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手機(jī)號(hào)格式不正確") // 手機(jī)號(hào)正則校驗(yàn)
    privateString phone;

    // getters和setters省略...
}

// 傳統(tǒng)項(xiàng)目，用@Controller，有的方法返回頁(yè)面，有的方法返回JSON
@Controller
@RequestMapping("/test")
publicclass TestController {

    // 返回頁(yè)面，不用@ResponseBody，返回的是Thymeleaf模板名
    @GetMapping("/page")
    publicString getPage() {
        return"index"; // 對(duì)應(yīng)resources/templates/index.html
    }

    // 返回JSON，需要加@ResponseBody
    @GetMapping("/json")
    @ResponseBody
    public Map<String, String> getJson() {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        return map;
    }
}

@GetMapping("/header")
public String getHeader(
        @RequestHeader("User-Agent") String userAgent, // 獲取User-Agent（客戶端信息）
        @RequestHeader(value = "Token", required = false) String token // 獲取Token，可選
) {
    String result = "客戶端信息：" + userAgent;
    if (token != null) {
        result += "，Token：" + token;
    }
    return result;
}

@GetMapping("/cookie")
public String getCookie(
        @CookieValue(value = "username", required = false) String username, // 獲取username Cookie
        @CookieValue(value = "sessionId", defaultValue = "unknown") String sessionId // 默認(rèn)值
) {
    return "Cookie中的用戶名：" + username + "，SessionId：" + sessionId;
}

// 通用組件，用@Component
@Component
public class CommonUtils {

    // 比如一個(gè)工具方法
    public String formatDate(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(date);
    }
}

// 服務(wù)層類(lèi)，用@Service
@Service
publicclass UserService {

    // 業(yè)務(wù)邏輯方法：根據(jù)id查用戶
    public User getUserById(Long id) {
        // 這里實(shí)際會(huì)調(diào)用DAO層查數(shù)據(jù)庫(kù)，現(xiàn)在模擬一下
        if (id == 1L) {
            returnnew User(1L, "張三", 25);
        } else {
            returnnull;
        }
    }

    // 業(yè)務(wù)邏輯方法：添加用戶
    public boolean addUser(User user) {
        // 模擬保存邏輯
        return user != null && user.getName() != null;
    }
}

// 數(shù)據(jù)訪問(wèn)層類(lèi)，用@Repository
@Repository
public class UserDao {

    // 模擬數(shù)據(jù)庫(kù)查詢
    public User findById(Long id) {
        return new User(id, "李四", 30);
    }
}

@RestController
@RequestMapping("/user")
public class UserController {

    // 自動(dòng)注入U(xiǎn)serService，不用new UserService()
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        // 直接用注入的userService調(diào)用方法
        return userService.getUserById(id);
    }
}

@Service
publicclass UserService {

    // 同一個(gè)類(lèi)型有多個(gè)Bean的情況，用@Qualifier指定Bean名稱(chēng)
    @Autowired
    @Qualifier("userDaoImpl1") // 指定注入名稱(chēng)為userDaoImpl1的Bean
    private UserDao userDao;

    public User getUserById(Long id) {
        return userDao.findById(id);
    }
}

// UserDao的實(shí)現(xiàn)類(lèi)1
@Repository("userDaoImpl1")
publicclass UserDaoImpl1 implements UserDao {
    @Override
    public User findById(Long id) {
        returnnew User(id, "張三（來(lái)自Impl1）", 25);
    }
}

// UserDao的實(shí)現(xiàn)類(lèi)2
@Repository("userDaoImpl2")
publicclass UserDaoImpl2 implements UserDao {
    @Override
    public User findById(Long id) {
        returnnew User(id, "李四（來(lái)自Impl2）", 30);
    }
}

@Service
public class OrderService {

    // 按名稱(chēng)注入，name指定Bean名稱(chēng)
    @Resource(name = "orderDao")
    private OrderDao orderDao;

    // 不指定name，默認(rèn)按變量名“userService”匹配Bean名稱(chēng)
    @Resource
    private UserService userService;

    public Order getOrderById(Long id) {
        return orderDao.findById(id);
    }
}

@Service
publicclass PayService {

    // 同一個(gè)PayDao有多個(gè)實(shí)現(xiàn)類(lèi)，用@Qualifier指定注入alipayDao
    @Autowired
    @Qualifier("alipayDao")
    private PayDao payDao;

    public String pay(Double amount) {
        return payDao.pay(amount);
    }
}

@Repository("alipayDao")
publicclass AlipayDao implements PayDao {
    @Override
    public String pay(Double amount) {
        return"支付寶支付：" + amount + "元";
    }
}

@Repository("wechatPayDao")
publicclass WechatPayDao implements PayDao {
    @Override
    public String pay(Double amount) {
        return"微信支付：" + amount + "元";
    }
}

@Service
publicclass UserService {

    // 沒(méi)加@Qualifier，會(huì)優(yōu)先注入加了@Primary的UserDao
    @Autowired
    private UserDao userDao;

    public User getUserById(Long id) {
        return userDao.findById(id);
    }
}

// 加了@Primary，是首選Bean
@Repository
@Primary
publicclass UserDaoImpl1 implements UserDao {
    @Override
    public User findById(Long id) {
        returnnew User(id, "張三（首選Impl1）", 25);
    }
}

// 沒(méi)加@Primary，不是首選
@Repository
publicclass UserDaoImpl2 implements UserDao {
    @Override
    public User findById(Long id) {
        returnnew User(id, "李四（Impl2）", 30);
    }
}

// 加了@Lazy，Spring啟動(dòng)時(shí)不創(chuàng)建這個(gè)Bean，第一次用的時(shí)候才創(chuàng)建
@Service
@Lazy
publicclass LazyService {

    public LazyService() {
        // 構(gòu)造方法，啟動(dòng)時(shí)如果沒(méi)創(chuàng)建，這個(gè)日志不會(huì)打印
        System.out.println("LazyService被創(chuàng)建了");
    }

    public String doSomething() {
        return"LazyService做事了";
    }
}

@RestController
publicclass LazyController {

    @Autowired
    private LazyService lazyService;

    // 第一次訪問(wèn)這個(gè)接口的時(shí)候，才會(huì)創(chuàng)建LazyService，打印構(gòu)造方法的日志
    @GetMapping("/lazy")
    public String testLazy() {
        return lazyService.doSomething();
    }
}

// 自定義@Log注解
@Target(ElementType.METHOD) // 注解作用在方法上
@Retention(RetentionPolicy.RUNTIME) // 注解在運(yùn)行時(shí)生效
public @interface Log {
    String value() default ""; // 注解的屬性，用來(lái)描述日志內(nèi)容
}

@Component // 讓Spring掃描到
@Aspect// 標(biāo)記為切面類(lèi)
publicclass LogAspect {

    privatestaticfinal Logger log = LoggerFactory.getLogger(LogAspect.class);

    // 定義切入點(diǎn)：加了@Log注解的方法
    @Pointcut("@annotation(com.demo.annotation.Log)")
    public void logPointcut() {}

    // 前置通知：方法執(zhí)行前記錄請(qǐng)求信息
    @Before("logPointcut() && @annotation(logAnnotation)") // 拿到@Log注解的屬性
    public void beforeLog(JoinPoint joinPoint, Log logAnnotation) {
        // 獲取請(qǐng)求信息
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 記錄日志
        log.info("【前置通知】請(qǐng)求URL：{}，請(qǐng)求方法：{}，日志描述：{}",
                request.getRequestURL(),
                request.getMethod(),
                logAnnotation.value());
    }

    // 返回后通知：方法正常返回后記錄返回值
    @AfterReturning(pointcut = "logPointcut()", returning = "result") // returning指定返回值變量名
    public void afterReturningLog(JoinPoint joinPoint, Object result) {
        log.info("【返回后通知】方法返回值：{}", result);
    }

    // 異常通知：方法拋異常后記錄異常信息
    @AfterThrowing(pointcut = "logPointcut()", throwing = "e") // throwing指定異常變量名
    public void afterThrowingLog(JoinPoint joinPoint, Exception e) {
        log.error("【異常通知】方法拋出異常：{}，異常信息：{}",
                e.getClass().getName(),
                e.getMessage(),
                e); // 打印異常棧
    }

    // 環(huán)繞通知：記錄方法執(zhí)行時(shí)間
    @Around("logPointcut()")
    public Object aroundLog(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis(); // 開(kāi)始時(shí)間

        // 執(zhí)行切入點(diǎn)方法（也就是目標(biāo)方法）
        Object result = joinPoint.proceed();

        long endTime = System.currentTimeMillis(); // 結(jié)束時(shí)間
        long costTime = endTime - startTime; // 執(zhí)行時(shí)間

        log.info("【環(huán)繞通知】方法執(zhí)行時(shí)間：{}毫秒", costTime);

        return result; // 返回目標(biāo)方法的返回值
    }
}

@RestController
@RequestMapping("/user")
publicclass UserController {

    @Autowired
    private UserService userService;

    // 加@Log注解，描述日志內(nèi)容
    @Log("根據(jù)ID查詢用戶")
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @Log("添加用戶")
    @PostMapping
    publicString addUser(@RequestBody User user) {
        boolean success = userService.addUser(user);
        return success ? "添加成功" : "添加失敗";
    }
}

@Service
publicclass OrderService {

    @Autowired
    private OrderDao orderDao;

    @Autowired
    private StockDao stockDao;

    // 下單方法，需要事務(wù)支持：創(chuàng)建訂單和扣庫(kù)存必須同時(shí)成功或失敗
    @Transactional(
            propagation = Propagation.REQUIRED, // 事務(wù)傳播行為：默認(rèn)
            isolation = Isolation.READ_COMMITTED, // 隔離級(jí)別：讀已提交
            timeout = 5, // 超時(shí)時(shí)間5秒
            rollbackFor = Exception.class // 所有Exception都回滾（默認(rèn)只回滾RuntimeException）
    )
    public String createOrder(Long productId, Integer count) {
        try {
            // 1. 創(chuàng)建訂單
            Order order = new Order();
            order.setProductId(productId);
            order.setCount(count);
            order.setStatus(0); // 0：未支付
            orderDao.insert(order);
            log.info("創(chuàng)建訂單成功：{}", order.getId());

            // 2. 扣庫(kù)存
            int rows = stockDao.decreaseStock(productId, count);
            if (rows == 0) {
                // 庫(kù)存不足，拋出異常，觸發(fā)事務(wù)回滾
                thrownew RuntimeException("商品" + productId + "庫(kù)存不足");
            }
            log.info("扣庫(kù)存成功：商品{}，數(shù)量{}", productId, count);

            return"下單成功，訂單ID：" + order.getId();
        } catch (Exception e) {
            log.error("下單失敗", e);
            // 拋出異常，觸發(fā)回滾（如果是checked異常，要手動(dòng)拋，或者rollbackFor指定）
            thrownew RuntimeException("下單失敗：" + e.getMessage());
        }
    }
}

@Service
public class TestService {
    public void methodA() {
        // 內(nèi)部調(diào)用methodB，methodB的事務(wù)不生效
        methodB();
    }

    @Transactional
    public void methodB() {
        // 數(shù)據(jù)庫(kù)操作
    }
}

// 純Spring項(xiàng)目的配置類(lèi)，需要加@EnableTransactionManagement
@Configuration
@EnableTransactionManagement
public class SpringConfig {

    // 配置數(shù)據(jù)源、事務(wù)管理器等
    @Bean
    public DataSource dataSource() {
        // 數(shù)據(jù)源配置
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        returnnewDataSourceTransactionManager(dataSource);
    }
}

// 自定義業(yè)務(wù)異常
public class BusinessException extends RuntimeException {
    private Integer code; // 錯(cuò)誤碼

    // 構(gòu)造方法
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    // getter
    public Integer getCode() {
        return code;
    }
}

// 全局異常處理，返回JSON
@RestControllerAdvice
publicclass GlobalExceptionHandler {

    // 捕獲自定義的BusinessException
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResult> handleBusinessException(BusinessException e) {
        ErrorResult result = new ErrorResult(e.getCode(), e.getMessage());
        // 返回400狀態(tài)碼和錯(cuò)誤信息
        return ResponseEntity.badRequest().body(result);
    }

    // 捕獲參數(shù)校驗(yàn)異常（MethodArgumentNotValidException）
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResult> handleValidException(MethodArgumentNotValidException e) {
        // 獲取校驗(yàn)失敗的信息
        String message = e.getBindingResult().getFieldErrors().stream()
                .map(FieldError::getDefaultMessage)
                .collect(Collectors.joining("，"));
        ErrorResult result = new ErrorResult(400, message);
        return ResponseEntity.badRequest().body(result);
    }

    // 捕獲其他所有未處理的異常（兜底）
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResult> handleException(Exception e) {
        log.error("系統(tǒng)異常", e); // 記錄異常棧
        ErrorResult result = new ErrorResult(500, "系統(tǒng)繁忙，請(qǐng)稍后再試");
        // 返回500狀態(tài)碼
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
    }

    // 錯(cuò)誤結(jié)果實(shí)體類(lèi)
    @Data
    staticclass ErrorResult {
        private Integer code; // 錯(cuò)誤碼
        private String message; // 錯(cuò)誤信息

        public ErrorResult(Integer code, String message) {
            this.code = code;
            this.message = message;
        }
    }
}

@Service
publicclass UserService {

    public User getUserById(Long id) {
        if (id == null || id <= 0) {
            // 拋?zhàn)远x異常，錯(cuò)誤碼400，提示信息
            thrownew BusinessException(400, "用戶ID不能為空且必須大于0");
        }
        // 模擬查數(shù)據(jù)庫(kù)
        if (id == 1L) {
            returnnew User(1L, "張三", 25);
        } else {
            thrownew BusinessException(404, "用戶不存在");
        }
    }
}

{
  "code": 400,
  "message": "用戶ID不能為空且必須大于0"
}

// 多例Bean，每次注入或獲取都是新實(shí)例
@Component
@Scope("prototype")
publicclass PrototypeBean {

    private Integer count = 0;

    public void increment() {
        count++;
    }

    public Integer getCount() {
        return count;
    }
}

// 測(cè)試多例Bean
@RestController
publicclass ScopeController {

    @Autowired
    private PrototypeBean prototypeBean1;

    @Autowired
    private PrototypeBean prototypeBean2;

    @GetMapping("/prototype")
    public String testPrototype() {
        prototypeBean1.increment();
        prototypeBean2.increment();
        // 兩個(gè)Bean的count都是1，因?yàn)槭遣煌膶?shí)例
        return"prototypeBean1 count：" + prototypeBean1.getCount() + 
               "，prototypeBean2 count：" + prototypeBean2.getCount();
    }
}

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

@RestController
@RequestMapping("/user")
@RequiredArgsConstructor// 自動(dòng)生成帶final字段的構(gòu)造方法
publicclass UserController {

    // 用final修飾，@RequiredArgsConstructor會(huì)生成帶這個(gè)字段的構(gòu)造方法
    privatefinal UserService userService;

    // 不用加@Autowired，Spring會(huì)通過(guò)構(gòu)造方法注入
    privatefinal OrderService orderService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @GetMapping("/order/{userId}")
    public List<Order> getOrderByUserId(@PathVariable Long userId) {
        return orderService.getOrderByUserId(userId);
    }
}

@Service
@Slf4j // 自動(dòng)生成log對(duì)象
publicclass UserService {

    public User getUserById(Long id) {
        log.info("開(kāi)始查詢用戶，用戶ID：{}", id); // 用log.info打日志
        try {
            // 模擬查數(shù)據(jù)庫(kù)
            if (id == 1L) {
                User user = new User(1L, "張三", 25);
                log.debug("查詢到用戶信息：{}", user); // debug日志，一般開(kāi)發(fā)環(huán)境開(kāi)啟
                return user;
            } else {
                log.warn("用戶不存在，用戶ID：{}", id); // warn日志，警告信息
                return null;
            }
        } catch (Exception e) {
            log.error("查詢用戶失敗，用戶ID：{}", id, e); // error日志，異常信息
            throw e;
        }
    }
}

@Service
publicclass UserService {

    // 方法參數(shù)加@NonNull，自動(dòng)校驗(yàn)非空
    public boolean addUser(@NonNull User user) {
        if (user.getName() == null) {
            returnfalse;
        }
        // 模擬保存
        returntrue;
    }

    // 字段加@NonNull，Lombok會(huì)在構(gòu)造方法和setter里加非空校驗(yàn)
    @Data
    @AllArgsConstructor
    publicstaticclass User {
        private Long id;
        @NonNull// 姓名非空
        private String name;
        private Integer age;
    }
}

// 測(cè)試
@RestController
publicclass UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/user")
    public String addUser(@RequestBody UserService.User user) {
        // 如果user是null，調(diào)用addUser的時(shí)候會(huì)拋NullPointerException
        boolean success = userService.addUser(user);
        return success ? "添加成功" : "添加失敗";
    }
}

// 用@Data，自動(dòng)生成getter、setter、toString、equals、hashCode
@Data
publicclassUser {
    private Long id;
    private String name;
    private Integer age;
    private String phone;
    private Date createTime;
}

// 測(cè)試
publicclassTest {
    public static void main(String[] args) {
        User user = new User();
        user.setId(1L); // 自動(dòng)生成的setter
        user.setName("張三");
        System.out.println(user.getName()); // 自動(dòng)生成的getter
        System.out.println(user); // 自動(dòng)生成的toString
    }
}

@Data
@NoArgsConstructor// 無(wú)參構(gòu)造
@AllArgsConstructor// 全參構(gòu)造
publicclass Order {
    private Long id;
    private Long userId;
    private Double amount;
    private Integer status;
    privateDate createTime;
}

// 測(cè)試
publicclass Test {
    publicstaticvoid main(String[] args) {
        // 無(wú)參構(gòu)造
        Order order1 = new Order();
        order1.setId(1L);
        order1.setUserId(100L);

        // 全參構(gòu)造
        Order order2 = new Order(2L, 101L, 200.0, 0, newDate());
        System.out.println(order2);
    }
}