package com.liu;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("com.liu.mapper")  // 掃描Mapper接口
@SpringBootApplication         // 核心注解
public class SimpleAccountingApplication {
    public static void main(String[] args) {
        SpringApplication.run(SimpleAccountingApplication.class, args);
    }
}

// 錯(cuò)誤：啟動(dòng)類放在子包里，掃描不到其他組件
package com.liu.config;  // 錯(cuò)誤位置
@SpringBootApplication
public class Application { }
// 正確：啟動(dòng)類放在根包
package com.liu;  // 正確位置
@SpringBootApplication
public class Application { }

@Component
public class JwtUtil {
    @Value("${jwt.secret}")
    private String secret;
    public String generateToken(Long userId, Integer role, String username) {
        // 生成JWT Token
    }
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;  // 自動(dòng)注入Mapper
    @Autowired
    private JwtUtil jwtUtil;  // 自動(dòng)注入工具類
    public User login(String username, String password) {
        return userMapper.selectByUsername(username);
    }
}

@Service
@RequiredArgsConstructor  // Lombok注解，自動(dòng)生成構(gòu)造器
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;  // final修飾
    private final JwtUtil jwtUtil;
    // Lombok自動(dòng)生成構(gòu)造器，Spring自動(dòng)注入
}

@Component
public class JwtUtil {
    @Value("${jwt.secret}")
    private String secret;  // 注入配置：jwt.secret
    @Value("${jwt.expiration}")
    private Long expiration;  // 注入配置：jwt.expiration
}

jwt:
  secret: my-secret-key-12345
  expiration: 7200000  # 2小時(shí)

// 錯(cuò)誤：配置文件中沒有這個(gè)key
@Value("${jwt.secretKey}")  // 配置文件是jwt.secret，不是jwt.secretKey
private String secret;
// 正確：設(shè)置默認(rèn)值
@Value("${jwt.secret:default-secret}")  // 如果沒有配置，使用default-secret
private String secret;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private JwtInterceptor jwtInterceptor;
    // 注冊攔截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**");
    }
    // 配置跨域
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOriginPatterns("*")
                .allowedMethods("GET", "POST", "DELETE", "PUT");
    }
}

@RestController
@RequestMapping("/user")
public class UserController {
    @PostMapping("/login")
    public Result<String> login(@RequestParam String username, 
                                @RequestParam String password) {
        // 返回JSON：{"code":200,"msg":"登錄成功","data":"token"}
        return Result.success("登錄成功", token);
    }
}

@RestController
@RequestMapping("/user")  // 類級(jí)別：所有方法的URL前綴
public class UserController {
    // 方法級(jí)別：完整URL = /user/login
    @RequestMapping(value = "/login", method = {RequestMethod.GET, RequestMethod.POST})
    public Result<String> login() {
        // 支持GET和POST請求
    }
}

@GetMapping("/list")     // 等價(jià)于 @RequestMapping(method = RequestMethod.GET)
@PostMapping("/add")     // 等價(jià)于 @RequestMapping(method = RequestMethod.POST)
@PutMapping("/update")   // 等價(jià)于 @RequestMapping(method = RequestMethod.PUT)
@DeleteMapping("/delete")// 等價(jià)于 @RequestMapping(method = RequestMethod.DELETE)

@PostMapping("/login")
public Result<String> login(@RequestParam String username, 
                            @RequestParam String password) {
    // 請求：POST /user/login?username=admin&password=123456
    // username = "admin"
    // password = "123456"
}

@GetMapping("/list")
public Result<List<Bill>> list(
    @RequestParam(required = false) String keyword,  // 可選參數(shù)
    @RequestParam(defaultValue = "1") Integer page   // 默認(rèn)值
) {
    // 請求：GET /bill/list
    // keyword = null
    // page = 1
}

@PostMapping("/register")
public Result<User> register(@RequestBody User user) {
    // 請求體：{"username":"admin","password":"123456"}
    // 自動(dòng)轉(zhuǎn)換為User對象
    // user.getUsername() = "admin"
    // user.getPassword() = "123456"
}

