// ========== 1. 业务接口（规范核心方法） ==========
interface UserService {
    // 核心业务方法：登录校验
    boolean login(String username, String password);
}

// ========== 2. 真实实现类（目标类：只做核心业务） ==========
public class UserServiceImpl implements UserService {
    // 仅实现核心登录逻辑，无任何非业务代码
    @Override
    public boolean login(String username, String password) {
         System.out.println("UserServiceImpl - login username=" + username + " password=" + password);
        // 核心业务：判断账号密码是否正确
        return "admin".equals(username) && "123456".equals(password);
    }
}

// ========== 3. 静态代理类（替目标类执行，加增强逻辑） ==========
public class UserServiceStaticProxy implements UserService {
    // 持有目标对象（代理的核心：关联真实业务类）
    private UserService target = new UserServiceImpl();

    // 代理目标方法，包裹增强逻辑
    @Override
    public boolean login(String username, String password) {
        // 增强逻辑1：方法执行前（如打印入参日志）
        System.out.println("Before login: username = " + username);
        
        // 调用真实目标类的核心方法
        boolean result = target.login(username, password);
        
        // 增强逻辑2：方法执行后（如打印结果日志）
        System.out.println("After login: result = " + result);
        
        return result;
    }
}

// ========== 4. 测试调用（仅接触代理类，不直接调目标类） ==========
public class TestStaticProxy {
    public static void main(String[] args) {
        // 创建代理对象（而非直接new UserServiceImpl）
        UserService proxy = new UserServiceStaticProxy();
        
        // 调用代理方法（自动触发增强+核心业务）
        proxy.login("admin", "123456");
    }
}

// ========== 1. 业务接口（JDK动态代理必须依赖接口） ==========
interface UserService {
    boolean login(String username, String password);
}

// ========== 2. 目标类（实现接口，仅做核心业务） ==========
public class UserServiceImpl implements UserService {
    @Override
    public boolean login(String username, String password) {
        // 核心业务：登录校验
        return "admin".equals(username) && "123456".equals(password);
    }
}

// ========== 3. JDK动态代理核心：通用增强逻辑 + 生成代理 ==========
public class JdkDynamicProxyDemo {
    public static void main(String[] args) {
        // 步骤1：创建目标对象
        UserService target = new UserServiceImpl();
        
        // 步骤2：生成动态代理对象（运行时自动创建代理类，无需手动写）
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 类加载器
                target.getClass().getInterfaces(),  // 目标类实现的接口（核心）
                (proxyObj, method, argsArr) -> {    // 增强逻辑（InvocationHandler）
                    // 增强逻辑1：方法执行前（如打印日志）
                    System.out.println("Before " + method.getName() + ": " + argsArr[0]);
                    
                    // 调用目标类的核心方法
                    Object result = method.invoke(target, argsArr);
                    
                    // 增强逻辑2：方法执行后（如打印结果）
                    System.out.println("After " + method.getName() + ": " + result);
                    
                    return result;
                }
        );
        
        // 步骤3：调用代理方法（自动触发增强+核心业务）
        proxy.login("admin", "123456");
    }
}

        <dependency>
            <groupId>cglib</groupId>   <!-- 核心代理库 -->
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>    <!-- 推荐使用最新稳定版 -->
        </dependency>

// ========== 1. 目标类（无需实现接口，仅做核心业务） ==========
class UserService {
    public boolean login(String username, String password) {
        // 核心业务：登录校验
        return "admin".equals(username) && "123456".equals(password);
    }
}

