day12-实现Spring底层机制-02

时间:2023-01-28 22:07:33

3.实现任务阶段1

3.1知识拓展-类加载器

  1. Java的类加载器有三种:
    • Bootstrap类加载器 ----- 对应路径 jre/lib
    • Ext类加载器 ----- 对应路径 jre/lib/ext
    • App类加载器 ----- 对应路径 classpath
  2. classpath 类路径,就是java.exe执行时,指定的路径。

3.2分析

阶段1目标:编写自己的spring容器,实现扫描包,得到bean的class对象

day12-实现Spring底层机制-02

3.3代码实现

1.创建新的maven项目,注意把项目的 language level 改为支持 java8

day12-实现Spring底层机制-02

在pom.xml文件中指定编译版本:

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
</properties>

2.创建的架构如下:

day12-实现Spring底层机制-02

3.自定义ComponentScan注解,用于标记要扫描的包

package com.li.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 李
 * @version 1.0
 * 模仿spring原生注解,自定义一个注解
 * 1. @Target(ElementType.TYPE) 指定ComponentScan注解可以修饰TYPE元素
 * 2. @Retention(RetentionPolicy.RUNTIME) 指定ComponentScan注解 的保留范围
 * 3. String value() default "";  表示 ComponentScan 可以传入一个value值
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    //通过value指定要扫描的包
    String value() default "";
}

4.自定义Component注解,用于标记要扫描的类

package com.li.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    //通过value给要注入的bean指定名字
    String value() default "";
}

5.自定义配置类,相当于原生spring的容器配置文件

package com.li.spring.ioc;

import com.li.spring.annotation.ComponentScan;

/**
 * @author 李
 * @version 1.0
 * 这是一个配置类,作用类似我们原生 spring 的容器配置文件 beans.xml
 */
@ComponentScan(value = "com.li.spring.component")
public class MySpringConfig {

}

6.自定义spring容器,类似原生ioc容器。(未完成)

目前的功能:

(1)在初始化时,根据传入的配置类.class文件,读取要扫描的包路径

(2)遍历包路径下的文件,找出需要注入的bean

package com.li.spring.ioc;

import com.li.spring.annotation.Component;
import com.li.spring.annotation.ComponentScan;

import java.io.File;
import java.net.URL;

/**
 * @author 李
 * @version 1.0
 * MySpringApplicationContext 类的作用类似Spring原生的ioc容器
 */
public class MySpringApplicationContext {
    private Class configClass;

