精华内容
下载资源
问答
  • 2022-02-17 09:17:42

    Spring源码搭建

    最近需求都整完,遂动起了阅读spring源代码的想法

    准备工具

    1. idea 2021.1.3 ,转战新的开发环境吧;
    2. java17
    3. spring最新源代码多尝试几次,或者直接使用git直接下载下来 ;

    spring源代码地址

    搭建步骤

    1. idea 2021.1.3 ,忽略,直接官网下载;
    2. java17安装 ;
    3. Gradle安装 ;
    4. spring最新源代码编译࿰
    更多相关内容
  • spring 源码中文注释

    2018-12-11 15:22:05
    spring 源码解析
  • spring源码

    2018-10-16 14:58:42
    springmvc的源码,采用典型的三层架构进行开发,最简单的增删改查,登陆、修改密码等
  • spring源码(注释+测试版)
  • aspectj
  • spring源代码

    2018-10-31 16:43:11
    spring5.0.6框架源代码,看好源代码就是关键,祝你成功
  • Spring 源代码解析

    2022-06-01 19:52:56
    Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码解析Spring 源代码...
  • spring源码深度解析(包含所有spring源码,带全部的注释以及案例,很适合入门级)
  • Spring源码分析.pdf

    2021-09-26 18:46:48
    Spring源码分析.pdf
  • spring源码中英文注释

    2020-01-12 07:34:32
    spring源码 中英文注释
  • Spring源码解析.zip

    2020-07-31 16:21:16
    spring源码解析。使用xmind进行代码整理。包含ioc,aop,tr相关代码部分。
  • spring源码注释中文

    2019-04-12 09:47:30
    spring源码带注释的,直接可以阅读,不需要重新编译。
  • spring 源码环境搭建

    2018-11-19 11:14:32
    想要读spring源码但是是又不知道如何下手的同学看过来。文档中介绍如何搭建spring源码环境。
  • NULL 博文链接:https://ylxy3058.iteye.com/blog/2224244
  • Spring源码

    2018-04-13 12:29:16
    Spring源码 Spring源码 Spring源码 Spring源码 Spring源码 Spring源码 Spring源码 Spring源码 Spring源码
  • 1、spring 的整体架构 2、spring的基本实现(xml的加载原理、标签解析、bean加载) 3、容器扩展 4、ioc和aop 5、事务 6、springmvc 7、dispatcherServlet
  • Spring源代码解析

    2019-12-30 21:02:23
    Spring源代码解析。Spring源代码解析
  • 因为直接下载下来的代码不能直接导入到IDEA,这个是可以直接导入的:打开IDEA,File->New->Project From Existing Sources…,选中Spring-framework文件夹,OK->Import project from external model,选中Gradle,...
  • spring 源码

    2018-05-13 10:27:11
    Spring是一个开放源代码的设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用。
  • Spring:Spring源码下载、保存、编译

    千次阅读 2021-10-21 20:07:21
    Spring源码下载、编译Spring源码下载Spring源码编译1、新增下载地址2、修改依赖地址三级目录 Spring源码下载 注意:Spring源码使用的是Gradle,而不是Maven。因此下载Spring源码之前可以先安装Gradle,参考:...

    Spring源码下载

    注意:Spring源码使用的是Gradle,而不是Maven。因此下载Spring源码之前可以先安装Gradle,注意安装的gradle版本与spring源码中gradle-wrapper.properties文件中指定的gradle版本一致。参考:Gradle的下载、安装和配置环境
    Spring源码gitee地址:https://gitee.com/mirrors/Spring-Framework
    Spring源码gitee仓库地址:

    https://gitee.com/mirrors/Spring-Framework.git
    

    Spring源码github地址:https://github.com/spring-projects/spring-framework
    Spring源码github仓库地址:

    https://github.com/spring-projects/spring-framework.git
    

    从远程仓库下载项目的流程,参考:idea下载git仓库中的项目

    Spring源码保存gitee仓库

    将下载的Spring源码保存到自己的gitee仓库中方便源码学习过程中对源码注释提交到gitee仓库。也可以保存调试Spring源码的测试代码。
    gtiee个人仓库的创建参考:将本地项目提交到Gitee远程仓库

    1、需改远程仓库地址

    选中Git中的Repository中的Remotes
    在这里插入图片描述
    将git仓库地址从Spring源码地址修改为自己的git仓库地址
    在这里插入图片描述

    2、将Spring源码推送到自己仓库

    将spring源码推送到自己的远程仓库
    在这里插入图片描述

    Spring源码编译

    1、新增下载源地址

    在settings.gradle和build.gradle两个配置文件中新增阿里云仓库地址。
    settings.gradle配置文件

    repositories {
    	//spring源码中已有的配置
    	gradlePluginPortal()
    	//新增的阿里云仓库地址的配置
    	maven { url 'https://maven.aliyun.com/nexus/content/groups/public/' }
    	//新增的阿里云仓库地址的配置
    	maven { url 'https://maven.aliyun.com/nexus/content/repositories/jcenter' }
    	//spring源码中已有的配置
    	maven { url "https://repo.spring.io/plugins-release" }
    	}
    

    build.gradle配置文件

    repositories {
    	//新增的阿里云仓库地址的配置
    	maven { url 'https://maven.aliyun.com/nexus/content/groups/public/' }
    	//新增的阿里云仓库地址的配置
    	maven { url 'https://maven.aliyun.com/nexus/content/repositories/jcenter' }
    	//spring源码中已有的配置
    	mavenCentral()
    	//spring源码中已有的配置
    	maven { url "https://repo.spring.io/libs-spring-framework-build" }
    }
    

    2、修改gradle版本

    修改gradle-wrapper.properties配置文件中的配置,可以修改gradle的版本和下载的gradle存放的位置。一般不做修改。

    #distributionBase和distributionPath组合在一起,是gradle压缩包解压后的文件的存放位置。
    distributionBase=GRADLE_USER_HOME
    distributionPath=wrapper/dists
    #使用哪个版本的gradle,就在这里修改。gradle-##-all.zip是二进制版,只包含二进制文件(可执行文件)
    distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
    #zipStoreBase和zipStorePath组合在一起,是下载的gradle的压缩包的存放位置
    #环境变量GRADLE_USER_HOME的值
    zipStoreBase=GRADLE_USER_HOME
    zipStorePath=wrapper/dists
    
    #gradle-##-all.zip是完整版,包含二进制文件、源代码文件和离线文档
    #指定gradle的版本为本地存储的版本。
    #distributionUrl=file:///D:/worktools/Gradle/gradle-7.2-all.zip
    #将gradle-7.2-all.zip压缩包放到wrapper目录下。
    #distributionUrl=gradle-7.2-all.zip
    

    如果不想根据指定的路径去下载gradle。可以修改distributionUrl的值。
    如果将gradle-7.2-all.zip压缩包与gradle-wrapper.properties配置文件放到同一目录下,那么直接指定distributionUrl=gradle-7.2-all.zip。弊端是:压缩包超过100M,无法推送到gitee上。
    如果是指定本地存储的gradle,那么可以指定distributionUrl=file:///D:/worktools/Gradle/gradle-7.2-all.zip。弊端是:每个人本地存储路径不同。协作开发时,每个人都需要更改配置文件。

    源码编译时遇到的问题

    1、找不到jar包的问题

    编译时,可以编译成功,但是会有jar包找不到的问题。

    Errors occurred while build effective model from D:\worktools\Gradle\gradle_repository\caches\modules-2\files-2.1\com.alibaba\druid\1.2.6\c57198d77a31adf5bd36d35f9b12dc936b732587\druid-1.2.6.pom:
        'dependencies.dependency.systemPath' for com.sun:tools:jar must specify an absolute path but is ${project.basedir}/lib/openjdk-1.8-tools.jar in com.alibaba:druid:1.2.6
        'dependencies.dependency.systemPath' for com.sun:jconsole:jar must specify an absolute path but is ${project.basedir}/lib/openjdk-1.8-jconsole.jar in com.alibaba:druid:1.2.6
    

    解决方案一:
    根据报错信息中给出的路径找到文件,将文件中的依赖注释掉

    <!--找不到以下两个jar包,将jar包的引入注释掉
    <dependency>
    	<groupId>com.sun</groupId>
    	<artifactId>tools</artifactId>
    	<version>1.8</version>
    	<scope>system</scope>
    	<systemPath>${project.basedir}/lib/openjdk-1.8-tools.jar</systemPath>
    </dependency>
    
    <dependency>
    	<groupId>com.sun</groupId>
    	<artifactId>jconsole</artifactId>
    	<version>1.8</version>
    	<scope>system</scope>
    	<systemPath>${project.basedir}/lib/openjdk-1.8-jconsole.jar</systemPath>
    </dependency>
    -->
    

    解决方案二:
    根据错误信息中给出的缺少的jar包,如果本地有这个jar包,那么将systemPath中的路径修改为绝对路径即可。

    <dependency>
    	<groupId>com.sun</groupId>
    	<artifactId>tools</artifactId>
    	<version>1.8</version>
    	<scope>system</scope>
    	<!--将jar包路径修改为绝对路径-->
    	<systemPath>D:/worktools/jdk/jdk-11.0.11/lib/openjdk-1.8-tools.jar</systemPath>
    </dependency>
    
    <dependency>
    	<groupId>com.sun</groupId>
    	<artifactId>jconsole</artifactId>
    	<version>1.8</version>
    	<scope>system</scope>
    	<!--将jar包路径修改为绝对路径-->
    	<systemPath>D:/worktools/jdk/jdk-11.0.11/lib/openjdk-1.8-jconsole.jar</systemPath>
    </dependency>
    

    如果本地没有提示中缺少的jar包,如果必须使用该jar包,那么需要寻找jar包资源,将然后将存放jar的绝对路径写到配置文件中。如果不适用jar包中的内容,那么可以创建一个txt文件,命名为jar缺失的jar包名称,将后缀改为.jar,同样需要将jar包的绝对路径写到配置文件中。

    2、JDK版本不对应的问题

    本地配置的Java的环境变量的JDK版本要与spring源码要求的版本对应。不然会有一下错误:无效的源发行版:17。
    在这里插入图片描述
    我现在的最新的spring源码,使用的是jdk17。
    在编译之前查看spring要求的JDK版本:查看Spring编译要使用的JDK
    注意:要修改Java的环境变量中的jdk版本,只修改项目使用JDK是无效的。

    3、编译时可能出现的警告

    编译时可能会有以下警告。

    Java HotSpot(TM) 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
    

    在Settings中搜过async,然后将Instrumenting agent的勾选去掉,警告就没有了。
    在这里插入图片描述

    展开全文
  • XmlBeanFactory继承自DefaultListableBeanFactory,而DefaultListableBeanFactory是整个bean加载的核心部分,是Spring注册及加载bean的默认实现,XmlBeanFactory与DefaultListableBeanFactory不同的地方其实是在...
  • Spring源码搭建

    2021-01-08 01:37:07
    想要学习spring源码,第一步一定是构建spring源码环境 Spring源码构建 因为spring是用gradle构建的,所以需要确保本机有gradle。 我的环境是JDK1.8、Gradle5.6.1 第一步:从github下载spring-framework的源码 spring...
  • 无论在解析源码,还是在看待其他问题上,首先先来看第一个问题,为什么要有Spring?为什么Spring这么流行?为什么会有Spring? C++这个语言相信了解过的都知道,其对象是需要手动回收的,而Java的优点之一就是会...

    为什么要有Spring?

          无论在解析源码,还是在看待其他问题上,首先先来看第一个问题,为什么要有Spring?为什么Spring这么流行?为什么会有Spring?

          C++这个语言相信了解过的都知道,其对象是需要手动回收的,而Java的优点之一就是会自动回收不用了的对象。但是如果在一个项目中,如果创建的对象过多,这个创建速度超过了达到回收条件的时限时,内存就会爆掉。那么很多人就会想,很多创建的对象其实都是重复的,能否把这些对象集中起来,不用重复去创建,提高整个对象的利用率,那么就可以降低整个创建过多对象而导致内存爆掉的问题发生概率了。

          应运而生的Spring就出来了,或者说Spring就是带着这样的初衷而出生的。所有的对象都交给Spring这个容器(IOC容器)去管理,那么还节省了开发人员维护这个对象的功夫,还可以让其他框架的对象一样也交给Spring去管理就可以了,那么即便在一个项目应用多个框架的话,维护起来也不会麻烦,如果这个框架不用,那么就把其从Spring容器中移除,不在管理(解耦)即可。

     

    什么是Spring?

          官方的定义是:Spring框架是一种轻量级的阶级方案,是构建企业级应用程序的潜在一站式解决方案。

          在写这篇文章时,即便在一开始思考了为什么会有Spring这个框架之后,我也在想,什么是Spring?官方写的含糊其辞的,那么我又在想Spring就是IOC和AOP了吗?

          在结合在以前项目的应用和各种遇到的坑,我给予Spring的定义是:管理项目中所有主动注入容器中的对象的框架。

          给予这个定义的原因在于,每次做项目和面试时,别人问我们都会给予一个回答SSM,Spring必然是包含在其中的,并且Spring用多种形式(单例/多例)管理注入到IOC容器中的对象。

          Spring是面向Bean的编程(BOP:Bean Oriented Programming),Bean在Spring中才是真正的主角,即对象。Bean在Spring中的作用就像Object对OOP的意义一样,没有对象的概念就像没有面向对象编程,Spring中没有Bean也就没有Spring存在的意义。Spring提供了通过配置文件或者注解的方式来管理对象之间的依赖关系。

          控制反转(Inversion Of Control,IOC):是面向对象编程中的一种设计原则,可以用来减低代码之间的耦合度。其中最常见的方式叫依赖注入(Denpendency Injection,DI),还有一种方式叫依赖查找(Dependency Lookup)。

          过程:通过控制反转,对象在被创建时,由一个调控系统内所有对象的外界实体,将其依赖的对象的引用传递给它,即依赖被注入的到对象。

     

    Spring体系

    SpringCore

     

    SpringContext

    上下文容器,是BeanFactory功能加强的一个接口

    SpringWeb

    提供Web开发

    SpringMVC

    针对Web应用的MVC思想

    SpringDAO

    提供JDBC抽象层,简化了JDBC编码,同时编码更具有健壮性

    SpringORM

    与流行的ORM框架结合

    SpringAOP

    面向切面编程

     

    Spring框架结构(v 5.x)

    核心容器层(Core Container)

          Core Container(核心容器):包含有Beans、Core、Context、ExpressionLanguae模块。其中Core和Beans模块是框架的基础部分,提供IOC(控制反转)和DI(依赖注入)特性这里的基础概念是BeanFactory,它提供Factory模式的经典实现来消除对程序性单例模式的需要,并真正的允许你从程序逻辑中分离出依赖关系和配置。

     

          Core模块:主要包含Spring框架基本的核心工具类,Spring的其他组件都要使用到这个包里的类,Core模块是其他组件的基本核心。

     

          Beans模块:这个是所有应用都要用到的,包含访问配置文件、创建和管理Bean,以及进行Inversion of Control/Dependency Inection(IOC/DI)操作相关的所有类。

     

          Context模块:构建于Core和Beans模块基础之上,提供了一种类似于JNDI注册器的框架式对象访问方法。Context模块基础了Beans的特性,为Spring核心提供了大量扩展,添加了对国际化(例如资源绑定)、事件传播、资源加载和对Context的透明创建的支持。Contet同时也支持J2EE的一些特性,例如EJB、JMX和基础的远程处理。AppliationContext接口是Contetext模块的关键。

     

          Expression Language模块:提供了一个强大的表达式语音用于在运行时查询和操作对象。是JSP2.1规范中定义的Unifedexpression Language的一个扩展。这个语言支持设置/获取属性值,属性的分配,方法的调用,访问数组上下文,容器和索引器,逻辑和算术运算符,命名变量以及Spring的IOCring器中根据名称检索对象,它也支持List投影,选择和一般的List聚合。

     

          串联:Beans模块是用于操作对象进行的IOC/DI的。Core模块提供工具类方法,用于整个Spring框架。Context模块是在Beans和Core模块已经完成了对对象的IOC/DI的操作之后,提供了面向不同环境的一些高级特性(国际化)。Expression Language模块则是为了方面所有的模块进行编写,比如 * 这个字符的解析。

     

    数据访问/集成层(Data Access/Integration)

          这个在听名字就知道了,就是提供与其他中间件的交互模块的,包括有JDBC、OXM、JMS、Transaction模块。

          JDBC模块:提供了一个JDBC抽象层,可以消除冗长的JDBC编码和解析数据库厂商的错误代码。这个模块包含了Spring对JDBC数据访问进行封装的所有类。

     

          ORM(Object Relational Mapping):名为对象关系映射模块,这个为对象-关系映射的API,如Hibernate、Mybatis这些ORM框架,提供了一个交互层,利用ORM封装包,可以混合使用所有Spring提供的特性进行O/R映射。如简单的声明式事务管理。

          Spring框架插入了若干个ORM框架,从而提供了ORM的对象关系工具,其中包括JDO、Hibernate、MybatisSQL Map。所有这些都遵从Spring的通用事务和DAO异常层次结构。

     

          OXM模块:提供了一个对Object/XML映射实现的抽象层,Object/XML映射实现包括JAXB、Castor、XMLBeans、JiBX和XStream。

     

          JMS(Java Messageing Service)模块:包括了一些制造和消费消息的特性。

     

          Transaction模块:支持编程和声明式的事务管理,这些事务类必须实现特定的接口,并且对所有POJO都适用。

     

    Web层

          Web上下文模块建立在应用程序上下文模块之上,为基于Web的应用成提供了上下文。所以Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。Web层包含了Web、Web-Servlet、Web-Struts和Web-Porlet模块。

     

          Web模块:提供了基础的面向Web的集成特性,比如多文件上传,使用Servlet LiSteners初始化IOC容器以及一个面向Web的应用上下文,还包含Srping远程支持中Web的相关部分。

     

          Web-MVC模块:包含Spring的Model-View-Controller(MVC)的实现。Spring的MVC框架使得模型范围内的代码和Web Forms之间能够清楚的分离开来,并与Spring框架的其他特性集成在一起。

          Web-Socket模块:提供了与Web前端的全双工通讯协议。

     

          Web-Flux模块:是一个新的非阻塞函数式Reactive Web框架,可以用来建立异步、非阻塞,事件驱动的服务,并且扩展性非常好。

     

          串联:Web模块提供基础。WebMVC模块提供MVC分离。Web-Socket模块在Web模块和WebMVC模块的基础上提供代码解耦的网络链接。WebFlux模块提供非阻塞的形式来去实现NIO的特性。

     

    AOP、Aspects、Instrmentation(设备支持)

          AOP(Aspect Oraiented Programming)模块:AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现,可以让定义例如方法拦截器和切点。从而将逻辑代码分开,降低耦合性。利用Source-Level的元数据功能,还可以将各种行为信息合并到代码中。

          通过Spring配置管理的特性,Spring AOP模块之间将面向切面的功能集成到Spring框架中,所以很容易的使得Spring框架管理的任何对象支持AOP。为基于Spring的应用成的对象提供事务管理服务。通过使用Spring AOP,不用依赖EJB组件,就可以加个声明式事务管理集成到应用程序中。

     

          Aspects模块:提供AspectJ的集成支持,AspectJ是一个面向切面的框架,并且它还扩展了Java语言,主要是为Spring AOP提供多种AOP实现方法。

     

          Instrumentation(设备支持)模块:提供了Class Instrumentation(类仪器)支持和Class Loader(类加载)的实现,使得可以在特定的应用服务器上使用。应该算是AOP的一个支援模块,主要作用是在JVM启用时,生成一个代理类,开发者可以通过代理类在运行时修改类的字节,从而改变一个类的功能,实现AOP的功能。

     

    Messaging

          Messaging模块:这是从Spring4开始新加入的一个模块,主要是为Spring框架继承一些基础的报文传送应用。

     

    Test层

          Test模块:用于使用Junit和TestNG对Spring组件进行测试。

     

    串联

          核心容器层(Core Container)提供了基础,帮助应用管理对象。

          数据访问/集成层(Data Access/Integration)提供了对象与数据库的交互性映射。

          Web层提供了网络交互的相关组件。

          AOP、Asepects、Instramenetation提供了辅助型的增强功能,让整个开发更简单,也增强了健壮性(比如AOP日志)。

          Message提供了对一些消息的报文传送的优化等内容,为其他层提供增强型的辅助功能。

          Test层为其他层增强了健壮性。

     

    Spring源码结构(v5.2.7.RELEASE)

          在浏览器搜索很多Spring源码解析相关的文章,一上来就告诉你Spring IOC是什么?源码是怎么样的?让我们很困惑,在了解了Spring的框架结构之后,会发现其实Spring源码阅读似乎只需要阅读其中一些核心模块即可,其他的辅助模块其实是可以在使用到在去阅读的。

          现在在来看看Spring的源码结构究竟是怎么样的,以及和刚刚讲的Spring框架结构有什么关联。

          Srping总共大约有20个模块,1300多个不同的文件组成。而这些组件被分别整合在核心容器层(Core Container)、数据访问及集成(Data Access/Integeration)、AOP、Web、Messaging、Test这几个模块中。

     

    核心容器层(Core Container)

          核心层是这4个模块组成的。1、spring-beans,2、spring-core,3、spring-cotext,4、spring-expression。

     

          spring-beans和spring-core模块:是Spring框架的核心模块,包含了IOC(控制反转,Inversion of Control)和DI(依赖注入,Dependency Injection)。BeanFactory接口是Spring框架中的核心结构,它是工厂模式的具体实现。

    BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际应用程序代码进行分离。但BeanFactory容器实例化后并不会自动实例化Bean,只有当Bean被使用时,BeanFactory才会对该Bean进行实例化与依赖关系的装配。

     

          spring-context模块:构架于spring-beans和spring-core模块之上,这个模块扩展了BeanFactory,为BeanFactory添加了Bean生命周期控制、框架事件体系以及资源加载透明化等功能。而且这个模块还提供了很多企业级的支持,比如邮件访问、远程控制、任务调度等。

          ApplicationContext是该模块的核心接口,是BeanFactory的超类,与BeanFactory不同,ApplicationCotext容器实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配,使之处于待用状态。

     

          spring-expression模块:统一表达式语言(EL)的扩展模块,可以查询、管理运行中的对象,同时也方便的可以调用对象方法、操作数组、集合等。语法类似于传统EL,但提供了额外的功能,最出色的就是函数调用和简单字符串的模板函数,这样的语言特性是基于Spring产品的需求而设计,使其可以非常方便的与Spring IOC进行交互。

     

    数据访问/集成层(Data Access/Integration)

          数据访问/集成层是这5个模块组成。1、spring-jdbc,2、spring-tx,3、spring-orm,4、spring-jms,5、spring-oxm。

          spring-jdbc模块:这个是Spring提供的JDBC抽象框架的主要实现模块,用于简化Spring JDBC。主要是提供JDBC的模板方式、关系数据库对象化方式、SimpleJdbc方式、事务管理来简化JDBC编程,主要实现类是JdbcTemplate、SimpleJdbcTemplate、NamedParameterJdbcTemplate。

     

          spring-tx模块:这个是Spring JDBC事务控制实现模块。Spring框架对事务做了很好的封装,通过它的AOP配置,可以灵活的配置在任何一层。但是在很多需求和应用中,直接使用JDBC事务控制还是有优势的。

          其实事务是以业务逻辑为基础的,一个完整的业务应该对应业务层里的一个方法。如果业务操作失败,则整个事务回滚。所以事务控制绝对应该放在业务层的。但是持久层的设计则应该遵循保证操作的原子性,即持久层里的每个方法都是不可以分割的。所以在使用Spring JDBC事务时,要特别注意其特殊性。

     

          spring-orm模块:这个是ORM框架的支撑模块,主要集成Hibernate、Java Persistence API(JPA)和Java Data Objects(JDO)用于资源管理、数据访问对象(DAO)的实现和事务策略。

     

          spring-jmx(Java Messaging Service)模块:能顾发送和接受信息,自Spring Framework 4.1以后,还提供了对spring-messaging模块的支撑。

     

          spring-oxm模块:提供了一个抽象层以支撑OXM(Object XML Mapping),是一个O/M-mapper,将java对象映射成XML数据,或者讲XML数据映射成java对象,比如JAXB、XMLBeans、XStream等。

     

    Web层

          Web层是这4个模块组成的。1、spring-web,2、spring-webmvc,3、spring-websocket,4、spring-webflux。

          spring-web模块:这个模块为Spring提供了最基础的Web支持,主要建立于核心容器之上,通过Servlet或Listeners来初始化IOC容器,也包含一些鱼Web相关的支持。

     

          spring-webmvc模块:这个模块众所周知是一个Web-Servlet模块,实现了Spring MVC(Model-View-Controller)的Web应用。

     

          spring-websocket模块:主要是与Web前端的全双工通讯的协议。

     

          spring-webflux模块:是一个新的非阻塞函数式Reactive Web框架,可以用来建立异步的,非阻塞的事件驱动的服务,并且扩展性很好。

     

    AOP、Aspects、Instrmentation(设备支持)

          这一层是这3个模块组成的。1、spring-aop、2、spring-aspects、3、spring-instrument。

          spring-aop模块:这个是Spring的另一大核心模块,是AOP主要的实现模块,作为继OOP后,对程序影响最大的编程思想之一,AOP极大的开拓了人们对于编程的思路。在Spring中,他是以JVM的动态代理技术为基础,然后设计出一系列的AOP横切实现,比如前置通知、返回通知、异常通知等。同时,Pointcut接口来匹配切入点,可以使用现有的切入点来设计横切面,也可以扩展相关方法根据需求进行切入。

          spring-aspects模块:这个是集成AspectJ框架,主要是为Spring AOP提供多种AOP实现方法。

          spring-instrument(设备支持)模块:这个是基于Java SE中的java.lang.instrument进行设计的,应该算是AP一个支援模块,主要作用是在JVM启动时,生成一个代理类,程序员通过代理类在运行时修改类的字节,从而改变一个类的功能,实现AOP的功能。

     

    Messaging

          Messaging这一层是1个模块组成。1、spring-messaging。

          spring-messaging模块:这个是从Spring4开始新加入的一个模块,主要职责是为Spring框架集成一些基础的报文传送应用。

     

    Test层

          Test这一层是1个模块组成。1、spring-test。

          spring-test模块:主要是为测试提供支持的,毕竟在不需要发布(程序)到你的应用服务器或者链接到其他企业设施的情况下能够执行一些集成测试或其他测试。

     

    Spring包依赖图

     

    展开全文
  • 更改spring在项目中gradle下载位置4. 阿里云配置,修改bulid.gradle文件, 注意加在了哪,可以用“ mavenCentral()”定位一下5. 命令行运行 gradlew.bat, 成功的结果如下:6. 导入idea预编译7. 正式导入idea(要导好...

    版本说明:

    • JDK:11
    • Springframework:5.1.X
    • Gradle:6.5.1

    1. 项目克隆

    # github 版
    git clone -b 5.1.x https://github.com/Xudongenen/spring-framework.git
    # 国内镜像(本文采用的)
    git clone -b 5.1.x https://gitee.com/mirrors/Spring-Framework.git
    

    2. 下载gradle

     https://services.gradle.org/distributions/gradle-6.5.1-bin.zip
    

    3. 更改spring在项目中gradle下载位置

    # 改动文件地址 Spring-Framework\gradle\wrapper\gradle-wrapper.properties
    # 将其中gradle下载地址改为我们下好的目录,他就会不去下载直接用了,如下图所示:
    

    更改获取位置

    4. 阿里云配置

    修改bulid.gradle文件, 注意加在了哪,可以用“ mavenCentral()”定位一下

    repositories {
        mavenCentral()
        maven { url "https://repo.spring.io/libs-spring-framework-build" }
        maven { url "https://repo.spring.io/snapshot" }
        maven { url 'https://maven.aliyun.com/nexus/content/groups/public/'}
        maven { url 'https://maven.aliyun.com/nexus/content/repositories/jcenter'}
      }
    

    阿里源

    5. 命令行运行 gradlew.bat

    成功的结果如下:

    成功运行

    失败结果如下:
    失败运行

    我当时是报了如下错误:
    错误信息: Could not initialize class org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSetKt
    解决方案: 在 Spring-Framework\build.gradle 中修改kotlin版本,共两处:

    # 第一处:
    plugins {
      id "io.spring.dependency-management" version "1.0.7.RELEASE" apply false
      id "org.jetbrains.kotlin.jvm" version "1.3.61" apply false //这里!!!!
      id "org.jetbrains.dokka" version "0.9.18"
      id "org.asciidoctor.convert" version "1.5.8"
    }
    # 第二处:
    kotlinVersion        = "1.3.61"  //这里!!!!
    

    6. 导入idea预编译

    # 命令行执行
    gradlew :spring-oxm:compileTestJava
    

    成功之后如图:
    成功运行

    当然了事情并不是一帆风顺,我出现了以下错误:

    错误信息:
    org.gradle.api.CircularReferenceException: Circular dependency between the following tasks:
    :spring-beans:compileGroovy
    — :spring-beans:compileJava
    — :spring-beans:compileKotlin
    — :spring-beans:compileGroovy (*)**

    解决方案: 更改 Spring-Framework\spring-beans\spring-beans.gradle 文件,方法如下:

    1. 在文件最后注释掉下面三行代码
    // def deps = compileGroovy.taskDependencies.immutableValues + compileGroovy.taskDependencies.mutableValues
    // compileGroovy.dependsOn = deps - "compileJava"
    // compileKotlin.dependsOn(compileGroovy)
    
    1. 添加如下代码
    tasks.named('compileGroovy') {
        // Groovy only needs the declared dependencies (and not the result of Java compilation)
        classpath = sourceSets.main.compileClasspath
    }
    tasks.named('compileKotlin') {
        // Kotlin also depends on the result of Groovy compilation
        classpath += files(sourceSets.main.groovy.classesDirectory)
    }
    

    7. 正式导入idea(要导好一会儿)

    导入idea

    8. 改用idea构建,主要为了提速

    idea构建

    9. 新建测试模块

    • 新建模块
      新建模块

    • 选择gradle构建
      新建模块

    • 起名字
      新建模块

    10. 为自己的模块添加spring依赖

    找到我们自己建的模块中的gradle.bulid
    添加依赖

    加入如下代码:

    compile(project(":spring-context")) 
    

    添加依赖

    11. 创建自己的测试类

    我的文件目录是这样的:
    目录结构

    其中涉及到的三个文件如下:

    // MyConfig.java 文件
    package com.zxd;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    @Configuration
    @ComponentScan("com.zxd")
    public class MyConfig {}
    
    // MyService.java 文件
    package com.zxd;
    import org.springframework.stereotype.Component;
    @Componentpublic 
    class MyService {}
    
    // MyTest.java 文件
    import com.zxd.MyConfig;
    import com.zxd.MyService;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    public class MyTest {      
        public static void main(String[] args) {            
            AnnotationConfigApplicationContext annotationConfigApplicationContext = 
                                                                    new AnnotationConfigApplicationContext (MyConfig.class);            
            System.out.println(annotationConfigApplicationContext.getBean(MyService.class));      
        }
    }
    

    运行MyTest类成功便会得到如下结果:
    测试成功

    但事情往往不会那么顺利,我就遇到了以下两个问题:

    错误信息1: Kotlin: Language version 1.1 is no longer supported; please, use version 1.2 or greater.
    Errors occurred while compiling module ‘spring.spring-beans.main’

    解决方案: 我们需要找到对应报错模块,改变他的Kotlin版本,在这里我改成了 1.4 稳定版,遇到类似问题也是同样的解决办法,如图所示。
    错误1

    错误信息2:
    D:\java\Spring-Framework\spring-context\src\main\java\org\springframework\context\weaving\DefaultContextLoadTimeWeaver.java:26:38
    java: 找不到符号
    符号: 类 InstrumentationSavingAgent
    位置: 程序包 org.springframework.instrument

    解决方案: 通过查看报错信息,我们知道了,编译器没有找到对应的InstrumentationSavingAgent类,我们到这个类所在的模块 spring-instrument 的 out 文件中发现没有这个类,所以我们需要通过手动运行test类将它们编译出来,具体如图所示。
    错误二

    总结:

    终于,我们可以运行spring源码了,过程不难,遇到问题不要慌,版本问题一定要细致,如果是第一次装最好先和我的版本保持一致,轻车熟路之后再换呗~
    大家如果有啥问题可以留言哦,没问题我们就一起开始学源码了,大家加油啊!!!

    参考:

    Build from Source

    展开全文
  • 尚硅谷的springboot源码解析及相关整合课件百度网盘连接资源
  • Tom_深入分析Spring源码docTom_深入分析Spring源码doc
  • spring 源码 翻译注释

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 592,739
精华内容 237,095
关键字:

spring源码

spring 订阅