2. 程式人生 > >自己動手實現的 Spring IOC 和 AOP - 上篇

自己動手實現的 Spring IOC 和 AOP - 上篇

阿新 • • 發佈：2018-12-23

1. 背景

我在大四實習的時候開始接觸 J2EE 方面的開發工作，也是在同時期接觸並學習 Spring 框架，到現在也有快有兩年的時間了。不過之前沒有仿寫過 Spring IOC 和 AOP，只是巨集觀上對 Spring IOC 和 AOP 原理有一定的認識。所以為了更進一步理解 Spring IOC 和 AOP 原理。在工作之餘，參考了一些資料和程式碼，動手實現了一個簡單的 IOC 和 AOP，並實現瞭如下功能：

  1. 根據 xml 配置檔案載入相關 bean
  2. 對 BeanPostProcessor 型別的 bean 提供支援
  3. 對 BeanFactoryAware 型別的 bean 提供支援
  4. 實現了基於 JDK 動態代理的 AOP
  5. 整合了 IOC 和 AOP，使得二者可很好的協同工作

在實現自己的 IOC 和 AOP 前，我的想法比較簡單，就是實現一個非常簡單的 IOC 和 AOP，哪怕是幾十行程式碼實現的都行。後來實現後，感覺還很有意思的。不過那個實現太過於簡單，和 Spring IOC，AOP 相去甚遠。後來想了一下，不能僅滿足那個簡單的實現，於是就有了這個仿寫專案。相對來說仿寫的程式碼要複雜了一些，功能也多了一點，看起來也有點樣子的。儘管仿寫出的專案仍然是玩具級，不過寫仿寫的過程中，還是學到了一些東西。總體上來說，收穫還是很大的。在接下來文章中，我也將從易到難，實現不同版本的 IOC 和 AOP。好了，不多說了，開始幹活。

 2. 簡單的 IOC 和 AOP 實現

 2.1 簡單的 IOC

先從簡單的 IOC 容器實現開始，最簡單的 IOC 容器只需4步即可實現，如下：

  1. 載入 xml 配置檔案，遍歷其中的標籤
  2. 獲取標籤中的 id 和 class 屬性，載入 class 屬性對應的類，並建立 bean
  3. 遍歷標籤中的標籤，獲取屬性值，並將屬性值填充到 bean 中
  4. 將 bean 註冊到 bean 容器中

如上所示，僅需4步即可，是不是覺得很簡單。好了，Talk is cheap, Show me the code. 接下來要上程式碼了。不過客官別急，上程式碼前，容我對程式碼結構做一下簡單介紹：

1
2
3
4
5

SimpleIOC     // IOC 的實現類，實現了上面所說的4個步驟
SimpleIOCTest    // IOC 的測試類
Car           // IOC 測試使用的 bean
Wheel         // 同上 
ioc.xml       // bean 配置檔案

容器實現類 SimpleIOC 的程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

public class SimpleIOC {

    private Map<String, Object> beanMap = new HashMap<>();

    public SimpleIOC(String location) throws Exception {
        loadBeans(location);
    }

    public Object getBean(String name) {
        Object bean = beanMap.get(name);
        if (bean == null) {
            throw new IllegalArgumentException("there is no bean with name " + name);
        }

        return bean;
    }

