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