30個類手寫Spring核心原理之Ioc頂層架構設計(2)

語言: CN / TW / HK

本文節選自《Spring 5核心原理》

1 Annotation(自定義配置)模組

Annotation的程式碼實現我們還是沿用Mini版本的,保持不變,複製過來便可。

1.1 @GPService

@GPService程式碼如下:


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
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)
@Documented
public @interface GPService {

   String value() default "";
	 
}

1.2 @GPAutowired

@GPAutowired程式碼如下:


package com.tom.spring.formework.annotation;

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

/**
 * 自動注入
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPAutowired {

   String value() default "";
	 
}

1.3 @GPController

@GPController程式碼如下:


package com.tom.spring.formework.annotation;

import java.lang.annotation.Documented;
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)
@Documented
public @interface GPController {

   String value() default "";
	 
}

1.4 @GPRequestMapping

@GPRequestMapping程式碼如下:


package com.tom.spring.formework.annotation;

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

/**
 * 請求URL
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestMapping {

   String value() default "";
	 
}

1.5 @GPRequestParam

@GPRequestParam程式碼如下:


package com.tom.spring.formework.annotation;

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

/**
 * 請求引數對映
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface GPRequestParam {

   String value() default "";
	 
}

2 core(頂層介面)模組

2.1 GPFactoryBean

關於頂層介面設計,通過前面的學習我們瞭解了FactoryBean的基本作用,在此不做過多解釋。


package com.tom.spring.formework.core;

public interface GPFactoryBean {

}

2.2 GPBeanFactory

作為所有IoC容器的頂層設計,前面也已經詳細介紹了BeanFactory的作用。


package com.tom.spring.formework.core;

/**
 * 單例工廠的頂層設計
 */
public interface GPBeanFactory {

    /**
     * 根據beanName從IoC容器中獲得一個例項Bean
     * @param beanName
     * @return
     */
    Object getBean(String beanName) throws Exception;

    public Object getBean(Class<?> beanClass) throws Exception;

}

3 beans(配置封裝)模組

3.1 GPBeanDefinition

BeanDefinition主要用於儲存Bean相關的配置資訊。


package com.tom.spring.formework.beans.config;

//用來儲存配置檔案中的資訊
//相當於儲存在記憶體中的配置
public class GPBeanDefinition {

    private String beanClassName;  //原生Bean的全類名
    private boolean lazyInit = false; //標記是否延時載入
    private String factoryBeanName;  //儲存beanName,在IoC容器中儲存的key
		
    public String getBeanClassName() {
        return beanClassName;
    }
		
    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
    }
		
    public boolean isLazyInit() {
        return lazyInit;
    }
		
    public void setLazyInit(boolean lazyInit) {
        this.lazyInit = lazyInit;
    }
		
    public String getFactoryBeanName() {
        return factoryBeanName;
    }
		
    public void setFactoryBeanName(String factoryBeanName) {
        this.factoryBeanName = factoryBeanName;
    }
		
}

3.2 GPBeanWrapper

BeanWrapper主要用於封裝建立後的物件例項,代理物件(Proxy Object)或者原生物件(Original Object)都由BeanWrapper來儲存。


package com.tom.spring.formework.beans;

public class GPBeanWrapper {

    private Object wrappedInstance;
    private Class<?> wrappedClass;

    public GPBeanWrapper(Object wrappedInstance){
        this.wrappedInstance = wrappedInstance;
    }

    public Object getWrappedInstance(){
        return this.wrappedInstance;
    }

    //返回代理以後的Class
    //可能會是這個 $Proxy0
    public Class<?> getWrappedClass(){
        return this.wrappedInstance.getClass();
    }
}

4 context(IoC容器)模組

4.1 GPAbstractApplicationContext

IoC容器實現類的頂層抽象類,實現IoC容器相關的公共邏輯。為了儘可能地簡化,在這個Mini版本中,暫時只設計了一個refresh()方法。


package com.tom.spring.formework.context.support;

/**
 * IoC容器實現的頂層設計
 */
public abstract class GPAbstractApplicationContext {

    //受保護,只提供給子類重寫
    public void refresh() throws Exception {}
		
}

4.2 GPDefaultListableBeanFactory

DefaultListableBeanFactory是眾多IoC容器子類的典型代表。在Mini版本中我只做了一個簡單的設計,就是定義頂層的IoC快取,也就是一個Map,屬性名字也和原生Spring保持一致,定義為beanDefinitionMap,以方便大家對比理解。


package com.tom.spring.formework.beans.support;

