實作Spring底層機制-01

主要實作：初始化IOC容器+依賴注入+BeanPostProcessor機制+AOP

前面我們實際上已經使用代碼簡單實作了：

1. Spring XML 注入 bean （Spring基本介紹02）
2. Spring 注解方式注入 bean （Spring管理Bean-IOC-04）
3. Spring AOP 動態代理實作 （AOP-01）

1.引出問題

1.1原生Spring如何實作依賴注入、singleton和prototype

例子

1.創建新的Maven專案：

2.在pom.xml檔案中添加 spring 開發的基本包：

<dependencies>
    <!--加入 spring 開發的基本包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>
    <!--加入spring開發切面編程需要的包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

3.src/main/java/ 目錄下創建包 com/li/component，在該包下分別創建UserDao.java、UserService.java、UserAction.java

UserDao：

package com.li.component;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Repository
@Component
public class UserDao {

    public void hi() {
        System.out.println("UserDao-hi()---");
    }
}

UserService：

package com.li.component;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Service
@Component
public class UserService {
    //定義屬性
    //也可以使用 @Resource
    @Autowired
    private UserDao userDao;

    public void m1() {
        userDao.hi();
    }
}

UserAction：

package com.li.component;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 * 一個 Controller
 */
//也可以使用 @Controller
@Component
public class UserAction {
}

4.在 src/main/resources 目錄下創建 spring 的容器檔案 beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置自動掃描的包，同時引入對應的名稱空間-->
    <!--說明：
        1.如果是普通的java專案，beans.xml 放在src 目錄下即可
        2.如果是maven專案，beans.xml檔案就要放在 src/main/resources 目錄下-->
    <context:component-scan base-package="com.li.component"/>

</beans>

5.測驗類中獲取配置的bean，并輸出物件的地址值

package com.li;

import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        //測驗是否可以得到spring容器中的bean
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = (UserAction) ioc.getBean("userAction");
        UserAction userAction2 = (UserAction) ioc.getBean("userAction");

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);
    }
}

可以看到通過“userAction”名稱獲取的物件的地址值相同，這說明它們實際上是同一個物件

在默認情況下，我們配置的@Component，@Controller，@Service，@Repository 是單例的，即spring的ioc容器只會創建一個bean實體

6.如果我們希望將一個類配置為多例的，怎么辦呢？

只需要在對應的類頭部添加 @Scope(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/prototype")，表示以多實體的形式回傳該類的bean物件

package com.li.component;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/prototype")
public class UserAction {
}

現在我們重新運行測驗類，可以看到通過“userAction”名稱獲取的物件的地址值不相同，這說明它們是不同的物件，

7.我們在測驗類中獲取userService物件，并呼叫m1方法

package com.li;

import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {   
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) ioc.getBean("userService");
        
        System.out.println("userService=" + userService);
        //測驗依賴注入
        System.out.print("userService物件呼叫m1()=");
        userService.m1();

    }
}

輸出如下，成功獲取到userService物件，并且呼叫m1方法成功，這說明UserService類中的userDao屬性成功通過@AutoWired 注解裝配，

問題一：spring底層是如何通過注解來完成多例或者單例物件的創建的？

問題二：Spring容器如何實作依賴注入？

1.2原生Spring如何實作BeanPostProcessor

BeanPosecessor詳見Spring管理Bean-IOC-03-2.16后置處理器

1. 后置處理器會在 bean 初始化方法呼叫前 和 初始化方法呼叫后 被呼叫
2. 后置處理器物件會作用在容器組態檔的所有bean物件中（即使bean物件沒有初始化方法）

例子

1.創建一個后置處理器：

package com.li.process;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 * 一個后置處理器
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    //在 Bean的 init初始化方法前被呼叫
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization 被呼叫 " + beanName + " bean= " + bean.getClass());
        return bean;
    }

    //在 Bean的 init初始化方法后被呼叫
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization 被呼叫 " + beanName + " bean= " + bean.getClass());
        return bean;
    }
}

要使用后置處理器，需要進行配置，配置的方式有兩種：（1）在xml容器檔案中進行配置（2）添加注解

使用注解時，還要保證掃描的范圍要覆寫到該類

2.在UserService類中添加初始化方法：

package com.li.component;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Service
@Component
public class UserService {
    //定義屬性
    //也可以使用 @Resource
    @Autowired
    private UserDao userDao;

    public void m1() {
        userDao.hi();
    }

    //初始化方法-名稱隨意，需要@PostConstruct指定init為初始化方法
    @PostConstruct
    public void init(){
        System.out.println("UserService-init()");
    }
}