// ========== 2. CGLIB动态代理核心：通用增强逻辑 + 生成代理 ==========
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
public class CglibDynamicProxyDemo {
    public static void main(String[] args) {
        // 步骤1：创建目标对象
        UserService target = new UserService();
        
        // 步骤2：生成动态代理对象（运行时自动创建代理类，继承目标类）
        UserService proxy = (UserService) Enhancer.create(
                UserService.class,  // 目标类的Class对象（核心：继承目标类）
                (MethodInterceptor) (proxyObj, method, argsArr, methodProxy) -> {
                    // 增强逻辑1：方法执行前（如打印日志）
                    System.out.println("Before " + method.getName() + ": " + argsArr[0]);
                    
                    // 调用目标类的核心方法
                    Object result = methodProxy.invoke(target, argsArr);
                    
                    // 增强逻辑2：方法执行后（如打印结果）
                    System.out.println("After " + method.getName() + ": " + result);
                    
                    return result;
                }
        );
        
        // 步骤3：调用代理方法（自动触发增强+核心业务）
        proxy.login("admin", "123456");
    }
}

Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass(...) accessible:
module java.base does not "opens java.lang" to unnamed module
关键机制：从 Java 9 开始引入的模块系统（JPMS）对反射做了严格限制。
具体表现：CGLIB 尝试通过反射调用 ClassLoader.defineClass() 方法来动态生成类，但该方法属于 java.lang 包且未被暴露给“未命名模块”（即你的普通 Java 项目）。
添加 JVM 启动参数（最直接有效）: --add-opens java.base/java.lang=ALL-UNNAMED

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

public interface Calculator {
    
    int add(int i, int j);
    
    int sub(int i, int j);
    
    int mul(int i, int j);
    
    int div(int i, int j);
}

@Component
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        int result = i / j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
}

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入 IoC 容器
@Component
public class LogAspect {
        
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
    public void printLogBeforeCore() {
        System.out.println("[AOP前置通知] 方法开始了");
    }
    
    @AfterReturning(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
    public void printLogAfterSuccess() {
        System.out.println("[AOP返回通知] 方法成功返回了");
    }
    
    @AfterThrowing(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
    public void printLogAfterException() {
        System.out.println("[AOP异常通知] 方法抛异常了");
    }
    
    @After(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
    public void printLogFinallyEnd() {
        System.out.println("[AOP后置通知] 方法最终结束了");
    }
    
}

@SpringBootTest
public class AOPTest {
    
    @Autowired
    private Calculator calculator;
    
    @Test
    public void testAnnotationAOP() {
    
        int add = calculator.add(10, 2);
        System.out.println("方法外部 add = " + add);
    
    }
    
}

# application.properties
spring.aop.proxy-target-class=false # 覆盖默认值true，强制有接口时使用JDK动态代理

// @Before注解标记前置通知方法
// value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
// 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
// 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
@Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
public void printLogBeforeCore(JoinPoint joinPoint) {
    
    // 1.通过JoinPoint对象获取目标方法签名对象
    // 方法的签名：一个方法的全部声明信息
    Signature signature = joinPoint.getSignature();
    
    // 2.通过方法的签名对象获取目标方法的详细信息
    String methodName = signature.getName();
    System.out.println("methodName = " + methodName);
    
    int modifiers = signature.getModifiers();
    System.out.println("modifiers = " + modifiers);
    
    String declaringTypeName = signature.getDeclaringTypeName();
    System.out.println("declaringTypeName = " + declaringTypeName);
    
    // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
    Object[] args = joinPoint.getArgs();
    
    // 4.由于数组直接打印看不到具体数据，所以转换为List集合
    List<Object> argList = Arrays.asList(args);
    
    System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + argList);
}

// @AfterReturning注解标记返回通知方法
// 在返回通知中获取目标方法返回值分两步：
// 第一步：在@AfterReturning注解中通过returning属性设置一个名称
// 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
@AfterReturning(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        returning = "targetMethodReturnValue"
)
public void printLogAfterCoreSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);
}

// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        throwing = "targetMethodException"
)
public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
}

public private 直接描述对应修饰符即可