    private void loadBeans(String location) throws Exception {
        // 載入 xml 配置檔案
        InputStream inputStream = new FileInputStream(location);
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        Element root = doc.getDocumentElement();
        NodeList nodes = root.getChildNodes();

        // 遍歷 <bean> 標籤
        for (int i = 0; i < nodes.getLength(); i++) {
            Node node = nodes.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                String id = ele.getAttribute("id");
                String className = ele.getAttribute("class");
                
                // 載入 beanClass
                Class beanClass = null;
                try {
                    beanClass = Class.forName(className);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                    return;
                }

                   // 建立 bean
                Object bean = beanClass.newInstance();

                // 遍歷 <property> 標籤
                NodeList propertyNodes = ele.getElementsByTagName("property");
                for (int j = 0; j < propertyNodes.getLength(); j++) {
                    Node propertyNode = propertyNodes.item(j);
                    if (propertyNode instanceof Element) {
                        Element propertyElement = (Element) propertyNode;
                        String name = propertyElement.getAttribute("name");
                        String value = propertyElement.getAttribute("value");

                            // 利用反射將 bean 相關欄位訪問許可權設為可訪問
                        Field declaredField = bean.getClass().getDeclaredField(name);
                        declaredField.setAccessible(true);

                        if (value != null && value.length() > 0) {
                            // 將屬性值填充到相關欄位中
                            declaredField.set(bean, value);
                        } else {
                            String ref = propertyElement.getAttribute("ref");
                            if (ref == null || ref.length() == 0) {
                                throw new IllegalArgumentException("ref config error");
                            }
                            
                            // 將引用填充到相關欄位中
                            declaredField.set(bean, getBean(ref));
                        }

                        // 將 bean 註冊到 bean 容器中
                        registerBean(id, bean);
                    }
                }
            }
        }
    }

    private void registerBean(String id, Object bean) {
        beanMap.put(id, bean);
    }
}

容器測試使用的 bean 程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Car {
    private String name;
    private String length;
    private String width;
    private String height;
    private Wheel wheel;
    
    // 省略其他不重要程式碼
}

public class Wheel {
    private String brand;
    private String specification ;
    
    // 省略其他不重要程式碼
}

bean 配置檔案 ioc.xml 內容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<beans>
    <bean id="wheel" class="com.titizz.simulation.toyspring.Wheel">
        <property name="brand" value="Michelin" />
        <property name="specification" value="265/60 R18" />
    </bean>

    <bean id="car" class="com.titizz.simulation.toyspring.Car">
        <property name="name" value="Mercedes Benz G 500"/>
        <property name="length" value="4717mm"/>
        <property name="width" value="1855mm"/>
        <property name="height" value="1949mm"/>
        <property name="wheel" ref="wheel"/>
    </bean>
</beans>

IOC 測試類 SimpleIOCTest：

1
2
3
4
5
6
7
8
9
10
11

public class SimpleIOCTest {
    @Test
    public void getBean() throws Exception {
        String location = SimpleIOC.class.getClassLoader().getResource("spring-test.xml").getFile();
        SimpleIOC bf = new SimpleIOC(location);
        Wheel wheel = (Wheel) bf.getBean("wheel");
        System.out.println(wheel);
        Car car = (Car) bf.getBean("car");
        System.out.println(car);
    }
}

測試結果：

以上是簡單 IOC 實現的全部內容，難度不大，程式碼也不難看懂，這裡不再多說了。下面說說簡單 AOP 的實現。

 2.2 簡單的 AOP 實現

AOP 的實現是基於代理模式的，這一點相信大家應該都知道。代理模式是AOP實現的基礎，代理模式不難理解，這裡就不花篇幅介紹了。在介紹 AOP 的實現步驟之前，先引入 Spring AOP 中的一些概念，接下來我們會用到這些概念。

通知（Advice）

1
2
3
4
5
6
7

通知定義了要織入目標物件的邏輯，以及執行時機。
Spring 中對應了 5 種不同型別的通知：
· 前置通知（Before）：在目標方法執行前，執行通知
· 後置通知（After）：在目標方法執行後，執行通知，此時不關係目標方法返回的結果是什麼
· 返回通知（After-returning）：在目標方法執行後，執行通知
· 異常通知（After-throwing）：在目標方法丟擲異常後執行通知
· 環繞通知（Around）: 目標方法被通知包裹，通知在目標方法執行前和執行後都被會呼叫

切點（Pointcut）

1
2

如果說通知定義了在何時執行通知，那麼切點就定義了在何處執行通知。所以切點的作用就是
通過匹配規則查詢合適的連線點（Joinpoint），AOP 會在這些連線點上織入通知。

切面（Aspect）

1

切面包含了通知和切點，通知和切點共同定義了切面是什麼，在何時，何處執行切面邏輯。