// 錯(cuò)誤：GET請求不能用@RequestBody
@GetMapping("/list")
public Result<List<Bill>> list(@RequestBody Map<String, Object> params) {
    // GET請求沒有請求體，會(huì)報(bào)錯(cuò)
}
// 正確：GET請求用@RequestParam
@GetMapping("/list")
public Result<List<Bill>> list(@RequestParam String keyword) {
    // 正確
}

@DeleteMapping("/delete/{id}")
public Result<Boolean> delete(@PathVariable Long id) {
    // 請求：DELETE /bill/delete/123
    // id = 123
    billService.deleteById(id);
    return Result.success("刪除成功");
}
@GetMapping("/user/{userId}/bill/{billId}")
public Result<Bill> getBill(@PathVariable Long userId, 
                            @PathVariable Long billId) {
    // 請求：GET /user/10/bill/20
    // userId = 10
    // billId = 20
}

@Controller  // 注意：不是@RestController
@RequestMapping("/user")
public class UserController {
    @GetMapping("/toLogin")
    public String toLogin() {
        return "redirect:/login.html";  // 返回視圖
    }
    @ResponseBody  // 單獨(dú)使用，返回JSON
    @PostMapping("/login")
    public Result<String> login() {
        return Result.success("登錄成功");  // 返回JSON
    }
}

// 實(shí)體類（User.java）
@Data
public class User {
    @NotBlank(message = "用戶名不能為空")
    @Size(min = 3, max = 20, message = "用戶名長度必須在3-20個(gè)字符之間")
    private String username;
    @NotBlank(message = "密碼不能為空")
    @Size(min = 6, max = 10, message = "密碼長度必須在6-10個(gè)字符之間")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d]{6,10}$", 
             message = "密碼必須包含大小寫字母和數(shù)字")
    private String password;
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手機(jī)號(hào)格式不正確")
    private String phone;
}
// 控制器
@PostMapping("/register")
public Result<User> register(@RequestBody @Valid User user) {
    // 如果校驗(yàn)失敗，自動(dòng)返回400錯(cuò)誤，不會(huì)執(zhí)行方法體
    // 如果校驗(yàn)成功，繼續(xù)執(zhí)行
    return userService.register(user);
}

@RestControllerAdvice  // 全局異常處理
public class GlobalExceptionHandler {
    // 處理參數(shù)校驗(yàn)異常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<String> handleValidException(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldError().getDefaultMessage();
        return Result.fail(message);  // 返回：{"code":400,"msg":"用戶名不能為空"}
    }
    // 處理業(yè)務(wù)異常
    @ExceptionHandler(RuntimeException.class)
    public Result<String> handleRuntimeException(RuntimeException e) {
        return Result.fail(e.getMessage());
    }
    // 處理數(shù)據(jù)庫唯一約束異常
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public Result<String> handleSQLException(SQLIntegrityConstraintViolationException e) {
        if (e.getMessage().contains("Duplicate entry")) {
            return Result.fail("數(shù)據(jù)已存在");
        }
        return Result.fail("數(shù)據(jù)庫操作失敗");
    }
}

@Service
@RequiredArgsConstructor//Lombok注解，自動(dòng)生成構(gòu)造器,構(gòu)造器注入，避免字段注入
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;
    @Override
    public User login(String username, String password) {
        // 業(yè)務(wù)邏輯
        User user = userMapper.selectByUsername(username);
        if (user == null) {
            throw new RuntimeException("用戶不存在");
        }
        if (!user.getPassword().equals(password)) {
            throw new RuntimeException("密碼錯(cuò)誤");
        }
        return user;
    }
}

@Service
public class AnnouncementServiceImpl implements AnnouncementService {
    @Transactional  // 開啟事務(wù)
    public void publishAnnouncement(Announcement announcement) {
        // 1. 保存公告
        announcementMapper.insert(announcement);
        // 2. 記錄操作日志
        logMapper.insert(new Log("發(fā)布公告", announcement.getId()));
        // 如果第2步失敗，第1步會(huì)自動(dòng)回滾
    }
}

// 錯(cuò)誤：@Transactional只對public方法有效
@Transactional
private void saveUser(User user) {
    // 事務(wù)不生效
}

