技术实现：基于生命周期接口的简单IOC容器实现-CSDN博客

本文链接：https://blog.csdn.net/weixin_44454629/article/details/135170526

基于生命周期接口的简单容器实现

技术背景

在软件开发中，容器通常用于管理和组织对象的生命周期。通过实现生命周期接口，可以对容器中的对象进行初始化、销毁、启动和停止等操作。本文将介绍如何基于生命周期接口实现一个简单的容器，并演示如何使用该容器来管理服务对象的声明周期。

功能需求

实现生命周期接口，包括启动、停止、初始化和销毁操作。
注册对象到容器中，并能够通过名称获取对象。
容器能够启动和停止所有注册的实现了生命周期接口的对象。
对象在初始化和销毁时，可以接收参数并进行验证。

技术实现

// 定义一个生命周期接口
public interface Lifecycle {

    // 启动对象
    void start();

    // 停止对象
    void stop();

    // 初始化对象
    void init(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException;

    // 销毁对象
    void destroy(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException;
}

// 定义一个简单的容器实现类
public class SimpleContainer implements Container, Lifecycle {

    // 存储已注册的对象
    private Map<String, Object> beans = new HashMap<>();

    // 注册一个对象到容器中
    @Override
    public void registerBean(String name, Object bean) {
        beans.put(name, bean);
    }

    // 从容器中获取一个对象
    @Override
    public Object getBean(String name) {
        return beans.get(name);
    }

    // 启动容器中的所有对象
    @Override
    public void start() {
        for (Object bean : beans.values()) {
            if (bean instanceof Lifecycle) {
                ((Lifecycle) bean).start();
            }
        }
    }

    // 停止容器中的所有对象
    @Override
    public void stop() {
        for (Object bean : beans.values()) {
            if (bean instanceof Lifecycle) {
                ((Lifecycle) bean).stop();
            }
        }
    }

    // 初始化容器中的所有对象
    @Override
    public void init(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        validateInitParams(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);

        for (Object bean : beans.values()) {
            if (bean instanceof Lifecycle) {
                ((Lifecycle) bean).init(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);
            }
        }
    }

    // 销毁容器中的所有对象
    @Override
    public void destroy(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        validateDestroyParams(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);

        for (Object bean : beans.values()) {
            if (bean instanceof Lifecycle) {
                ((Lifecycle) bean).destroy(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);
            }
        }
    }

    // 验证初始化参数
    private void validateInitParams(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        // 在这里添加初始化参数的验证逻辑
    }

    // 验证销毁参数
    private void validateDestroyParams(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        // 在这里添加销毁参数的验证逻辑
    }
}

// 定义一个服务接口
public interface Service {

    // 服务的方法
    void doSomething();
}

// 定义一个服务实现类
@InitParams(names = {"name", "age"}, validationRules = {"^[A-Za-z]+$", "^[0-9]+$"})
public class ServiceImpl implements Service, Lifecycle {

    private String name;

    private int age;

    // 服务的方法
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }

    // 启动服务
    @Override
    public void start() {
        System.out.println("Service started.");
    }

    // 停止服务
    @Override
    public void stop() {
        System.out.println("Service stopped.");
    }

    // 初始化服务
    @Override
    public void init(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        validateInitParams(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);

        // 对象初始化时执行
        this.name = (String) params.get("name");
        this.age = (Integer) params.get("age");

        System.out.println("Service initialized with params: " + params);
    }

    // 销毁服务
    @Override
    public void destroy(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        validateDestroyParams(params, validationRules, validationRuleTypes, validationRuleDefaultValues, validationRuleDefaultValueType, validationRuleDefaultValueDefaultValues);

        // 对象销毁时执行
        System.out.println("Service destroyed with params: " + params);
    }

    // 验证初始化参数
    private void validateInitParams(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        // 在这里添加初始化参数的验证逻辑
    }

    // 验证销毁参数
    private void validateDestroyParams(Map<String, Object> params, Map<String, Object> validationRules, Map<String, Object> validationRuleTypes, Map<String, Object> validationRuleDefaultValues, Map<String, Object> validationRuleDefaultValueType, Map<String, Object> validationRuleDefaultValueDefaultValues) throws IllegalArgumentException {
        // 在这里添加销毁参数的验证逻辑
    }
}

// 定义一个自定义注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface InitParams {

    String[] names();

    String[] validationRules();
}

// 创建一个注解处理器来处理这个自定义注解
public class InitParamsAnnotationProcessor {

    public void process(Object bean) {
        Class<?> clazz = bean.getClass();

        if (clazz.isAnnotationPresent(InitParams.class)) {
            InitParams initParams = clazz.getAnnotation(InitParams.class);

            String[] names = initParams.names();
            String[] validationRules = initParams.validationRules();

            Map<String, Object> params = new HashMap<>();
            Map<String, Object> validationRulesMap = new HashMap<>();

            for (int i = 0; i < names.length; i++) {
                params.put(names[i], null);
                validationRulesMap.put(names[i], validationRules[i]);
            }

            container.init(bean, params, validationRulesMap);
        }
    }
}

测试与评估

// 定义一个主类
public class Main {

    public static void main(String[] args) {
        // 创建一个容器
        Container container = new SimpleContainer();

        // 注册一个注解处理器
        container.registerBean("initParamsAnnotationProcessor", new InitParamsAnnotationProcessor());

        // 将服务对象注册到容器中
        container.registerBean("service", new ServiceImpl());

        // 获取service bean
        Service service = (Service) container.getBean("service");

        // 调用service bean的方法
        service.doSomething();

        // 销毁容器（停止容器中的所有对象）
        container.stop();
    }
}

在主类中，我们创建了一个容器，注册了一个自定义的注解处理器和一个服务对象。然后通过容器获取服务对象，并调用其方法。最后，我们停止了容器，触发了容器中所有对象的停止操作。