本文節選自《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彈架構”原創，轉載請註明出處。技術在於分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。
原創不易，堅持很酷，都看到這裡了，小夥伴記得點贊、收藏、在看，一鍵三連加關注！如果你覺得內容太乾，可以分享轉發給朋友滋潤滋潤！