// 正確：必須是public方法
@Transactional
public void saveUser(User user) {
    // 事務(wù)生效
}

@Data
@TableName("user")  // 對應(yīng)數(shù)據(jù)庫的user表
public class User {
    private Long userId;
    private String username;
}

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)  // 主鍵自增
    private Long userId;
}

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long userId;
    // 自動(dòng)填充：插入時(shí)填充
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    // 自動(dòng)填充：插入和更新時(shí)都填充
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long userId;
    @Version  // 樂觀鎖
    private Integer version;
}

-- 更新時(shí)自動(dòng)加上version條件
UPDATE user SET username = ?, version = version + 1 
WHERE user_id = ? AND version = ?
-- 如果version不匹配（被其他線程修改了），更新失敗

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long userId;
    @TableLogic  // 邏輯刪除：0=正常，1=已刪除
    private Integer deleted;
}

// 調(diào)用刪除方法
userMapper.deleteById(1);
// 實(shí)際執(zhí)行的SQL（不是真刪除）
UPDATE user SET deleted = 1 WHERE user_id = 1 AND deleted = 0
// 查詢時(shí)自動(dòng)過濾已刪除的數(shù)據(jù)
SELECT * FROM user WHERE deleted = 0

@MapperScan("com.liu.mapper")  // 掃描mapper包下的所有接口
@SpringBootApplication
public class SimpleAccountingApplication {
    public static void main(String[] args) {
        SpringApplication.run(SimpleAccountingApplication.class, args);
    }
}

@Mapper
public interface UserMapper extends BaseMapper<User> {
    @Select("SELECT * FROM user WHERE username = #{username}")
    User selectByUsername(String username);
    @Update("UPDATE user SET status = #{status} WHERE user_id = #{userId}")
    int updateStatus(@Param("userId") Long userId, @Param("status") Integer status);
}

// 多參數(shù)需標(biāo)注@Param
@Select("SELECT * FROM t_user WHERE username = #{name} AND age = #{age}")
User selectByUsernameAndAge(@Param("name") String username, @Param("age") Integer age);

@Aspect
@Component
@Slf4j
public class RoleCheckAspect {
    @Before("@annotation(requireRole)")//在切點(diǎn)之前運(yùn)行的代碼
    public void checkRole(JoinPoint joinPoint, RequireRole requireRole) {
        // 權(quán)限驗(yàn)證邏輯
        int[] allowedRoles = requireRole.value();
        int userRole = TokenHelper.getRole(request);
        boolean hasPermission = Arrays.stream(allowedRoles)
                .anyMatch(role -> role == userRole);
        if (!hasPermission) {
            throw new RuntimeException("無權(quán)限訪問");
        }
    }
}