說完概念，接下來我們來說說簡單 AOP 實現的步驟。這裡 AOP 是基於 JDK 動態代理實現的，只需3步即可完成：

  1. 定義一個包含切面邏輯的物件，這裡假設叫 logMethodInvocation
  2. 定義一個 Advice 物件（實現了 InvocationHandler 介面），並將上面的 logMethodInvocation 和 目標物件傳入
  3. 將上面的 Adivce 物件和目標物件傳給 JDK 動態代理方法，為目標物件生成代理

上面步驟比較簡單，不過在實現過程中，還是有一些難度的，這裡要引入一些輔助接口才能實現。接下來就來介紹一下簡單 AOP 的程式碼結構：

1
2
3
4
5
6
7

MethodInvocation 介面  // 實現類包含了切面邏輯，如上面的 logMethodInvocation
Advice 介面        // 繼承了 InvocationHandler 介面
BeforeAdvice 類    // 實現了 Advice 介面，是一個前置通知
SimpleAOP 類       // 生成代理類
SimpleAOPTest      // SimpleAOP 從測試類
HelloService 介面   // 目標物件介面
HelloServiceImpl   // 目標物件

MethodInvocation 介面程式碼：

1
2
3

public interface MethodInvocation {
    void invoke();
}

Advice 介面程式碼：

1

public interface Advice extends InvocationHandler {}

BeforeAdvice 實現程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class BeforeAdvice implements Advice {
    private Object bean;
    private MethodInvocation methodInvocation;

    public BeforeAdvice(Object bean, MethodInvocation methodInvocation) {
        this.bean = bean;
        this.methodInvocation = methodInvocation;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在目標方法執行前呼叫通知
        methodInvocation.invoke();
        return method.invoke(bean, args);
    }
}

SimpleAOP 實現程式碼：

1
2
3
4
5
6

public class SimpleAOP {
    public static Object getProxy(Object bean, Advice advice) {
        return Proxy.newProxyInstance(SimpleAOP.class.getClassLoader(), 
                bean.getClass().getInterfaces(), advice);
    }
}

HelloService 介面，及其實現類程式碼：

1
2
3
4
5
6
7
8
9
10

public interface HelloService {
    void sayHelloWorld();
}

public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHelloWorld() {
        System.out.println("hello world!");
    }
}

SimpleAOPTest 程式碼:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class SimpleAOPTest {
    @Test
    public void getProxy() throws Exception {
        // 1. 建立一個 MethodInvocation 實現類
        MethodInvocation logTask = () -> System.out.println("log task start");
        HelloServiceImpl helloServiceImpl = new HelloServiceImpl();
        
        // 2. 建立一個 Advice
        Advice beforeAdvice = new BeforeAdvice(helloServiceImpl, logTask);
        
        // 3. 為目標物件生成代理
        HelloService helloServiceImplProxy = (HelloService) SimpleAOP.getProxy(helloServiceImpl,beforeAdvice);
        
        helloServiceImplProxy.sayHelloWorld();
    }
}

輸出結果：

以上實現了簡單的 IOC 和 AOP，不過實現的 IOC 和 AOP 還很簡單，且只能獨立執行。在下一篇文章中，我將實現一個較為複雜的 IOC 和 AOP，大家如果有興趣可以去看看。好了，本篇文章到此結束。

 附錄：Spring 原始碼分析文章列表

 Ⅰ. IOC

更新時間 標題
2018-05-30 Spring IOC 容器原始碼分析系列文章導讀
2018-06-01 Spring IOC 容器原始碼分析 - 獲取單例 bean
2018-06-04 Spring IOC 容器原始碼分析 - 建立單例 bean 的過程
2018-06-06 Spring IOC 容器原始碼分析 - 建立原始 bean 物件
2018-06-08 Spring IOC 容器原始碼分析 - 迴圈依賴的解決辦法
2018-06-11 Spring IOC 容器原始碼分析 - 填充屬性到 bean 原始物件
2018-06-11 Spring IOC 容器原始碼分析 - 餘下的初始化工作

 Ⅱ. AOP

更新時間 標題
2018-06-17 Spring AOP 原始碼分析系列文章導讀
2018-06-20 Spring AOP 原始碼分析 - 篩選合適的通知器
2018-06-20 Spring AOP 原始碼分析 - 建立代理物件
2018-06-22 Spring AOP 原始碼分析 - 攔截器鏈的執行過程

 Ⅲ. MVC

