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