import com.tom.spring.formework.beans.config.GPBeanDefinition;
import com.tom.spring.formework.context.support.GPAbstractApplicationContext;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class GPDefaultListableBeanFactory extends GPAbstractApplicationContext{

    //儲存註冊資訊的BeanDefinition
    protected final Map<String, GPBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, GPBeanDefinition>();
		
}

4.3 GPApplicationContext

ApplicationContext是直接接觸使用者的入口,主要實現DefaultListableBeanFactory的refresh()方法和BeanFactory的getBean()方法,完成IoC、DI、AOP的銜接。


package com.tom.spring.formework.context;

import com.tom.spring.formework.annotation.GPAutowired;
import com.tom.spring.formework.annotation.GPController;
import com.tom.spring.formework.annotation.GPService;
import com.tom.spring.formework.beans.GPBeanWrapper;
import com.tom.spring.formework.beans.config.GPBeanPostProcessor;
import com.tom.spring.formework.core.GPBeanFactory;
import com.tom.spring.formework.beans.config.GPBeanDefinition;
import com.tom.spring.formework.beans.support.GPBeanDefinitionReader;
import com.tom.spring.formework.beans.support.GPDefaultListableBeanFactory;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 按之前原始碼分析的套路,IoC、DI、MVC、AOP
 */
public class GPApplicationContext extends GPDefaultListableBeanFactory implements GPBeanFactory {

    private String [] configLoactions;
    private GPBeanDefinitionReader reader;

    //單例的IoC容器快取
    private Map<String,Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>();
		
    //通用的IoC容器
    private Map<String,GPBeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<String, GPBeanWrapper>();

    public GPApplicationContext(String... configLoactions){
		
        this.configLoactions = configLoactions;
				
        try {
            refresh();
        } catch (Exception e) {
            e.printStackTrace();
        }
				
    }


    @Override
    public void refresh() throws Exception{
		
        //1. 定位,定位配置檔案
        reader = new GPBeanDefinitionReader(this.configLoactions);

        //2. 載入配置檔案,掃描相關的類,把它們封裝成BeanDefinition
        List<GPBeanDefinition> beanDefinitions = reader.loadBeanDefinitions();

        //3. 註冊,把配置資訊放到容器裡面(偽IoC容器)
        doRegisterBeanDefinition(beanDefinitions);

        //4. 把不是延時載入的類提前初始化
        doAutowrited();
				
    }

    //只處理非延時載入的情況
    private void doAutowrited() {
		
        for (Map.Entry<String, GPBeanDefinition> beanDefinitionEntry : super.beanDefinitionMap.entrySet()) {
				
           String beanName = beanDefinitionEntry.getKey();
					 
           if(!beanDefinitionEntry.getValue().isLazyInit()) {
					 
               try {
							 
                   getBean(beanName);
									 
               } catch (Exception e) {
							 
                   e.printStackTrace();
									 
               }
							 
           }
					 
        }
				
    }

    private void doRegisterBeanDefinition(List<GPBeanDefinition> beanDefinitions) throws Exception {

        for (GPBeanDefinition beanDefinition: beanDefinitions) {
				
            if(super.beanDefinitionMap.containsKey(beanDefinition.getFactoryBeanName())){
                throw new Exception("The “" + beanDefinition.getFactoryBeanName() + "” is exists!!");
            }
            super.beanDefinitionMap.put(beanDefinition.getFactoryBeanName(),beanDefinition);
						
        }
				
        //到這裡為止,容器初始化完畢
    }
		
    public Object getBean(Class<?> beanClass) throws Exception {
		
        return getBean(beanClass.getName());
				
    }

    //依賴注入,從這裡開始,讀取BeanDefinition中的資訊
    //然後通過反射機制建立一個例項並返回
    //Spring做法是,不會把最原始的物件放出去,會用一個BeanWrapper來進行一次包裝
    //裝飾器模式:
    //1. 保留原來的OOP關係
    //2. 需要對它進行擴充套件、增強(為了以後的AOP打基礎)
    public Object getBean(String beanName) throws Exception {

        return null;
    }

    public String[] getBeanDefinitionNames() {
		
        return this.beanDefinitionMap.keySet().toArray(new String[this.beanDefinitionMap. size()]);
				
    }

    public int getBeanDefinitionCount(){
		
        return this.beanDefinitionMap.size();
				
    }

    public Properties getConfig(){
		
        return this.reader.getConfig();
				
    }
		
}

4.4 GPBeanDefinitionReader

根據約定,BeanDefinitionReader主要完成對application.properties配置檔案的解析工作,實現邏輯非常簡單。通過構造方法獲取從ApplicationContext傳過來的locations配置檔案路徑,然後解析,掃描並儲存所有相關的類並提供統一的訪問入口。