更新時間 標題
2018-06-29 Spring MVC 原理探祕 - 一個請求的旅行過程
2018-06-30 Spring MVC 原理探祕 - 容器的建立過程

from:http://www.tianxiaobo.com/2018/01/18/%E8%87%AA%E5%B7%B1%E5%8A%A8%E6%89%8B%E5%AE%9E%E7%8E%B0%E7%9A%84-Spring-IOC-%E5%92%8C-AOP-%E4%B8%8A%E7%AF%87/ 

相關推薦

自己動手實現的 Spring IOC 和 AOP - 上篇

1. 背景 我在大四實習的時候開始接觸 J2EE 方面的開發工作，也是在同時期接觸並學習 Spring 框架，到現在也有快有兩年的時間了。不過之前沒有仿寫過 Spring IOC 和 AOP，只是巨集觀上對 Spring IOC 和 AOP 原理有一定的認識。所以為了更進一步理解 Spring

Spring IoC和AOP使用擴展

處理類型 can 初始 ext @aspectj 環繞增強 組件 ont qualifier 　　Spring提供了設值註入，構造註入等依賴註入方式。 　　使用p命令空間可以簡化屬性註入的配置。 　　Spring提供的增強處理類型包括前置增強，異常拋出增強，環繞增強，最終增

Spring IoC和AOP使用擴展（二）

cor ima 容器 常用 size ops ali class sta 一、IOC的實現方式： 　　Set註入：熟悉必須有公共set方法； 　　構造器註入：可以根據構造器參數名稱、下標註入； 　　p命名空間註入：要求有set方法； 　　 　　 　　 　　內部bean的實現

【Java】模擬Sping，實現其IOC和AOP核心（一）

在這裡我要實現的是Spring的IOC和AOP的核心，而且有關IOC的實現，註解+XML能混合使用！ 參考資料： IOC：控制反轉（Inversion of Control，縮寫為IoC），是面向物件程式設計中的一種設計原則，可以用來減低計算機程式碼之間的耦合度。其中最常見的方式叫做依賴注入（D

Spring IOC 和 AOP

文件 編程思想 dep nbsp 織入 擴展 con 集中管理 重復 一.　　IOC 　　1.　概念及原理 　　IOC: Inversion of Control(控制反轉)是一種設計思想,就是容器控制應用程序所需要的外部資源的創建和管理,然後將其反轉給應用程序.對象及其依

對Spring Ioc和AOP的理解

轉載自：https://blog.csdn.net/u013148153/article/details/80293587  Ioc和AOP是Spring的兩大核心，面試的時候也經常被問及對這兩個概念的理解，因此也記下我對此的理解，方便以後查漏補缺。  一、控制反轉(Ioc,

Spring IOC和AOP

Spring提供了很多輕量級應用開發實踐的工具集合，這些工具集以介面、抽象類、或工具類的形式存在於Spring中。通過使用這些工具集，可以實現應用程式與各種開源技術及框架間的友好整合。比如有關jdbc封裝的資料訪問工具Spring JDBC，有關編寫單元測試的spring t

【Java】模擬Sping，實現其IOC和AOP核心（二）

接著上一篇，在上一篇完成了有關IOC的註解實現，這一篇用XML的方式實現IOC，並且完成AOP。 簡易的IOC框圖 註解的方式實現了左邊的分支，那麼就剩下右邊的XML分支： XmlContext：這個類是也是AbstractApplicationContext的子類，和AnnotationContext

Spring——IoC和Aop使用拓展

一、多種方式實現依賴注入 構造注入 設值注入 p名稱空間注入 1、構造注入：通過建構函式注入資料。 構造注入的優劣勢：構造注入的時效性好，在物件例項化時就得到所依賴的物件，便於在物件的初始化時就得到所依賴的物件，便於在物件的初始化方法中使用依賴物件；但受限於方法

關於spring IOC和AOP的解析原理和舉例

