day12-实现Spring底层机制-02

seo排名网 2023年01月31日 23:39 238 0

实现Spring底层机制-02

3.实现任务阶段1

3.1知识拓展-类加载器

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

3.2分析

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

day12-实现Spring底层机制-02-第1张图片-seo排名网

3.3代码实现

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

day12-实现Spring底层机制-02-第2张图片-seo排名网

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

<properties>

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

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

</properties>

2.创建的架构如下：

day12-实现Spring底层机制-02-第3张图片-seo排名网

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张图片-seo排名网

4.实现任务阶段2

4.1分析

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

day12-实现Spring底层机制-02-第5张图片-seo排名网

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

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

新添加的注解和类：

day12-实现Spring底层机制-02-第6张图片-seo排名网

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-第7张图片-seo排名网

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-第8张图片-seo排名网

6.测试类

//...

public class AppMain {

    public static void main(String[] args) {

        MySpringApplicationContext ioc =

                new MySpringApplicationContext(MySpringConfig.class);

    }

}

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

day12-实现Spring底层机制-02-第9张图片-seo排名网

5.实现任务阶段3

5.1分析

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

day12-实现Spring底层机制-02-第10张图片-seo排名网

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-第11张图片-seo排名网

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-第12张图片-seo排名网

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

day12-实现Spring底层机制-02-第13张图片-seo排名网

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-第14张图片-seo排名网

本文地址： http://seopm.com/3385.html

文章来源： seo排名网