package com.tom.spring.formework.beans.support;

import com.tom.spring.formework.beans.config.GPBeanDefinition;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

//對配置檔案進行查詢、讀取、解析
public class GPBeanDefinitionReader {

    private List<String> registyBeanClasses = new ArrayList<String>();

    private Properties config = new Properties();

    //固定配置檔案中的key,相對於XML的規範
    private final String SCAN_PACKAGE = "scanPackage";

    public GPBeanDefinitionReader(String... locations){
		
        //通過URL定位找到其所對應的檔案,然後轉換為檔案流
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(locations[0]. replace("classpath:",""));
        try {
            config.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != is){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        doScanner(config.getProperty(SCAN_PACKAGE));
				
    }

    private void doScanner(String scanPackage) {
		
        //轉換為檔案路徑,實際上就是把.替換為/
        URL url = this.getClass().getClassLoader().getResource("/" + scanPackage.replaceAll ("\\.","/"));
        File classPath = new File(url.getFile());
        for (File file : classPath.listFiles()) {
            if(file.isDirectory()){
                doScanner(scanPackage + "." + file.getName());
            }else{
                if(!file.getName().endsWith(".class")){ continue;}
                String className = (scanPackage + "." + file.getName().replace(".class",""));
                registyBeanClasses.add(className);
            }
        }
				
    }

    public Properties getConfig(){
		
        return this.config;
				
    }

    //把配置檔案中掃描到的所有配置資訊轉換為GPBeanDefinition物件,以便於之後的IoC操作
    public List<GPBeanDefinition> loadBeanDefinitions(){
		
        List<GPBeanDefinition> result = new ArrayList<GPBeanDefinition>();
        try {
				
            for (String className : registyBeanClasses) {
                Class<?> beanClass = Class.forName(className);
                if(beanClass.isInterface()) { continue; }

                result.add(doCreateBeanDefinition(toLowerFirstCase(beanClass.getSimpleName()), beanClass.getName()));

                Class<?> [] interfaces = beanClass.getInterfaces();
                for (Class<?> i : interfaces) {
                    result.add(doCreateBeanDefinition(i.getName(),beanClass.getName()));
                }

            }
						
        }catch (Exception e){
            e.printStackTrace();
        }
				
        return result;
				
    }


    //把每一個配置資訊解析成一個BeanDefinition
    private GPBeanDefinition doCreateBeanDefinition(String factoryBeanName,String beanClassName){
		
        GPBeanDefinition beanDefinition = new GPBeanDefinition();
        beanDefinition.setBeanClassName(beanClassName);
        beanDefinition.setFactoryBeanName(factoryBeanName);
        return beanDefinition;
				
    }

    //將類名首字母改為小寫
    //為了簡化程式邏輯,就不做其他判斷了,大家瞭解就好
    private String toLowerFirstCase(String simpleName) {
		
        char [] chars = simpleName.toCharArray();
        //因為大小寫字母的ASCII碼相差32
        //而且大寫字母的ASCII碼要小於小寫字母的ASCII碼
        //在Java中,對char做算術運算,實際上就是對ASCII碼做算術運算
        chars[0] += 32;
        return String.valueOf(chars);
				
    }

}

4.5 GPApplicationContextAware

相信很多“小夥伴”都用過ApplicationContextAware介面,主要是通過實現偵聽機制得到一個回撥方法,從而得到IoC容器的上下文,即ApplicationContext。在這個Mini版本中只是做了一個頂層設計,告訴大家這樣一種現象,並沒有做具體實現。這不是本書的重點,感興趣的“小夥伴”可以自行嘗試。


package com.tom.spring.formework.context;

/**
 * 通過解耦方式獲得IoC容器的頂層設計
 * 後面將通過一個監聽器去掃描所有的類,只要實現了此介面,
 * 將自動呼叫setApplicationContext()方法,從而將IoC容器注入目標類中
 */
public interface GPApplicationContextAware {

    void setApplicationContext(GPApplicationContext applicationContext);
		
}

關注微信公眾號『 Tom彈架構 』回覆“Spring”可獲取完整原始碼。

Tom彈架構

本文為“Tom彈架構”原創,轉載請註明出處。技術在於分享,我分享我快樂!
如果本文對您有幫助,歡迎關注和點贊;如果您有任何建議也可留言評論或私信,您的支援是我堅持創作的動力。關注微信公眾號『 Tom彈架構 』可獲取更多技術乾貨!

原創不易,堅持很酷,都看到這裡了,小夥伴記得點贊、收藏、在看,一鍵三連加關注!如果你覺得內容太乾,可以分享轉發給朋友滋潤滋潤!