1.關於spring ioc  　這段時間也著實好好的看了下spring的相關書籍，對其也有了大概和初步的認識和理解，雖然之前也一直聽說spring是一個非常優秀的開源框架，可一直沒有機會學習和使用（是不是有點落伍了？呵呵），所以呢，這段時間就重點學習了spring（一個星期的時間

Spring IOC和AOP 原理徹底搞懂

Spring提供了很多輕量級應用開發實踐的工具集合，這些工具集以介面、抽象類、或工具類的形式存在於Spring中。通過使用這些工具集，可以實現應用程式與各種開源技術及框架間的友好整合。比如有關jdbc封裝的資料訪問工具Spring JDBC，有關編寫單元測試的

spring ioc和aop原理理解

ioc的意思是控制反轉，表示建立物件並不是new出來的，而是通過spring配置建立的，實現原理是xml配置檔案+SAX解析+工廠模式。aop的意思是面向切面程式設計，表示將封裝好的物件剖開，找出對多個物件產生影響的公共行為，並封裝成可重用的模組，這種被成為“切面”，切面將那

關於spring,IOC和AOP的解析原理和舉例

先從IOC說起，這個概念其實是從我們平常new一個物件的對立面來說的，我們平常使用物件的時候，一般都是直接使用關鍵字類new一個物件，那這樣有什麼壞處呢？其實很顯然的，使用new那麼就表示當前模組已經不知不覺的和new的物件耦合了，而我們通常都是更高層次的抽象模組

閉關修煉180天--手寫IOC和AOP(xml篇)

閉關修煉180天--手寫IOC和AOP(xml篇) 帝莘   首先先分享一波思維導圖，涵蓋了一些Spring的知識點，當然這裡並不全面，後期我會持續更新知識點。 在手寫實現IOC和AOP之前（也就是打造一個簡單的Spring框架），先簡單的瞭解一些Spring以及它的兩個核心思想IOC和AOP的

【Java】 Spring 框架初步學習總結（一）簡單實現 IoC 和 AOP

1.0 其中 表示 只需要 第一篇 否則 info fin pojo 　　Spring 是一個開源的設計層面的輕量級框架，Spring 的好處網上有太多，這裏就不在贅述。 　　IoC 控制反轉和 AOP 面向切面編程是 Spring 的兩個重要特性。 　　IoC（Inver

對於spring中IOC和AOP的理解及程式碼簡單實現

IoC（Inversion of Control）: 在傳統的java程式編寫中如果呼叫方法或類者，必須要對被呼叫者進行例項化，即必須要通過new 被呼叫者類，才能對被呼叫者類中的方法、成員進行操作。在開發某一個專案時必然會出現很多類來完善專案的需求，並且類與類

Spring 的 IOC 和 AOP的簡單實現

一、IOC 1、配置檔案實現IOC IOC ：控制反轉，將建立物件的控制權又之前的new轉移給Spring框架，目的是為了解耦。 匯入相應的Jar包。 匯入配置檔案applicationContext.xml  並進行配置如下： <?xml version="

Spring IOC和Spring AOP的實現原理(原始碼主線流程)

寫在前面      正本文參考了《spring技術內幕》和spring 4.0.5原始碼。本文只描述原理流程的主線部分，其他比如驗證，快取什麼可以具體參考原始碼理解。Spring IOC一、容器初始化      容器的初始化首先是在對應的構造器中進行，在application

理解Spring中的IOC和AOP

nfa 重復 高度 只需要 spring框架 aop 編程 靈活 攔截 我們是在使用Spring框架的過程中，其實就是為了使用IOC，依賴註入和AOP，面向切面編程，這兩個是Spring的靈魂。 主要用到的設計模式有工廠模式和代理模式 IOC就是典型的工廠模式，通過se

用通俗的語言解釋 Spring 中的 DI 、IOC 和AOP概念

private rgs 完成 編程 而是 無需 解決 情況 分離關註點 DI 所謂依賴，從程序的角度看，就是比如A要調用B的方法，那麽A就依賴於B，反正A要用到B，則A依賴於B。所謂倒置，你必須理解如果不倒置，會怎麽著，因為A必須要有B，才可以調用B，如果不倒置，意思就是A