接口编程

接口编程

在创建好 Bean 实例后，判断是否要初始化，心得：

• 容器中常用的方法是：根据该类是否实现了某个接口，来判断是否要执行某个业务逻辑
• 这其实就是 java基础的 接口编程的 实际运用

package com.llq.spring.ioc;

/**
 * Spring 原生 Ioc 容器
 */
public class LlqSpringApplicationContext {
    //  定义属性 BeanDefinitionMap，用于存放 BeanDefinition
    private ConcurrentHashMap<String, BeanDefinition> BeanDefinitionMap = new ConcurrentHashMap<>();
    //  定义属性 singletonObjects，作为单例池
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();

    private Class configClass;

    public LlqSpringApplicationContext(Class configClass) {
        BeanDefinitionsScan(configClass);
    }

    public ConcurrentHashMap<String, BeanDefinition> getBeanDefinitionMap() {
        return BeanDefinitionMap;
    }

    public ConcurrentHashMap<String, Object> getSingletonObjects() {
        return singletonObjects;
    }

    public void BeanDefinitionsScan(Class configClass) {
        //  这里拿到了自定义配置类的 Class 类型
        this.configClass = configClass;
        System.out.println("配置类的 Class 类型");
        System.out.println("this.configClass= " + this.configClass);
        //  1. 先得到 LlqSpringConfig 配置的注解 @ComponentScan(value = "com.llq.spring.component")
        ComponentScan declaredAnnotation = (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        //  2. 通过 ComponentScan的 value ===> 要扫描的包
        String path = declaredAnnotation.value();
        System.out.println("待扫描的包如下：");
        System.out.println(path);   //  com.llq.spring.component ===> 路径的话，要将 . 替换为 、 ===》com/llq/spring/component
        String scanDir = path.replace(".", "/");
        System.out.println(scanDir);

        //  3. 得到扫描包下的所有资源(类.class) ===> 工作目录的 class
        URL resource = configClass.getClassLoader().getResource(scanDir);  //  URL 对象有许多 API
        scanDir = resource.getPath();
        System.out.println("我们真正要扫描的路径如下：");
        System.out.println(scanDir);

        //  4. 将要加载的资源(.class) 路径下的文件进行遍历 ===> IO 知识

        File file = new File(scanDir); //  得到目录
        File[] files = file.listFiles();    //  列出目录下的所有文件

        System.out.println("==============");
        for (File f : files) {
            String absolutePath = f.getAbsolutePath();
            //  注意这里，只处理 .class 文件
            if (absolutePath.endsWith(".class")) {

                System.out.println(absolutePath);   //  D:\spring5\out\production\spring5\com\llq\spring\component\UserService.class
                //  现在反射需要得到：com.llq.spring.component.UserService
                //  1. 先获取类名
                String[] split = absolutePath.split("\\\\");
                String s = split[split.length - 1];
                System.out.println(s);
                String className = split[split.length - 1].split("\\.")[0];
                //  得到类名
                System.out.println("类名：" + className);
                //  再将 / 改回成 .
                String classFullName = path + "." + className; // 包名 + 类名
                System.out.println(classFullName);

                //  2. 判断该类是否需要注入到容器中
                //      观察该类是否包含以下注解
                //      @Component、@Service、@Repository、@Controller
                try {
                    Class<?> aClass = Class.forName(classFullName);
                    if (aClass.isAnnotationPresent(Component.class)) {
                        //  如果该类使用了 @Component 注解，说明是 Spring Bean
                        System.out.println("这是一个 Spring Bean= " + aClass + " 类名 " + className);
                        //  1. 先得到 beanName
                        String beanName = "";
                        String value = aClass.getDeclaredAnnotation(Component.class).value();
                        if ("".equals(value)) { //  是否右 scope 注解
                            className = className.substring(0, 1).toLowerCase() + className.substring(1);   //  首字母小写
                            beanName = className;
                        } else {
                            beanName = value;
                        }
                        System.out.println("key：" + beanName);

                        String scopeValue = "";
                        //  将 Bean信息封装到 BeanDefinition 对象 ===> 放入到 BeanDefinitionMap中
                        Scope scope = aClass.getDeclaredAnnotation(Scope.class);
                        if (scope == null) {
                            scopeValue = "singleton";
                        } else {
                            scopeValue = scope.value();
                        }

                        BeanDefinition beanDefinition = new BeanDefinition();
                        beanDefinition.setaClass(aClass);
                        beanDefinition.setScope(scopeValue);
                        BeanDefinitionMap.put(beanName, beanDefinition);

                        //  初始化单例池
                        if ("singleton".equals(scopeValue)) {
                            //  已经创建好 Bean 对象了，还要判断是否要执行 初始化方法
                            System.out.println("我是单例，直接实例化，放入到单例池 singletonObjects 中");
                            Object o = aClass.getConstructor().newInstance();
                            if (o instanceof InitializingBean){
                                ((InitializingBean) o).afterPropertiesSet();
                            }
                            singletonObjects.put(beanName, o);
                        }
                        System.out.println("---------------------------");

                    } else {
                        System.out.println("这不是一个 Spring Bean" + " 类名 " + className);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public Object createBean(BeanDefinition beanDefinition){
        Object o = null;
        Class aClass = beanDefinition.getaClass();
        Field[] declaredFields = aClass.getDeclaredFields();    //  拿到所有字段

        try {
            o = aClass.getConstructor().newInstance();

            for (Field declaredField : declaredFields) {
                if (declaredField.getAnnotation(Autowired.class) != null){  // 字段上是否有 @Autowired 注解
                    //  1. 先看单例池中有没有，有的话直接 get
                    //  2. 没有的话，new 一个 新的
                    String name = declaredField.getName();
                    Object bean = getBean(name);    //  待注入的依赖
                    declaredField.setAccessible(true);
                    declaredField.set(o, bean);
                }
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("创建好 Bean 实例 " + o);
        //  这里判断是否执行 Bean 初始化方法
        //  1. 判断当前创建的 Bean 对象是否实现了 InitializingBean 接口
        if (o instanceof InitializingBean){
            try {
                ((InitializingBean) o).afterPropertiesSet();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return o;
    }

    public Object getBean(String name){
        if (singletonObjects.containsKey(name)){   //  单例池中有的话
            return singletonObjects.get(name);
        }

        Object o = null;

        if (BeanDefinitionMap.containsKey(name) && "prototype".equals(BeanDefinitionMap.get(name).getScope())){
            o = createBean(BeanDefinitionMap.get(name));
        }

        if (o == null){
            throw new NullPointerException("没有该 Bean");
        }
        return o;
    }
}

接口编程