int String void 直接描述返回值类型
注意：
特殊情况 不考虑 访问修饰符和返回值
execution("* *"") 这是错误语法
execution("*") == 你只要考虑返回值 或者 不考虑访问修饰符 相当于全部不考虑了

固定的包: com.atguigu.api | service | dao
单层的任意命名: com.atguigu.*  = com.atguigu.api  com.atguigu.dao  * = 任意一层的任意命名
任意层任意命名: com.. = com.atguigu.api.erdaye com.a.a.a.a.a.a.a  ..任意层,任意命名 用在包上!
注意: ..不能用作包开头   public int .. 错误语法  com..
找到任何包下: *..

固定名称: UserService
任意类名: *
部分任意: com..service.impl.*Impl
任意包任意类: *..*

语法和类名一致
任意访问修饰符,任意类的任意方法: * *..*.*

具体值: (String,int) != (int,String) 没有参数 ()
模糊值: 任意参数 有 或者 没有 (..)  ..任意参数的意识
部分具体和模糊:
第一个参数是字符串的方法 (String..)
最后一个参数是字符串 (..String)
字符串开头,int结尾 (String..int)
包含int类型(..int..)

1.查询某包某类下，访问修饰符是公有，返回值是int的全部方法
2.查询某包下类中第一个参数是String的方法
3.查询全部包下，无参数的方法！
4.查询com包下，以int参数类型结尾的方法
5.查询指定包下，Service开头类的私有返回值int的无参数方法

// 切入点表达式重用
@Pointcut("execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
public void declarePointCut() {}

@Before(value = "declarePointCut()")
public void printLogBeforeCoreOperation(JoinPoint joinPoint) {

@Around(value = "com.atguigu.spring.aop.aspect.LogAspect.declarePointCut()")
public Object roundAdvice(ProceedingJoinPoint joinPoint) {

@Component
public class AtguiguPointCut {
    
    @Pointcut(value = "execution(public int *..Calculator.sub(int,int))")
    public void atguiguGlobalPointCut(){}
    
    @Pointcut(value = "execution(public int *..Calculator.add(int,int))")
    public void atguiguSecondPointCut(){}
    
    @Pointcut(value = "execution(* *..*Service.*(..))")
    public void transactionPointCut(){}
}

// 使用@Around注解标明环绕通知方法
@Around(value = "com.atguigu.aop.aspect.AtguiguPointCut.transactionPointCut()")
public Object manageTransaction(
    
        // 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，
        // Spring会将这个类型的对象传给我们
        ProceedingJoinPoint joinPoint) {
    
    // 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组
    Object[] args = joinPoint.getArgs();
    
    // 通过ProceedingJoinPoint对象获取目标方法的签名对象
    Signature signature = joinPoint.getSignature();
    
    // 通过签名对象获取目标方法的方法名
    String methodName = signature.getName();
    
    // 声明变量用来存储目标方法的返回值
    Object targetMethodReturnValue = null;
    
    try {
    
        // 在目标方法执行前：开启事务（模拟）
        System.out.println("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));
    
    // 通过ProceedingJoinPoint对象调用目标方法
        // 目标方法的返回值一定要返回给外界调用者
        targetMethodReturnValue = joinPoint.proceed(args);
    
        // 在目标方法成功返回后：提交事务（模拟）
        System.out.println("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + targetMethodReturnValue);
    
    }catch (Throwable e){
    
        // 在目标方法抛异常后：回滚事务（模拟）
        System.out.println("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());
    
    }finally {
    
        // 在目标方法最终结束后：释放数据库连接
        System.out.println("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);
    
    }
    
    return targetMethodReturnValue;
}

-- 方法访问统计表
CREATE TABLE IF NOT EXISTS sys_method_stat (
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    method_name VARCHAR(100) NOT NULL COMMENT '方法名（如login、saveUser）',
    visit_count INT NOT NULL DEFAULT 0 COMMENT '访问次数',
    total_time BIGINT NOT NULL DEFAULT 0 COMMENT '总耗时（毫秒）',
    avg_time DECIMAL(10,2) NOT NULL DEFAULT 0.00 COMMENT '平均耗时（毫秒）',
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id),
    UNIQUE KEY uk_method_name (method_name) COMMENT '方法名唯一'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='方法访问统计表';

/**
 * 方法访问统计实体
 */
@Data
@TableName("sys_method_stat")
public class SysMethodStat {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String methodName; // 方法名
    private Integer visitCount; // 访问次数
    private Long totalTime; // 总耗时（毫秒）
    private BigDecimal avgTime; // 平均耗时（毫秒）
    private Date updateTime; // 更新时间
}

package com.example.aopdemo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.aopdemo.entity.SysMethodStat;

/**
 * 方法统计Mapper
 */
@Mapper
public interface SysMethodStatMapper extends BaseMapper<SysMethodStat> {
}

package com.example.aopdemo.service;
/**
 * 方法统计Service接口
 */
public interface SysMethodStatService extends IService<SysMethodStat> {
    // 根据方法名查询统计数据
    SysMethodStat getByMethodName(String methodName);

    // 更新方法统计数据
    void updateStat(String methodName, long costTime);

    // 查询全部统计列表（按访问次数降序、平均耗时降序）
    List<SysMethodStat> listAllStat();
}

package com.example.aopdemo.service.impl;
/**
 * 方法统计Service实现
 */
@Service
public class SysMethodStatServiceImpl extends ServiceImpl<SysMethodStatMapper, SysMethodStat> implements SysMethodStatService {

    @Override
    public SysMethodStat getByMethodName(String methodName) {
        LambdaQueryWrapper<SysMethodStat> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysMethodStat::getMethodName, methodName);
        return this.getOne(wrapper);
    }

    @Override
    public void updateStat(String methodName, long costTime) {
        // 查询该方法的统计记录
        SysMethodStat stat = this.getByMethodName(methodName);

        if (stat == null) {
            // 无记录：新增
            stat = new SysMethodStat();
            stat.setMethodName(methodName);
            stat.setVisitCount(1);
            stat.setTotalTime(costTime);
            stat.setAvgTime(new BigDecimal(costTime).setScale(2, RoundingMode.HALF_UP));
            this.save(stat);
        } else {
            // 有记录：更新
            stat.setVisitCount(stat.getVisitCount() + 1);
            stat.setTotalTime(stat.getTotalTime() + costTime);
            // 计算平均耗时
            BigDecimal avg = new BigDecimal(stat.getTotalTime())
                    .divide(new BigDecimal(stat.getVisitCount()), 2, RoundingMode.HALF_UP);
            stat.setAvgTime(avg);
            this.updateById(stat);
        }
    }

    @Override
    public List<SysMethodStat> listAllStat() {
        LambdaQueryWrapper<SysMethodStat> wrapper = new LambdaQueryWrapper<>();
        // 排序：访问次数降序 → 平均耗时降序
        wrapper.orderByDesc(SysMethodStat::getVisitCount)
               .orderByDesc(SysMethodStat::getAvgTime);
        return this.list(wrapper);
    }
}

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

package com.example.aopdemo.aop;
/**
 * UserService方法访问统计切面
 */
@Aspect
@Component
public class UserServiceStatAspect {

    @Autowired
    private SysMethodStatService statService;

    // 定义切入点：切入SysMethodStatService的所有方法。注意包名别写错。目标类包名哦。
    @Pointcut("execution(* com.example.aopdemo.service.UserService.*(..))")
    public void userServicePointcut() {}

    // 环绕通知：统计方法耗时并更新数据库
    @Around("userServicePointcut()")
    public Object statMethodTime(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行目标方法
        Object result = joinPoint.proceed();
        // 计算耗时
        long costTime = System.currentTimeMillis() - startTime;
        // 更新统计数据
        statService.updateStat(methodName, costTime);
        // 返回结果
        return result;
    }
}

/**
 * 方法统计查询Controller
 */
@RestController
@RequestMapping("/stat")
public class MethodStatController {

    @Autowired
    private SysMethodStatService statService;

    // 根据方法名查询
    @GetMapping("/method")
    public Result getStatByMethod(String methodName) {
        SysMethodStat stat = statService.getByMethodName(methodName);
        if (stat == null) {
            return Result.fail("该方法暂无统计数据");
        }
        return Result.success("查询成功", stat);
    }

    // 查询全部统计列表
    @GetMapping("/all-list")
    public Result getAllMethodStatList() {
        List<SysMethodStat> statList = statService.listAllStat();
        if (statList.isEmpty()) {
            return Result.success("暂无方法访问统计数据", statList);
        }
        return Result.success("查询全部方法统计数据成功，共" + statList.size() + "条", statList);
    }
}

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>UserService方法访问统计</title>
    <style>
        table {width: 80%; margin: 20px auto; border-collapse: collapse;}
        th, td {border: 1px solid #ccc; padding: 10px; text-align: center;}
        th {background-color: #f5f5f5;}
        .title {text-align: center; margin-top: 20px; font-size: 20px; font-weight: bold;}
    </style>
</head>
<body>
    <div class="title">UserService方法访问统计</div>
    <table>
        <thead>
            <tr>
                <th>方法名</th>
                <th>访问次数</th>
                <th>总耗时(毫秒)</th>
                <th>平均耗时(毫秒)</th>
                <th>最后更新时间</th>
            </tr>
        </thead>
        <tbody id="statTable">
            <!-- 数据由JS动态填充 -->
        </tbody>
    </table>

    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
    <script>
        // 页面加载后查询统计数据
        $(function() {
            $.get("/stat/all-list", function(res) {
                if (res.code === 200) {
                    let html = "";
                    res.data.forEach(item => {
                        html += `<tr>
                            <td>${item.methodName}</td>
                            <td>${item.visitCount}</td>
                            <td>${item.totalTime}</td>
                            <td>${item.avgTime}</td>
                            <td>${formatTime(item.updateTime)}</td>
                        </tr>`;
                    });
                    $("#statTable").html(html);
                } else {
                    $("#statTable").html(`<tr><td colspan="5">${res.message}</td></tr>`);
                }
            });
        });

        // 时间格式化
        function formatTime(timeStr) {
            if (!timeStr) return "";
            let date = new Date(timeStr);
            return date.toLocaleString();
        }
    </script>
</body>
</html>

// 订单服务类
@Service
public class OrderService {
    @Autowired
    private OrderLogService orderLogService;

    // 外层方法A：创建订单（标记REQUIRED事务，默认可省略）
    @Transactional(propagation = Propagation.REQUIRED)
    public void createOrder(String orderNo) {
        try {
            // 1. 核心业务：创建订单（数据库操作）
            System.out.println("执行：创建订单 " + orderNo);
            // 2. 嵌套调用：记录订单日志（方法B）
            orderLogService.recordLog(orderNo);
            // 模拟：订单创建失败（抛出异常）
            throw new RuntimeException("订单创建失败！");
        } catch (Exception e) {
            // 异常触发事务回滚
            throw e;
        }
    }
}

// 订单日志服务类
@Service
public class OrderLogService {
    // 内层方法B：记录订单日志（REQUIRED）
    @Transactional(propagation = Propagation.REQUIRED)
    public void recordLog(String orderNo) {
        // 业务：记录订单操作日志（数据库操作）
        System.out.println("执行：记录订单" + orderNo + "的日志");
    }
}

// 订单服务类（同案例1，仅方法B传播行为修改）
@Service
public class OrderService {
    @Autowired
    private OrderLogService orderLogService;

    // 外层方法A：创建订单（REQUIRED）
    @Transactional(propagation = Propagation.REQUIRED)
    public void createOrder(String orderNo) {
        try {
            System.out.println("执行：创建订单 " + orderNo);
            orderLogService.recordLog(orderNo); // 调用方法B
            throw new RuntimeException("订单创建失败！"); // 模拟异常
        } catch (Exception e) {
            throw e;
        }
    }
}

// 订单日志服务类（修改方法B的传播行为为REQUIRES_NEW）
@Service
public class OrderLogService {
    // 内层方法B：记录日志（REQUIRES_NEW → 新建独立事务）
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void recordLog(String orderNo) {
        System.out.println("执行：记录订单" + orderNo + "的日志");
        // 该方法的事务会独立提交，不受外层影响
    }
}

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.5</version>
    <relativePath/> <!-- 从Maven仓库查找父工程，不依赖本地路径 -->
</parent>

<!-- Web开发场景：包含 Spring MVC、内置 Tomcat、JSON 解析等核心依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 测试场景：包含JUnit、SpringTest等测试工具，仅测试环境生效 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<!-- JDBC操作场景：包含数据源、JDBC模板等核心依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

/**
 * Spring Boot 主启动类（工程入口）
 * @SpringBootApplication：核心注解，整合3个关键能力：
 * 1. @SpringBootConfiguration：标识为配置类（底层是@Configuration）；
 * 2. @EnableAutoConfiguration：开启自动配置（核心！自动创建场景所需Bean）；
 * 3. @ComponentScan：开启组件扫描（默认扫描主启动类所在包及子包）。
 */
@SpringBootApplication
public class Module33DemoMainType {
    // 启动 Spring Boot 应用：加载 IoC 容器，启动内置服务器（如Tomcat）
    public static void main(String[] args) {
        SpringApplication.run(Module33DemoMainType.class, args);
    }
}

@SpringBootApplication
// 手动指定扫描路径：仅扫描controller包（多路径用数组{"包1","包2"}）
@ComponentScan("com.atguigu.demo.controller")
public class Module33DemoMainType {
    public static void main(String[] args) {
        SpringApplication.run(Module33DemoMainType.class, args);
    }
}

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

<!-- 覆盖父工程的MySQL驱动版本 -->
<properties>
    <mysql.version>8.0.33</mysql.version>
</properties>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <!-- 无需写version，自动使用上面定义的8.0.33 -->
</dependency>

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

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot!";
    }
}

# 这是一个YAML配置文件示例
# 键值对（映射）
server:
  host: localhost
  port: 8080
  enabled: true

# 列表（数组）
libraries:
  - spring-boot
  - hibernate
  - junit

# 嵌套结构
database:
  type: mysql
  credentials:
    username: root
    password: secret
  options:
    timeout: 3000
    retries: 3

# 多行字符串
description: |
  这是一个多行描述
  可以包含换行和特殊字符
  如: " ' @ # $ %

# 布尔值、空值和数字
isDebug: false
maxConnections: 100
nullValue: null

# 主配置文件（存放所有环境共享的配置）
spring:
  application:
    name: module44-SpringBoot-Usage  # 应用名称（所有环境共用）
  profiles:
    active: dev  # 激活开发环境（可改为test/prod快速切换）多个用 , 隔开即可

# 启动时激活测试环境
java -jar module44-SpringBoot-Usage.jar --spring.profiles.active=test

# 启动时激活生产环境
java -jar module44-SpringBoot-Usage.jar --spring.profiles.active=prod

<build>
    <plugins>
        <!-- Spring Boot 专属打包插件：生成可直接启动的JAR包 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

# 基础启动（前台运行，关闭命令行则应用停止）
java -jar 【JAR包路径】/xxx.jar

# 示例：启动当前目录下的module44-SpringBoot-Usage.jar
java -jar module44-SpringBoot-Usage.jar

java -jar -Dprofile=参数 xxx.jar # 运行时可以指定环境或者参数；System.getProperty("profile") 读取

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

# 暴露所有Web端点
management.endpoints.web.exposure.include=*
# 自定义端口（默认8080），这里是获取监控数据的端口
management.server.port=8081
# 自定义访问路径（默认/actuator）
management.endpoints.web.base-path=/monitor

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

@SpringBootTest(classes = Day21SsmApplication.class)
public class TestSlf4j {
    
    //内置的日志记录器:log
    Logger log = LoggerFactory.getLogger(TestSlf4j.class);

    @Test
    public void testSlf4j(){
        // 创建日志记录器
        log.info("日志记录器创建成功");
        // 记录日志
        log.trace("追踪信息trace");
        log.debug("调试信息debug");
        log.info("普通信息info");
        log.warn("警告信息warn");
        log.error("错误信息error");

    }
}

import lombok.extern.slf4j.Slf4j;
@Slf4j
@SpringBootTest(classes = Day21SsmApplication.class)
public class TestSlf4j {
    
    @Test
    public void testSlf4j(){
        // 创建日志记录器
        log.info("日志记录器创建成功");
        // 记录日志
        log.trace("追踪信息trace");
        log.debug("调试信息debug");
        log.info("普通信息info");
        log.warn("警告信息warn");
        log.error("错误信息error");
    }
}

// 示例：判断当前系统是否为Windows
public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取环境变量，判断系统类型
        String os = context.getEnvironment().getProperty("os.name");
        return os != null && os.toUpperCase().contains("WINDOWS");
    }
}

// 示例：判断数字是否为偶数
public class NumberCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return 101 % 2 == 0; // 条件不满足（返回false）
    }
}

// 单条件：仅Windows系统时，TigerComp才注册到IoC
@Component
@Conditional(WindowsCondition.class)
public class TigerComp {}

// 多条件：需同时满足Windows系统 + 数字偶数，MyConditionController才注册
@Controller
@Conditional({WindowsCondition.class, NumberCondition.class})
public class MyConditionController {}

public static void main(String[] args) {

    ApplicationContext ioc = SpringApplication.run(MainApplication.class, args);

    //1、获取容器中所有组件的名字
    String[] names = ioc.getBeanDefinitionNames();
    //2、挨个遍历：
    // dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver
    // Spring Boot 把以前配置的核心组件现在都给我们自动配置好了。
    for (String name : names) {
        System.out.println(name);
    }
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
        <version>3.3.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <version>3.3.12</version>
        <optional>true</optional>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>3.3.12</version>
        </plugin>
    </plugins>
</build>

@ConfigurationProperties(prefix = "atguigu")
public class AgeProperties {
    
    private String birthday;

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

public class AgeService {

    public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private final String birthday;

    public AgeService(String birthday) {
        this.birthday = birthday;
    }

    public int computeAgeByBirthday() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DATE_TIME_FORMAT);
        LocalDate birthDate = LocalDate.parse(birthday, formatter);
        LocalDate currentDate = LocalDate.now();

        // 检查生日是否在当前日期之后
        if (birthDate.isAfter(currentDate)) {
            return -1; // 无效的生日
        }

        // 计算年龄
        Period period = Period.between(birthDate, currentDate);
        return period.getYears();
    }
}

package com.atguigu.starter.config;

import com.atguigu.starter.service.AgeService;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 将当前类声明为配置类
@Configuration

// 如果当前类路径下有 AgeService 这个类，就把当前类加入 IoC 容器
// 当前类路径下怎么才能有 AgeService？引入我们正在开发的这个 starter 的依赖即可
@ConditionalOnClass(AgeService.class)

// 注册属性组件，Spring Boot 会读取用户在配置文件中指定的生日字符串，注入属性组件
@EnableConfigurationProperties(AgeProperties.class)
public class AgeAutoConfiguration {

    private final AgeProperties ageProperties;

    // 基于构造器装配，把属性组件注入进来
    public AgeAutoConfiguration(AgeProperties ageProperties) {
        this.ageProperties = ageProperties;
    }

    @Bean
    // Missing 单词：丢失、遗漏、找不到
    // MissingBean 单词：IoC 容器中没有这个 bean
    // @ConditionalOnMissingBean 条件注解：当 IoC 容器中没有 AgeService 这个 bean 时，才把当前方法返回的对象加入 IoC 容器
    // 提问：IoC 容器中为啥会有 AgeService 这个 bean 呢？
    // 答：开发人员有可能自己把它加入 IoC 容器
    @ConditionalOnMissingBean
    public AgeService ageService() {
        // 创建业务组件对象的同时，把生日字符串传入进去
        return new AgeService(ageProperties.getBirthday());
    }
}

com.atguigu.starter.config.AgeAutoConfiguration

{
  "properties": [
    {
      "name": "atguigu.birthday",
      "type": "java.lang.String",
      "description": "Your birthday",
      "defaultValue": "2025-10-21 13:27:54"
    }
  ]
}

<dependency>
    <groupId>com.atguigu.starter</groupId>
    <artifactId>atguigu-pre-age-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

atguigu.birthday=2020-10-25 23:14:26

@Resource
private AgeService ageService;

@Test
public void testComputeAge() {
    int age = ageService.computeAgeByBirthday();
    System.out.println("age = " + age);
}

// 普通组件类（无特殊配置，默认单例）
@Component
public class Demo13Comp {
}

// 测试代码
Object demo13Comp01 = ioc.getBean("demo13Comp");
Object demo13Comp02 = ioc.getBean("demo13Comp");
// 输出true：两次获取的是同一个对象
System.out.println("比较两个变量：" + (demo13Comp01 == demo13Comp02));

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {
    @AliasFor("scopeName")
    String value() default "";

    @AliasFor("value")
    String scopeName() default "";

    ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
}

@Component
@Scope("singleton") // 默认值，可省略
public class Demo13Comp {
    public Demo13Comp() {
        System.out.println("★★★★★★★★★★★Demo13Comp 类创建了对象★★★★★★★★★★★");
    }
}

@Component
@Scope("prototype") // 指定多实例
public class Demo13Comp {
    public Demo13Comp() {
        System.out.println("★★★★★★★★★★★Demo13Comp 类创建了对象★★★★★★★★★★★");
    }
}

// 核心：通过@Component注册Bean，替代XML配置
@Component
public class MyBean {
    // 自定义初始化方法（命名随意，无参数、void返回、public修饰）
    @PostConstruct // 替代XML的init-method
    public void start() {
        System.out.println("✅ Bean初始化方法执行");
    }

    // 自定义销毁方法（命名随意，无参数、void返回、public修饰）
    @PreDestroy // 替代XML的destroy-method
    public void end() {
        System.out.println("❌ Bean销毁方法执行");
    }
}

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

// 替代XML的<beans>标签，扫描指定包下的注解组件
@Configuration
@ComponentScan("com.atguigu.lifecycle") // 扫描MyBean所在包
public class LifecycleConfig {
}

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestLifecycle {
    public static void main(String[] args) {
        // 初始化容器（替代XML加载）
        AnnotationConfigApplicationContext context = 
            new AnnotationConfigApplicationContext(LifecycleConfig.class);
        
        // 获取Bean（触发初始化）
        MyBean myBean = context.getBean(MyBean.class);
        
        // 关闭容器（触发单例Bean销毁）
        context.close();
    }
}

public class Goods {
    private Integer saasId;
    public void setSaasId(Integer saasId) { this.saasId = saasId; }
    // ...其他属性和方法
}

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor：修改Bean定义");
        // 获取指定Bean的定义信息
        BeanDefinition goodsDef = beanFactory.getBeanDefinition("goods");
        // 动态修改属性值
        goodsDef.getPropertyValues().addPropertyValue("saasId", 1);
    }
}

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    // Bean初始化前执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化前：bean=" + bean + ", beanName=" + beanName);
        return bean; // 返回原Bean或包装后的Bean
    }

    // Bean初始化后执行（AOP核心扩展点）
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化后：bean=" + bean + ", beanName=" + beanName);
        // 示例：返回代理对象（模拟AOP）
        return new Goods(); 
    }
}