    //构造器
    public MySpringApplicationContext(Class configClass) {
        this.configClass = configClass;
        //步骤一:获取要扫描的包
        //1.先得到 MySpringConfig配置类的注解 @ComponentScan(value = "com.li.spring.component")
        ComponentScan componentScan =
                (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        //2.通过 componentScan的 value=>得到要扫描的包路径
        String path = componentScan.value();
        System.out.println("要扫描的包=" + path);

        //步骤二:得到要扫描的包下的所有资源(类.class)
        //1.得到类的加载器-->App 类加载器
        ClassLoader classLoader = MySpringApplicationContext.class.getClassLoader();
        //2.通过类的加载器获取到要扫描的包的资源 url=>类似一个路径
        path = path.replace(".", "/");//将原先路径的.替换成/ ==> com/li/component
        URL resource = classLoader.getResource(path);
        //resource=file:/D:/IDEA-workspace/spring/out/production/spring/com/li/component
        System.out.println("resource=" + resource);
        //3.将要加载的资源(.class)路径下的文件进行遍历
        File file = new File(resource.getFile());
        if (file.isDirectory()) {
            File[] files = file.listFiles();//将当前目录下的所有文件放到files数组中(这里没有实现递归)
            for (File f : files) {
                //System.out.println("============");
                //System.out.println("AbsolutePath=" + f.getAbsolutePath());
                //获取文件的绝对路径
                String fileAbsolutePath = f.getAbsolutePath();

                //只处理.class文件
                if (fileAbsolutePath.endsWith(".class")) {

                    //步骤三:获取全类名反射对象,并放入容器中
                    //将其转变为 com.li.spring.component.MyComponent.class 形式
                    //1.先获取到类名
                    String className = fileAbsolutePath.substring(
                            fileAbsolutePath.lastIndexOf("\\") + 1,
                            fileAbsolutePath.indexOf(".class"));
                    //2.获取类的完整路径(全类名)
                    // path.replace("/", ".") => com.li.component
                    String classFullName = path.replace("/", ".") + "." + className;
                    //3.判断该class文件是否要注入到容器中(该类是否有特定注解)
                    try {
                        /*
                        得到该类的Class对象:
                        (1)Class.forName(className) 可以反射加载类
                        (2)classLoader.loadClass(className)也可以反射类的Class
                        主要区别是:(1)的方式会调用该类的静态方法,(2)的方法不会
                         */
                        //因为这里只是要判断该类有没有注解,因此使用比较轻量级的方式
                        Class<?> clazz = classLoader.loadClass(classFullName);
                        //判断该类是否有特定注解
                        if (clazz.isAnnotationPresent(Component.class)) {
                            //以 Component注解为例,如果有其他注解,逻辑一致
                            //如果该类使用了 @Component ,说明是spring bean
                            System.out.println("是一个spring bean=" + clazz + " 类名=" + className);
                        } else {
                            //如果没有使用,则说明不是spring bean
                            System.out.println("不是一个 spring bean=" + clazz + " 类名=" + className);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("===========================");
        }
    }

    //编写方法,返回容器对象
    public Object getBean(String name) {
        return null;
    }
}

7.创建两个自定义 Spring bean,一个普通类作为测试

(1)MonsterService

package com.li.spring.component;

import com.li.spring.annotation.Component;

/**
 * @author 李
 * @version 1.0
 * MonsterService 是一个 Service
 * 1.如果指定了value,那么在注入spring容器时,以你指定的为准
 * 2.如果没有指定value,则使用类名(首字母小写)作为默认名
 */
@Component(value = "monsterService") //将 MonsterService注入到自己的spring容器中
public class MonsterService {
}

(2)MonsterDao

package com.li.spring.component;

import com.li.spring.annotation.Component;

/**
 * @author 李
 * @version 1.0
 */
@Component(value = "monsterDao")
public class MonsterDao {
}

(3)Car,普通类

package com.li.spring.component;

/**
 * @author 李
 * @version 1.0
 */
public class Car {
}

8.进行测试

package com.li.spring.test;

import com.li.spring.ioc.MySpringApplicationContext;
import com.li.spring.ioc.MySpringConfig;

/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        MySpringApplicationContext ioc =
                new MySpringApplicationContext(MySpringConfig.class);
    }
}

测试结果:成功区分指定包下的 bean 和普通类

day12-实现Spring底层机制-02

4.实现任务阶段2

4.1分析

阶段2目标:扫描指定包,将bean信息封装到BeanDefinition对象,并放入到Map

day12-实现Spring底层机制-02

BeanDefinitionMap以k-v形式存放bean对象的信息。

  1. key为bean对象的id
  2. value为BeanDefinition对象,该对象存放bean信息。如果bean为prototype,应保存bean的class对象,这样在调用getBean()方法时可以动态创建对象。

新添加的注解和类:

day12-实现Spring底层机制-02

4.2代码实现

1.自定义注解,用于指定 bean 是单例还是多例

package com.li.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 李
 * @version 1.0
 * Scope 用于指定 bean的作用范围 [singleton/prototype]
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
    //通过 value 指定 bean 是 singleton 或 prototype
    String value() default "";
}

2.修改MonsterService,添加Scope注解

day12-实现Spring底层机制-02

3.BeanDefinition 用于封装/记录 Bean对象的信息

package com.li.spring.ioc;

/**
 * @author 李
 * @version 1.0
 * 用于封装/记录 Bean对象的信息:
 * 1.scope
 * 2.Bean对应的 Class对象,用于反射生成对应对象
 */
public class BeanDefinition {
    private String scope;
    private Class clazz;

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    @Override
    public String toString() {
        return "BeanDefinition{" +
                "scope='" + scope + '\'' +
                ", clazz=" + clazz +
                '}';
    }
}

4.修改自定义spring容器 MySpringApplicationContext

增加的功能:

(1)定义属性beanDefinitionMap,用于存放BeanDefinition对象,BeanDefinition对象存储bean信息,包括bean是单例还是多例,bean的class对象

(2)将MySpringApplicationContext构造器的所有代码封装成一个方法。

部分代码:

package com.li.spring.ioc;

//...

/**
 * @author 李
 * @version 1.0
 * MySpringApplicationContext 类的作用类似Spring原生的ioc容器
 */
public class MySpringApplicationContext {
    private Class configClass;
    //定义属性 BeanDefinitionMap->存放BeanDefinition对象
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

    //构造器
    public MySpringApplicationContext(Class configClass) {
        beanDefinitionByScan(configClass);
        System.out.println("beanDefinitionMap=" + beanDefinitionMap);
    }

    //该方法完成对指定包的扫描,并将Bean信息封装到BeanDefinition对象,再放入map中
    public void beanDefinitionByScan(Class configClass) {
        //步骤一:获取要扫描的包
        //...

        //步骤二:得到要扫描的包下的所有资源(类.class)
        //...

        //步骤三:获取全类名反射对象,并放入容器中
        //...
        //判断该类是否有特定注解
        if (clazz.isAnnotationPresent(Component.class)) {
            //如果该类使用了 @Component ,说明是spring bean
            System.out.println("是一个spring bean=" + clazz + " 类名=" + className);
            //-------------------新增代码----------------------
            //得到 BeanName-key
            //1.得到 Component 注解
            Component componentAnnotation = clazz.getDeclaredAnnotation(Component.class);
            //2.得到Component注解的value值
            String beanName = componentAnnotation.value();
            //如果没有指定,就使用类名(首字母小写)作为beanName
            if ("".equals(beanName)) {
                beanName = StringUtils.uncapitalize(className);
            }
            //将 Bean信息封装到 BeanDefinition对象-value
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setClazz(clazz);
            //1.获取scope
            if (clazz.isAnnotationPresent(Scope.class)) {
                //如果配置了Scope,就设置配置的值
                Scope scopeAnnotation = clazz.getDeclaredAnnotation(Scope.class);
                beanDefinition.setScope(scopeAnnotation.value());
            } else {
                //如果没有配置Scope,就设置默认值singleton
                beanDefinition.setScope("singleton");
            }

            //将beanDefinition对象放入Map中
            beanDefinitionMap.put(beanName, beanDefinition);
            //--------------------新增代码------------------------
        } else {
            //如果没有使用,则说明不是spring bean
            System.out.println("不是一个 spring bean=" + clazz + " 类名=" + className);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
System.out.println("===========================");
}}}

    //编写方法,返回容器对象
    public Object getBean(String name) {
        return null;
    }
}

ps:这里使用了一个工具包

<dependencies>
    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.6</version>
    </dependency>
</dependencies>

5.为了测试,将MonsterService的@Component的value注释

day12-实现Spring底层机制-02

6.测试类

//...
public class AppMain {
    public static void main(String[] args) {
        MySpringApplicationContext ioc =
                new MySpringApplicationContext(MySpringConfig.class);
    }
}

测试结果:成功扫描指定包,并将bean对象的信息放入到beanDefinitionMap中,没有指定beanId的对象以默认规则作为id。

day12-实现Spring底层机制-02

5.实现任务阶段3

5.1分析

阶段3目标:初始化bean单例池,并完成getBean方法,createBean方法

day12-实现Spring底层机制-02

5.2代码实现

1.修改自定义spring容器 MySpringApplicationContext

增加的功能:

(1)增加方法createBean(),用于通过反射创建bean对象

(2)在构造方法中,初始化单例池:如果bean是单例,就通过createBean()将其实例化,然后放入单例池。

(3)实现getBean方法:通过beanName,返回bean对象。

部分代码:

//构造器
public MySpringApplicationContext(Class configClass) {
    beanDefinitionByScan(configClass);
    //后期封装成方法---------
    Enumeration<String> keys = beanDefinitionMap.keys();
    //遍历
    while (keys.hasMoreElements()) {
        //得到 beanName
        String beanName = keys.nextElement();
        //通过beanName得到对应的 beanDefinition 对象
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        //判断该 bean 是单例还是多例
        if ("singleton".equals(beanDefinition.getScope())) {
            //将该bean实例放入到singletonObjects中
            singletonObjects.put(beanName, createBean(beanDefinition));
        }
    }
    System.out.println("singletonObjects 单例池=" + singletonObjects);
    //------------
    System.out.println("beanDefinitionMap=" + beanDefinitionMap);
}

//完成createBean(BeanDefinition)方法
public Object createBean(BeanDefinition beanDefinition) {
    //得到Bean的class对象
    Class clazz = beanDefinition.getClazz();
    try {
        //反射创建bean实例
        Object instance = clazz.getDeclaredConstructor().newInstance();
        return instance;
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    //如果反射对象失败
    return null;
}

//编写方法,返回容器对象
public Object getBean(String name) {
    //传入的beanName是否在 beanDefinitionMap中存在
    if (beanDefinitionMap.containsKey(name)) {//存在
        //从 beanDefinitionMap中获取 beanDefinition对象
        BeanDefinition beanDefinition = beanDefinitionMap.get(name);
        if ("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
            //如果是单例 bean,直接从单例池获取
            return singletonObjects.get(name);
        } else {//如果不是单例,调用createBean(),反射创建对象
            return createBean(beanDefinition);
        }
    } else {//不存在
        //抛出空指针异常
        throw new NullPointerException("不存在该bean=" + name);
    }
}

2.测试类

//...
public class AppMain {
    public static void main(String[] args) {
        MySpringApplicationContext ioc =
                new MySpringApplicationContext(MySpringConfig.class);
        //Object xxx = ioc.getBean("xxx");//抛出空指针异常
        //多实例对象的获取
        MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
        MonsterService monsterService2 = (MonsterService) ioc.getBean("monsterService");
        System.out.println("monsterService=" + monsterService);
        System.out.println("monsterService2=" + monsterService2);
        //单实例对象的获取
        MonsterDao monsterDao = (MonsterDao) ioc.getBean("monsterDao");
        MonsterDao monsterDao2 = (MonsterDao) ioc.getBean("monsterDao");
        System.out.println("monsterDao=" + monsterDao);
        System.out.println("monsterDao2=" + monsterDao);
    }
}

测试结果:在创建MySpringApplicationContext对象时,成功初始化了单例池,beanDefinitionMap。并根据beanName返回bean对象。MonsterService添加了Scope=“prototype”注解,因此每一次获取的对象都是不同的。

day12-实现Spring底层机制-02

6.实现任务4

6.1分析

阶段4目标:完成依赖注入

6.2代码实现

1.自定义注解AutoWired,用于标记需要依赖注入的属性

package com.li.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author 李
 * @version 1.0
 */
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoWired {
    //如果为true,就完成依赖注入
    boolean required() default true;
}

2.为了测试,在MonsterDao,MonsterService中添加测试代码。

(1)修改MonsterDao,在该类中增加方法

day12-实现Spring底层机制-02

(2)修改MonsterService,在该类中添加属性monsterDao,并使用AutoWired注解修饰。在方法m1()中调用属性对象的方法。

day12-实现Spring底层机制-02

3.修改自定义spring容器 MySpringApplicationContext (部分代码)

修改方法createBean(),因为依赖注入需要在反射创建bean对象时完成。

//完成createBean(BeanDefinition)方法
public Object createBean(BeanDefinition beanDefinition) {
    //得到Bean的class对象
    Class clazz = beanDefinition.getClazz();
    try {
        //反射创建bean实例
        Object instance = clazz.getDeclaredConstructor().newInstance();
        //todo 这里要加入依赖注入的业务逻辑
        //1.遍历当前要创建对象的所有属性字段
        for (Field declaredField : clazz.getDeclaredFields()) {
            //2.判断字段是否有AutoWired注解
            if (declaredField.isAnnotationPresent(AutoWired.class)) {
                //判断是否需要自动装配
                AutoWired autoWiredAnnotation = 
                        declaredField.getAnnotation(AutoWired.class);
                if (autoWiredAnnotation.required()) {
                    //3.得到字段的名称
                    String name = declaredField.getName();
                    //4.通过getBean()方法获取要组装的对象
                    //如果name对应的对象时单例的,就到单例池去获取,如果是多例的,就反射创建并返回
                    Object bean = getBean(name);
                    //5.进行组装
                    //暴破
                    declaredField.setAccessible(true);
                    declaredField.set(instance, bean);
                }
            }
        }
        return instance;
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    //如果反射对象失败
    return null;
}

4.测试类

//...
public class AppMain {
    public static void main(String[] args) {
        MySpringApplicationContext ioc =
                new MySpringApplicationContext(MySpringConfig.class);
        MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
        monsterService.m1();
    }
}

测试结果:自动装配成功

day12-实现Spring底层机制-02