Spring源码构建教程

1、下载官方源码

1. 官方源码地址：https://github.com/spring-projects/spring-framework

2、安装Gradle

1. 下载并解压，下载地址：https://gradle.org/releases/，下载完毕后在本地解压即可
2. 配置环境变量：GRADLE_HOME 变量值为Gradle文件解压的实际路径，在系统变量 path中加入：%GRADLE_HOME%\bin; 在cmd输入gradle -v验证是否安装成功
3. 配置Gradle仓库源

在Gradle安装目录下的 init.d 文件夹下，新建一个 init.gradle 文件，里面填写以下配置。

allprojects {
    repositories {
        maven { url 'H:/maven/maven-repository'}
        mavenLocal()
        maven { name "Alibaba" ; url "https://maven.aliyun.com/repository/public" }
        maven { name "Bstek" ; url "http://nexus.bsdn.org/content/groups/public/" }
        mavenCentral()
    }

    buildscript { 
        repositories { 
            maven { name "Alibaba" ; url 'https://maven.aliyun.com/repository/public' }
            maven { name "Bstek" ; url 'http://nexus.bsdn.org/content/groups/public/' }
            maven { name "M2" ; url 'https://plugins.gradle.org/m2/' }
        }
    }
}

repositories 中写的是获取 jar 包的顺序。
先是本地的 Maven 仓库路径；

• 接着的 mavenLocal() 是获取 Maven 本地仓库的路径，应该是和第一条一样，但是不冲突；
• 第三条和第四条是从国内和国外的网络上仓库获取；
• 最后的 mavenCentral() 是从Apache提供的中央仓库获取 jar 包。

3、IDEA导入

1. 打开Idea，选择File—> New --> Project form Existing Sources

2. 选择要导入的spring-framework-5.1.x源码项目

3. 选择使用Gradle项目

4. 等待下载安装即可。

4、编译工程

顺序：core-oxm-context-beans-aspects-aop

根据上图命令按顺序编译指定工程即可，我们这边只看IoC以及AOP源码，所以不需要全部模块。

5、新建Spring-Module

项目右键-New Module-选择Gradle java

6、测试

ItBean

public class ItBean {

    private ScBean scBean;

    public void setScBean(ScBean scBean) {
        this.scBean = scBean;
    }

    /**
     * 构造函数
     */
    public ItBean(){
        System.out.println("ItBean 构造器...");
    }
}

LogUtils

public class LogUtils {

    public void beforeMethod() {
        System.out.println("前置通知");
    }
}

MyBeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor的实现方法调用中......");
    }
}

MyBeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        System.out.println("BeanPostProcessor 实现类构造函数...");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("lagouBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中......");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if("lagouBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中......");
        }
        return bean;
    }
}

ScBean

public class ScBean implements InitializingBean, ApplicationContextAware {

    private ItBean itBean;

    public void setItBean(ItBean itBean) {
        this.itBean = itBean;
    }

    /**
     * 构造函数
     */
    public ScBean(){
        System.out.println("ScBean 构造器...");
    }


    /**
     * InitializingBean 接口实现
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("ScBean afterPropertiesSet...");
    }

    public void print() {
        System.out.println("print方法业务逻辑执行");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("setApplicationContext....");
    }
}

applicationContext.xml

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

    <!--循环依赖问题-->
    <bean id="scBean" class="com.sc.edu.ScBean">
        <property name="ItBean" ref="itBean"/>
    </bean>
    <bean id="itBean" class="com.sc.edu.ItBean">
        <property name="ScBean" ref="scBean"/>
    </bean>


    <bean id="myBeanFactoryPostProcessor" class="MyBeanFactoryPostProcessor"/>
    <bean id="myBeanPostProcessor" class="MyBeanPostProcessor"/>


    <bean id="lagouBean" class="LagouBean">
    </bean>


    <!--aop配置-->
    <!--横切逻辑-->
    <bean id="logUtils" class="LogUtils">
    </bean>

    <aop:config>
        <aop:aspect ref="logUtils">
            <aop:before method="beforeMethod" pointcut="execution(public void ScBean.print())"/>
        </aop:aspect>
    </aop:config>


</beans>

测试类

public class IocTest {

    /**
     *  Ioc 容器源码分析基础案例
     */
    @Test
    public void testIoC() {
        // ApplicationContext是容器的高级接口，BeanFacotry（顶级容器/根容器，规范了/定义了容器的基础行为）
        // Spring应用上下文，官方称之为 IoC容器（错误的认识：容器就是map而已；准确来说，map是ioc容器的一个成员，
        // 叫做单例池, singletonObjects,容器是一组组件和过程的集合，包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作流程）

        /**
         * Ioc容器创建管理Bean对象的，Spring Bean是有生命周期的
         * 构造器执行、初始化方法执行、Bean后置处理器的before/after方法、：AbstractApplicationContext#refresh#finishBeanFactoryInitialization
         * Bean工厂后置处理器初始化、方法执行：AbstractApplicationContext#refresh#invokeBeanFactoryPostProcessors
         * Bean后置处理器初始化：AbstractApplicationContext#refresh#registerBeanPostProcessors
         */

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
        System.out.println(lagouBean);
    }



    /**
     *  Ioc 容器源码分析基础案例
     */
    @Test
    public void testAOP() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
        lagouBean.print();
    }
}

我只是觉得自己不仅仅如此，所以在努力呀！