實作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物件

3.3代碼實作

1.創建新的maven專案，注意把專案的 language level 改為支持 java8

在pom.xml檔案中指定編譯版本：

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

2.創建的架構如下：

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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/28/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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/28/com.li.spring.component")
        ComponentScan componentScan =
                (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        //2.通過 componentScan的 value=https://www.cnblogs.com/liyuelian/archive/2023/01/28/>得到要掃描的包路徑
        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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/28/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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/28/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 和普通類

4.實作任務階段2

4.1分析

階段2目標：掃描指定包，將bean資訊封裝到BeanDefinition物件，并放入到Map

BeanDefinitionMap以k-v形式存放bean物件的資訊，

key為bean物件的id
value為BeanDefinition物件，該物件存放bean資訊，如果bean為prototype，應保存bean的class物件，這樣在呼叫getBean()方法時可以動態創建物件，

新添加的注解和類：

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注解

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注釋

6.測驗類

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

測驗結果：成功掃描指定包，并將bean物件的資訊放入到beanDefinitionMap中，沒有指定beanId的物件以默認規則作為id，

5.實作任務階段3

5.1分析

階段3目標：初始化bean單例池，并完成getBean方法，createBean方法

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”注解，因此每一次獲取的物件都是不同的，

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，在該類中增加方法

（2）修改MonsterService，在該類中添加屬性monsterDao，并使用AutoWired注解修飾，在方法m1()中呼叫屬性物件的方法，

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();
    }
}

測驗結果：自動裝配成功

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542473.html

標籤：其他

上一篇：《RPC實戰與核心原理》學習筆記Day11

下一篇：C 語言輸出100至200之間的質數（素數）

day12-實作Spring底層機制-02