@Aspect
@Component
public class LogAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前置通知：记录入参和开始时间
        long start = System.currentTimeMillis();
        Object[] args = joinPoint.getArgs();
        System.out.println("方法入参：" + Arrays.toString(args));
        // 执行原方法
        Object result = joinPoint.proceed();
        // 后置通知：记录出参和耗时
        long end = System.currentTimeMillis();
        System.out.println("方法出参：" + result + "，耗时：" + (end - start) + "ms");
        return result;
    }
}

@Aspect
@Component
public class TransactionAspect {
    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object transactionAround(ProceedingJoinPoint joinPoint) throws Throwable {
        Connection conn = getConnection();
        try {
            conn.setAutoCommit(false); // 开启事务
            Object result = joinPoint.proceed(); // 执行业务方法
            conn.commit(); // 提交事务
            return result;
        } catch (Exception e) {
            conn.rollback(); // 回滚事务
            throw e;
        } finally {
            conn.close();
        }
    }
}

@Aspect
@Component
public class AuthAspect {
    @Before("execution(* com.example.controller.*.*(..)) && @annotation(NeedAuth)")
    public void checkAuth(JoinPoint joinPoint) {
        // 校验用户权限，无权限则抛异常
        if (!hasPermission()) {
            throw new NoAuthException("无访问权限");
        }
    }
}

@Aspect
@Component
public class ExceptionAspect {
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "e")
    public void handleException(JoinPoint joinPoint, Exception e) {
        System.out.println("方法" + joinPoint.getSignature().getName() + "抛出异常：" + e.getMessage());
        // 异常入库/告警等处理
    }
}