package com.example.spring6.bean;

public class SpringBean {
    public SpringBean() {
        System.out.println("SpringBean 的无参数构造方法执行了...");
    }
}

package com.example.spring6.test;

import com.example.spring6.bean.SpringBean;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ScopeTest {
    @Test
    public void testScope() {
        ApplicationContext applicationContext  = new ClassPathXmlApplicationContext("spring-scope.xml");
        SpringBean sb1 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println("sb1 = " + sb1);
        SpringBean sb2 = applicationContext.getBean("sb", SpringBean.class);
        System.out.println("sb2 = " + sb2);

        
    }
    @Test
    public void testSingletonCreateTiming() {
        // 仅创建容器，不获取 Bean
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-scope.xml");
    }

}

package com.example.spring6.bean;

// 模拟一个无法直接 new 的遗留类
public class LegacyApiClient {
    // 构造器是私有的
    private LegacyApiClient() {
        System.out.println("遗留 API 客户端实例已创建...");
    }

    // 提供一个公共的静态工厂方法
    public static LegacyApiClient getInstance() {
        return new LegacyApiClient();
    }
}

@Test
public void testStaticFactory() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-instantiation.xml");
    LegacyApiClient client = context.getBean("apiClient", LegacyApiClient.class);
    System.out.println(client);
}

package com.example.spring6.bean;
// 模拟的连接池产品
public class ConnectionPool {}

package com.example.spring6.bean;

// 模拟的连接池管理器（实例工厂）
public class ConnectionPoolManager {
    private int maxConnections;

    public void setMaxConnections(int maxConnections) {
        this.maxConnections = maxConnections;
    }

    // 实例方法，负责创建 ConnectionPool 实例
    public ConnectionPool createPool() {
        System.out.println("实例工厂 ConnectionPoolManager 正在创建连接池，最大连接数：" + this.maxConnections);
        return new ConnectionPool();
    }
}

@Test
public void testInstanceFactory() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-instantiation.xml");
    ConnectionPool pool = context.getBean("connectionPool", ConnectionPool.class);
    System.out.println(pool);
}

package com.example.spring6.bean;

// 产品接口
public interface MessageConverter {}
// 两种具体实现
class SimpleMessageConverter implements MessageConverter {}
class ComplexMessageConverter implements MessageConverter {}

package com.example.spring6.bean;
import org.springframework.beans.factory.FactoryBean;

// 1. 实现 FactoryBean 接口
public class MessageConverterFactoryBean implements FactoryBean<MessageConverter> {
    
    // 这个工厂本身可以被配置
    private String type = "simple"; 

    public void setType(String type) {
        this.type = type;
    }
    
    // 2. 封装复杂的创建逻辑在 getObject() 方法中
    @Override
    public MessageConverter getObject() throws Exception {
        System.out.println("FactoryBean 正在根据 type='" + type + "' 创建 MessageConverter...");
        if ("simple".equalsIgnoreCase(type)) {
            return new SimpleMessageConverter();
        } else if ("complex".equalsIgnoreCase(type)) {
            return new ComplexMessageConverter();
        }
        throw new IllegalArgumentException("未知的转换器类型: " + type);
    }

    @Override
    public Class<?> getObjectType() {
        return MessageConverter.class;
    }
}

@Test
public void testFactoryBean() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-instantiation.xml");
    // 当我们获取 id 为 "messageConverter" 的 Bean 时...
    MessageConverter converter = context.getBean("messageConverter", MessageConverter.class);
    // ...Spring 返回的不是 FactoryBean 本身，而是它 getObject() 方法的返回值！
    System.out.println("获取到的 Bean 类型: " + converter.getClass().getSimpleName());
}

package com.example.spring6.bean;

public class LifecycleBean {
    private String name;

    // 对应生命周期第 1 步
    public LifecycleBean() {
        System.out.println("1. 实例化 Bean (调用构造器)");
    }

    // 对应生命周期第 2 步
    public void setName(String name) {
        this.name = name;
        System.out.println("2. Bean 属性赋值 (调用 setter)");
    }

    // 对应生命周期第 3 步 (自定义初始化方法)
    public void init() {
        System.out.println("3. 初始化 Bean (调用自定义 init 方法)");
    }

    // 对应生命周期第 5 步 (自定义销毁方法)
    public void destroy() {
        System.out.println("5. 销毁 Bean (调用自定义 destroy 方法)");
    }
}

package com.example.spring6.test;

import com.example.spring6.bean.LifecycleBean;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LifecycleTest {
    @Test
    public void testLifecycleFiveSteps() {
        // 要想触发销毁方法，必须使用 ClassPathXmlApplicationContext 并手动 close()
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        
        LifecycleBean bean = context.getBean("lifecycleBean", LifecycleBean.class);
        System.out.println("4. 使用 Bean");
        
        // 关键：手动关闭容器，以触发 Bean 的销毁阶段
        context.close();
    }
}

package com.example.spring6.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class LogBeanPostProcessor implements BeanPostProcessor {
    // 在每个 Bean 的【初始化方法之前】执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("-> postProcessBeforeInitialization: " + beanName);
        return bean; // 必须返回 bean，否则后续流程会拿到 null
    }

    // 在每个 Bean 的【初始化方法之后】执行
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("-> postProcessAfterInitialization: " + beanName);
        return bean;
    }
}