3.在測驗類中進行測驗：

package com.li;

import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {

        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

        UserAction userAction = (UserAction) ioc.getBean("userAction");
        UserAction userAction2 = (UserAction) ioc.getBean("userAction");

        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);

        UserDao userDao = (UserDao) ioc.getBean("userDao");
        System.out.println("userDao=" + userDao);

        UserService userService = (UserService) ioc.getBean("userService");
        System.out.println("userService=" + userService);

        System.out.print("userService物件呼叫m1()=");
        userService.m1();

    }
}

如下，后置處理器物件會作用在容器組態檔的所有bean物件中（即使bean物件沒有初始化方法），根據之前的配置，容器中一共有四個物件（UserAction為多例），因此一共呼叫了八次，

這里userAction物件因為是多例的，強制為懶加載，因此在被獲取時（getBean()）才創建，因此排在最后，

問題三：原生Spring如何實作BeanPostProcessor？

1.3原生spring如何實作AOP

例子-在上述代碼的基礎上添加如下內容

1.SmartAnimal 介面：

package com.li.aop;

/**
 * @author 李
 * @version 1.0
 */
public interface SmartAnimal {
    public float getSum(float i, float j);

    public float getSub(float i, float j);
}

2.SmartDog 實作類：

package com.li.aop;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
@Component
public class SmartDog implements SmartAnimal {
    @Override
    public float getSum(float i, float j) {
        float res = i + j;
        System.out.println("SmartDog-getSum()-res=" + res);
        return res;
    }

    @Override
    public float getSub(float i, float j) {
        float res = i - j;
        System.out.println("SmartDog-getSub()-res=" + res);
        return res;
    }
}

3.SmartAnimalAspect 切面類：

package com.li.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 切面類
 */
@Component
@Aspect
public class SmartAnimalAspect {
    @Pointcut(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/execution(public float com.li.aop.SmartAnimal.*(float,float))")
    public void myPointCut() {
    }

    //前置通知
    @Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/myPointCut()")
    public void before(JoinPoint joinpoint) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面類-before()-" + signature.getName()
                + "-引數-" + Arrays.toString(joinpoint.getArgs()));
    }

    //回傳通知
    @AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/myPointCut()", returning = "res")
    public void afterReturning(JoinPoint joinpoint, Object res) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面類-afterReturning()-" + signature.getName() + "-res-" + res);
    }

    //例外通知
    @AfterThrowing(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/myPointCut()", throwing = "res")
    public void afterThrowing(JoinPoint joinpoint, Throwable res) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面類-afterThrowing()-" + signature.getName() + "-res-" + res);
    }

    //最終通知
    @After(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/27/myPointCut()")
    public void after(JoinPoint joinpoint) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面類-after()-" + signature.getName());
    }
}

4.在容器檔案中開啟基于注解的aop功能：

<!--配置自動掃描的包，同時引入對應的名稱空間-->
<context:component-scan base-package="com.li.aop"/>

<!--開啟基于注解的 aop 功能-->
<aop:aspectj-autoproxy/>

5.進行測驗：

package com.li;

import com.li.aop.SmartAnimal;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        SmartAnimal smartDogProxy = ioc.getBean(SmartAnimal.class);
        smartDogProxy.getSum(101, 99);
    }
}

測驗結果：

前面的輸出是因為之前配置了后置處理器，它在創建ioc容器時會被呼叫，對所有bean物件生效，

紅框處，后置處理器的 postProcessBeforeInitialization() 方法呼叫時，bean物件的還是原生的型別，但是到了 postProcessAfterInitialization() 方法呼叫時，已經變成了代理物件 $Proxy，這說明后置處理器和aop切面編程有著密切的關系，

簡單分析AOP和BeanPostProcessor的關系：

1.AOP實作Spring可以通過一個類加入注解@EnableAspectJAutoProxy來執行

2.我們來追一下@EnableAspectJAutoProxy

3.看一下 AnnotationAwareAspectJAutoProxyCreator 的類圖

4.解讀：

（1）AOP底層是基于BeanPostProcessor機制的

（2）即在Bean物件創建好后，根據是否需要AOP處理，決定回傳代理物件還是原生的Bean物件

（3）在回傳代理物件時，就可以根據要代理的類和方法來回傳

（4）這個機制并不難，本質就是BeanPostProcessor 機制+動態代理技術

2.Spring整體架構分析

標籤：其他

上一篇：C++Day12 虛擬繼承記憶體布局測驗

下一篇：python圖片拼接