@Service
public class UserService {
    // 無切面增強(qiáng)的方法
    public void test() {
        this.saveUser(); // 內(nèi)部自調(diào)用，saveUser的切面邏輯失效
    }
    // 有切面增強(qiáng)的方法（如@Transactional/@Around）
    public void saveUser() {
        // 業(yè)務(wù)邏輯
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

import org.springframework.stereotype.Service;
@Service
public class UserService {
    // 正常方法：返回結(jié)果
    public String getUserById(Long id) throws InterruptedException {
        Thread.sleep(80); // 模擬業(yè)務(wù)執(zhí)行耗時(shí)
        return "查詢到用戶ID：" + id;
    }
    // 異常方法：拋出運(yùn)行時(shí)異常
    public void deleteUserById(Long id) {
        throw new RuntimeException("模擬刪除失?。河脩舨淮嬖?);
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.Arrays;
// 1. 標(biāo)記為切面類  2. 注冊為Spring Bean（必須，否則AOP失效）
@Aspect
@Component
public class AopAdviceDemoAspect {
    private static final Logger log = LoggerFactory.getLogger(AopAdviceDemoAspect.class);
    // 定義公共切入點(diǎn)：匹配UserService類的所有公共方法（精準(zhǔn)增強(qiáng)目標(biāo)）
    @Pointcut("execution(public * com.example.demo.service.UserService.*(..))")
    public void userServicePointcut() {
        // 切入點(diǎn)方法：僅做標(biāo)識(shí)，無需編寫任何邏輯
    }
    // ==================== 1. @Before 前置通知 ====================
    @Before("userServicePointcut()")
    public void doBefore(JoinPoint joinPoint) {
        // 獲取方法信息：類名.方法名
        String methodFullName = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
        // 獲取方法入?yún)?
        Object[] args = joinPoint.getArgs();
        // 前置邏輯：記錄方法開始執(zhí)行 + 入?yún)?
        log.info("【@Before 前置通知】方法{}開始執(zhí)行，入?yún)ⅲ簕}", methodFullName, Arrays.toString(args));
    }
    // ==================== 2. @After 最終通知 ====================
    @After("userServicePointcut()")
    public void doAfter(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        // 最終邏輯：標(biāo)記方法執(zhí)行結(jié)束（無論是否異常，都會(huì)打?。?
        log.info("【@After 最終通知】方法{}執(zhí)行結(jié)束（必執(zhí)行）", methodName);
    }
    // ==================== 3. @Around 環(huán)繞通知 ====================
    @Around("userServicePointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // ① 執(zhí)行前邏輯：記錄開始時(shí)間 + 獲取方法信息（等效@Before）
        long startTime = System.currentTimeMillis();
        String methodFullName = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        log.info("【@Around 執(zhí)行前】方法{}入?yún)ⅲ簕}", methodFullName, Arrays.toString(args));
        Object result = null;
        try {
            // ② 手動(dòng)執(zhí)行目標(biāo)方法（核心：必須調(diào)用，否則目標(biāo)方法不執(zhí)行）
            result = joinPoint.proceed();
            // ③ 執(zhí)行成功后邏輯：記錄返回值 + 耗時(shí)
            long costTime = System.currentTimeMillis() - startTime;
            log.info("【@Around 執(zhí)行成功】方法{}返回值：{}，耗時(shí)：{}ms", methodFullName, result, costTime);
        } catch (Throwable e) {
            // ④ 執(zhí)行異常時(shí)邏輯：記錄異常信息 + 耗時(shí)
            long costTime = System.currentTimeMillis() - startTime;
            log.error("【@Around 執(zhí)行異?！糠椒▄}執(zhí)行失敗，耗時(shí)：{}ms，異常：{}", methodFullName, costTime, e.getMessage());
            throw e; // 重新拋出異常，讓全局異常處理器處理（不可省略）
        }
        // ⑤ 返回目標(biāo)方法結(jié)果（核心：必須返回，否則調(diào)用方獲取不到返回值）
        return result;
    }
}

@Aspect
@Component
public class LogAspect {
    // 前置通知：方法執(zhí)行前
    @Before("execution(* com.liu.controller.*.*(..))")
    public void before(JoinPoint joinPoint) {
        log.info("方法執(zhí)行前：{}", joinPoint.getSignature().getName());
    }
    // 后置通知：方法執(zhí)行后
    @After("execution(* com.liu.controller.*.*(..))")
    public void after(JoinPoint joinPoint) {
        log.info("方法執(zhí)行后：{}", joinPoint.getSignature().getName());
    }
    // 環(huán)繞通知：方法執(zhí)行前后
    @Around("execution(* com.liu.controller.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();  // 執(zhí)行方法
        long end = System.currentTimeMillis();
        log.info("方法執(zhí)行耗時(shí)：{}ms", end - start);
        return result;
    }
}

// 1. 定義注解
@Target(ElementType.METHOD)  // 作用在方法上
@Retention(RetentionPolicy.RUNTIME)  // 運(yùn)行時(shí)有效
public @interface RequireRole {
    int[] value() default {};  // 允許的角色
}
// 2. 使用注解
@RestController
@RequestMapping("/admin")
public class AdminController {
    @RequireRole({Constants.ROLE_ADMIN})  // 只允許管理員訪問
    @GetMapping("/users")
    public Result<List<User>> getAllUsers() {
        return Result.success(userService.list());
    }
}
// 3. 切面處理注解
@Aspect
@Component
public class RoleCheckAspect {
    @Before("@annotation(requireRole)")
    public void checkRole(JoinPoint joinPoint, RequireRole requireRole) {
        // 驗(yàn)證權(quán)限
    }
}

<!-- Maven 依賴（與其他 Lombok 注解共用） -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

@Data
public class User {
    private Long userId;
    private String username;
    private String password;
}
// 等價(jià)于手寫：
public class User {
    private Long userId;
    private String username;
    private String password;
    public Long getUserId() { return userId; }
    public void setUserId(Long userId) { this.userId = userId; }
    // ... 其他getter/setter
    @Override
    public String toString() { ... }
    @Override
    public boolean equals(Object o) { ... }
    @Override
    public int hashCode() { ... }
}

@Data
@NoArgsConstructor  // 無參構(gòu)造器
@AllArgsConstructor  // 全參構(gòu)造器
public class User {
    private Long userId;
    private String username;
}
// 等價(jià)于：
public class User {
    public User() {}  // 無參構(gòu)造器
    public User(Long userId, String username) {  // 全參構(gòu)造器
        this.userId = userId;
        this.username = username;
    }
}

@Service
@RequiredArgsConstructor  // 自動(dòng)生成構(gòu)造器
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;  // final修飾,依賴注入
    private final JwtUtil jwtUtil;
    // Lombok自動(dòng)生成：
    // public UserServiceImpl(UserMapper userMapper, JwtUtil jwtUtil) {
    //     this.userMapper = userMapper;
    //     this.jwtUtil = jwtUtil;
    // }
}

@Service
@Slf4j  // 自動(dòng)生成log對象
public class UserServiceImpl implements UserService {
    public User login(String username, String password) {
        log.info("用戶登錄：{}", username);  // 直接使用log
        log.error("登錄失敗：{}", username);
        log.debug("調(diào)試信息：{}", username);
    }
}
// 等價(jià)于：
public class UserServiceImpl implements UserService {
    private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
}

@Data
@Builder
public class User {
    private Long userId;
    private String username;
    private String password;
}
// 使用：
User user = User.builder()
    .userId(1L)
    .username("admin")
    .password("123456")
    .build();

@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
@Slf4j
public class UserController {
    private final UserService userService;
    @PostMapping("/login")
    public Result<String> login(@RequestParam String username, 
                                @RequestParam String password) {
        log.info("用戶登錄：{}", username);
        return userService.login(username, password);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long userId;
    @NotBlank(message = "用戶名不能為空")
    private String username;
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    @Version
    private Integer version;
    @TableLogic
    private Integer deleted;
}

@Service
@RequiredArgsConstructor
@Slf4j
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;
    @Transactional
    public void saveUser(User user) {
        log.info("保存用戶：{}", user.getUsername());
        userMapper.insert(user);
    }
}

// 錯(cuò)誤：沒有@Service注解，Spring不會(huì)管理這個(gè)類
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;  // 注入失敗，userMapper為null
}
// 正確：加上@Service
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;  // 注入成功
}

// 錯(cuò)誤：UserMapper沒有被Spring管理
public interface UserMapper {  // 缺少@Mapper注解
    User selectById(Long id);
}
// 正確：加上@Mapper或在啟動(dòng)類加@MapperScan
@Mapper
public interface UserMapper {
    User selectById(Long id);
}

// 錯(cuò)誤：private方法，事務(wù)不生效
@Transactional
private void saveUser(User user) {
    userMapper.insert(user);
}
// 正確：必須是public方法
@Transactional
public void saveUser(User user) {
    userMapper.insert(user);
}

// 錯(cuò)誤：不能同時(shí)使用
@PostMapping("/add")
public Result<Boolean> add(@RequestBody Bill bill, 
                           @RequestParam Long userId) {
    // 報(bào)錯(cuò)
}
// 正確：要么全用@RequestBody，要么全用@RequestParam
@PostMapping("/add")
public Result<Boolean> add(@RequestBody Map<String, Object> params) {
    Long userId = (Long) params.get("userId");
    Bill bill = (Bill) params.get("bill");
}