@Component
public class LifecycleBean implements BeanNameAware, InitializingBean, DisposableBean {

    public LifecycleBean() {
        System.out.println("1. Constructor");
    }

    @Autowired
    public void setDependency(Dependency dep) {
        System.out.println("2. 属性注入");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware: " + name);
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("4. @PostConstruct");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("5. InitializingBean.afterPropertiesSet()");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("8. @PreDestroy");
    }

    @Override
    public void destroy() {
        System.out.println("8. DisposableBean.destroy()");
    }
}

public interface BeanPostProcessor {
    // 初始化前调用（@PostConstruct 之前）
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    // 初始化后调用（@PostConstruct 之后）← 最常用
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

// 方式1: BeforeInitialization (侵入框架层, 影响所有Bean)
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    if (bean instanceof UserService) {
        ((UserService) bean).validate(); // 校验
    }
    return bean;
}

// 方式2: @PostConstruct (只影响自己, 简单直接)
@PostConstruct
public void init() {
    validate(); // 同样效果, 代码在身边, 更好维护
}

@Component
public class MyAutoProxyCreator implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean.getClass().isAnnotationPresent(MyAspect.class)) {
            return createProxy(bean);
        }
        return bean;
    }
}

@Component
public class ApiCheckProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        for (Field field : bean.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(RequiredConfig.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value == null) {
                        throw new IllegalStateException(
                                beanName + "." + field.getName() + " 未配置必填项");
                    }
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return bean;
    }
}

@Component
public class DataSourceProxyProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof DataSource && !"masterDataSource".equals(beanName)) {
            return new DynamicDataSourceProxy((DataSource) bean);
        }
        return bean;
    }
}

@Component
public class ServiceMonitorProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean.getClass().isAnnotationPresent(Service.class)) {
            return Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    long start = System.currentTimeMillis();
                    try {
                        return method.invoke(bean, args);
                    } finally {
                        long cost = System.currentTimeMillis() - start;
                        if (cost > 500) {
                            log.warn("慢调用：{}.{} cost={}ms",
                                beanName, method.getName(), cost);
                        }
                    }
                }
            );
        }
        return bean;
    }
}

@Component
public class SensitiveDataProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof UserService) {
            return Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    Object result = method.invoke(bean, args);
                    if (result instanceof UserVO) {
                        desensitize((UserVO) result);
                    }
                    return result;
                }
            );
        }
        return bean;
    }

    private void desensitize(UserVO user) {
        user.setPhone(user.getPhone().replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2"));
        user.setIdCard(user.getIdCard().replaceAll("(\\d{4})\\d{10}(\\d{4})", "$1**********$2"));
    }
}

public void createOrder() {
    log.info("开始创建订单");             // ← 日志
    checkPermission();                     // ← 权限
    TransactionManager.begin();            // ← 事务
    try {
        orderDao.save(order);              // ← 真正的业务
        TransactionManager.commit();       // ← 事务
    } catch (Exception e) {
        TransactionManager.rollback();     // ← 事务
        throw e;
    }
    log.info("订单创建完成");               // ← 日志
    metrics.record("order.create", cost);  // ← 监控
}

@Transactional
@Log
public void createOrder() {
    orderDao.save(order);                  // ← 只有业务
}

// JDK 动态代理：基于接口
UserService proxy = (UserService) Proxy.newProxyInstance(
    classLoader,
    new Class[]{UserService.class}, // 必须有接口
    invocationHandler
);
// 原理：运行时生成实现接口的代理类，反射调用

// CGLIB 代理：基于继承
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserServiceImpl.class); // 不需要接口
enhancer.setCallback(methodInterceptor);
UserService proxy = (UserService) enhancer.create();
// 原理：运行时生成目标类的子类，重写方法

// Spring 内部核心逻辑（简化）
public Object postProcessAfterInitialization(Object bean, String beanName) {
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName);
    if (specificInterceptors != DO_NOT_PROXY) {
        return createProxy(bean.getClass(), specificInterceptors, bean);
    }
    return bean;
}

@Service
public class UserService {
    // ✅ 外部调用 → 走代理 → 事务生效
    @Transactional
    public void methodA() {
        db.save();
    }

    // ❌ 内部调用 → this.methodA() → 不走代理 → 事务失效！
    public void methodB() {
        this.methodA();
    }

    // ✅ 解决：注入自身 或 AopContext
    @Autowired
    private UserService self;

    public void methodB() {
        self.methodA(); // 走代理
    }
}

// 真实对象
UserService real = new UserServiceImpl();
real.createUser(user); // 直接执行业务逻辑

// 代理对象（CGLIB 生成的子类）
UserService proxy = createProxy(real);
proxy.createUser(user);
// 实际执行：
//   1. proxy.createUser() → 拦截器.intercept()
//   2. 前置增强（开事务、打日志）
//   3. real.createUser() → 真正执行业务
//   4. 后置增强（提交事务、记录耗时）

// 验证
@Autowired
private UserService userService;

System.out.println(userService.getClass().getName());
// 输出: com.xxx.UserServiceImpl$$EnhancerBySpringCGLIB$$a1b2c3

System.out.println(userService instanceof UserServiceImpl);
// true - CGLIB 代理是子类，instanceof 仍为 true

@Service
public class UserService {

    @Transactional
    public void methodA() { /* 写数据库 */ }

    public void methodB() {
        this.methodA(); // ← 问题在这
    }
}

// 方式1：Spring 工具类
AopUtils.isAopProxy(bean)              // 是否代理
AopUtils.isJdkDynamicProxy(bean)       // 是否 JDK 代理
AopUtils.isCglibProxy(bean)            // 是否 CGLIB 代理

// 方式2：类名判断
bean.getClass().getName().contains("$Proxy")      // JDK
bean.getClass().getName().contains("$$Enhancer")  // CGLIB

// 方式3：获取真实对象
Object target = AopProxyUtils.getSingletonTarget(bean);
// 或
if (bean instanceof Advised) {
    Object target = ((Advised) bean).getTargetSource().getTarget();
}

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) {
        BeanDefinition bd = factory.getBeanDefinition("userService");
        bd.getPropertyValues().add("timeout", 5000);
    }
}

@Component
public class MyInstantiationProcessor implements InstantiationAwareBeanPostProcessor {

    // 实例化之前：可以直接返回代理对象，跳过 Spring 实例化
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        if (beanClass == SpecialBean.class) {
            return new SpecialBeanProxy();   // 返回非null则跳过Spring创建
        }
        return null;   // 返回null继续Spring正常流程
    }

    // 实例化之后，属性注入之前
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;   // 返回true继续属性注入，false则跳过
    }

    // 属性注入时修改属性值
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return pvs;   // 可修改注入的属性
    }
}

@Component
public class MyDestructionProcessor implements DestructionAwareBeanPostProcessor {
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) {
        if (bean instanceof Disposable) {
            ((Disposable) bean).cleanup();
        }
    }
}

// Spring 内部 @Autowired 的实现就靠它
@Component
public class MyMergedDefinitionProcessor implements MergedBeanDefinitionPostProcessor {
    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
                                                Class<?> beanType, String beanName) {
        // 扫描 @Autowired、@Value 等注解，缓存 InjectionMetadata
    }
}