一、什么是spring

一个java框架、java语言开发，轻量级、开源框架、在j2se、j2ee中都可以使用。它是一个管理对象的容器，Spring 容器不装文本，数字。装的是java对象。 

核心技术：ioc、aop

官网地址

https://spring.io

项目列表：https://spring.io/projects

二、核心模块

1. Spring Core：Spring Core是Spring框架的核心模块，提供了IoC（Inversion of Control）容器的实现和支持。它负责创建、配置和管理应用程序中的对象，并通过依赖注入的方式解耦组件之间的依赖关系。
2. Spring AOP：Spring AOP模块实现了面向切面编程（AOP）的支持。它允许开发者通过定义切点和切面，将横切关注点（如日志记录、性能监控等）与业务逻辑分离，从而提高代码的模块化和可维护性。
3. Spring Web MVC：Spring Web MVC是Spring框架的Web应用程序开发模块。它提供了一种基于MVC（Model-View-Controller）的架构，用于构建灵活、可扩展的Web应用程序。开发者可以使用注解或配置文件定义控制器、视图和模型，并实现Web请求的处理和响应。
4. Spring WebFlux：Spring WebFlux是Spring框架的响应式Web开发模块。它基于反应式编程模型，提供了一种异步、非阻塞的方式处理Web请求。开发者可以使用注解或函数式编程风格定义处理器函数，并利用响应式流处理请求和响应。
5. Spring Web：Spring Web模块是Spring框架的Web应用程序支持模块，提供了与Servlet API和其他Web相关技术的集成。它包括与Web安全、文件上传、WebSockets等相关的功能和工具，帮助开发者构建全功能的Web应用程序。
6. Spring DAO：Spring DAO模块提供了对数据访问对象（DAO）的支持。它简化了与数据库的交互，提供了一组抽象和实现，用于执行CRUD操作、批处理、存储过程调用等。开发者可以集成各种数据访问技术（如JDBC、Hibernate、JPA等）来实现灵活和可扩展的数据访问层。
7. Spring ORM：Spring ORM模块用于集成和支持各种对象关系映射（ORM）框架，如Hibernate、JPA等。它提供了事务管理、异常转换和对象关系映射等功能，简化了与关系型数据库的交互。
8. Spring Context：Spring Context是Spring框架的核心模块之一，实现了IoC容器的功能。它负责管理和组织应用程序中的各个组件，包括Bean管理、依赖注入、生命周期管理、事件机制等。Spring Context提供了一个上下文环境，使得开发者能够更方便地构建和管理应用程序。

        这些模块共同构成了Spring框架的基础架构，使得企业级Java应用程序的开发变得更加简单、灵活和可维护。开发者可以根据项目需求选择和集成相应的模块，以实现特定功能和业务逻辑。

三、spring下载

官⽹地址：https://spring.io/

官⽹地址（中⽂）：http://spring.p2hp.com/

打开Spring官⽹后，可以看到Spring Framework，以及通过Spring Framework衍⽣的其它框架： 

 进⼊github

找到下图位置，点击超链接

 继续在springframework⽬录下找下图的spring，点开之后你会看到很多不同的版本

选择对应的版本

点击上图的url 

 点击spring-5.3.9-dist.zip下载spring框架。

将下载的zip包解压：

docs：spring框架的API帮助⽂档

libs：spring框架的jar⽂件（⽤spring框架就是⽤这些jar包）

schema：spring框架的XML配置⽂件相关的约束⽂件

四、spring jar文件

打开libs⽬录，会看到很多jar包：

spring-core-5.3.9.jar：字节码（这个是⽀撑程序运⾏的jar包）

spring-core-5.3.9-javadoc.jar：代码中的注释

spring-core-5.3.9-sources.jar：源码

所有jar文件如下

JAR⽂件	描述
spring-aop-5.3.9.jar	这个jar⽂件包含在应⽤中使⽤Spring的AOP特性时所需的类
spring-aspects-5.3.9.jar	提供对AspectJ的⽀持，以便可以⽅便的将⾯向切⾯的功能集成进IDE中
spring-beans-5.3.9.jar	这个jar⽂件是所有应⽤都要⽤到的，它包含访问配置⽂件、创建和管理bean以及进⾏InversionofControl / Dependency Injection（IoC/DI）操作相关的所有类。如果应⽤只需基本的IoC/DI ⽀持，引⼊spring-core.jar及spring-beans.jar ⽂件就可以了。
spring-context-5.3.9.jar	这个jar ⽂件为Spring 核⼼提供了⼤量扩展。可以找到使⽤SpringApplicationContext特性时所需的全部类，JDNI所需的全部类，instrumentation组件以及校验Validation⽅⾯的相关类。
spring-context-indexer-5.3.9.jar	虽然类路径扫描⾮常快，但是Spring内部存在⼤量的类，添加此依赖，可以通过在编译时创建候选对象的静态列表来提⾼⼤型应⽤程序的启动性能。
spring-context-support-5.3.9.jar	⽤来提供Spring上下⽂的⼀些扩展模块,例如实现邮件服务、视图解析、缓存、定时任务调度等
spring-core-5.3.9.jar	Spring框架基本的核⼼⼯具类。Spring其它组件要都要使⽤到这个包⾥的类，是其它组件的基本核⼼，当然你也可以在⾃⼰的应⽤系统中使⽤这些⼯具类。
spring-expression-5.3.9.jar	Spring表达式语⾔。
spring-instrument-5.3.9.jar	Spring3.0对服务器的代理接⼝。
spring-jcl-5.3.9.jar	Spring的⽇志模块。JCL，全称为"JakartaCommonsLogging"，也可称为"ApacheCommonsLogging"。
spring-jdbc-5.3.9.jar	Spring对JDBC的⽀持。
spring-jms-5.3.9.jar	这个jar包提供了对JMS1.0.2/1.1的⽀持类。JMS是Java消息服务。属于JavaEE规范之⼀。
spring-messaging-5.3.9.jar	为集成messagingapi和消息协议提供⽀持
spring-orm-5.3.9.jar	Spring集成ORM框架的⽀持，⽐如集成hibernate，mybatis等。
spring-oxm-5.3.9.jar	为主流O/XMapping组件提供了统⼀层抽象和封装，OXM是ObjectXmlMapping。对象和XML之间的相互转换。
spring-r2dbc-5.3.9.jar	ReactiveRelationalDatabaseConnectivity (关系型数据库的响应式连接) 的缩写。这个jar⽂件是Spring对r2dbc的⽀持。
spring-test-5.3.9.jar	对Junit等测试框架的简单封装。
spring-tx-5.3.9.jar	为JDBC、Hibernate、JDO、JPA、Beans等提供的⼀致的声明式和编程式事务管理⽀持。
spring-web-5.3.9.jar	Spring集成MVC框架的⽀持，⽐如集成Struts 等。
spring-webflux-5.3.9.jar	WebFlux是 Spring5添加的新模块，⽤于 web的开发，功能和 SpringMVC类似的，Webflux使⽤当前⼀种⽐较流程响应式编程出现的框架。
spring-webmvc-5.3.9.jar	SpringMVC框架的类库
spring-websocket-5.3.9.jar	Spring集成WebSocket框架时使⽤

注意：

如果你只是想⽤Spring的IoC功能，仅需要引⼊：spring-context即可。将这个jar包添加到classpath当中。

<!--Spring6的正式版发布之前，这个仓库地址是需要的-->
<repositories>
    <repository>
        <id>repository.spring.milestone</id>
        <name>Spring Milestone Repository</name>
        <url>https://repo.spring.io/milestone</url>
    </repository>
</repositories>

<dependencies>
<!--spring context依赖：使⽤的是6.0.0-M2⾥程碑版-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.0-M2</version>
    </dependency>
</dependencies>

如果采⽤maven只需要引⼊context的依赖即可。

五、第⼀个Spring程序

打开IDEA创建Empty Project：spring6

设置JDK版本17，编译器版本17

 设置IDEA的Maven：关联⾃⼰的maven

在空的⼯程spring6中创建第⼀个模块：spring6-001-first

添加spring context的依赖，pom.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://mave
n.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.powernode</groupId>
    <artifactId>spring6-001-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <dependencies>
        <!--spring context依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
</project>

 注意：打包⽅式jar。

当加⼊spring context的依赖之后，会关联引⼊其他依赖：

spring aop：⾯向切⾯编程

spring beans：IoC核⼼

spring core：spring的核⼼⼯具包

spring jcl：spring的⽇志包

spring expression：spring表达式

添加junit依赖

<!--junit-->
 <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.13.2</version>
     <scope>test</scope>
 </dependency>

定义bean：User

public class User {
}

 编写spring的配置⽂件：beans.xml。该⽂件放在类的根路径下。

配置⽂件中进⾏bean的配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans htt
p://www.springframework.org/schema/beans/spring-beans.xsd">
 
 <bean id="userBean" class="com.powernode.spring6.bean.User"/>
</beans>

 bean的id和class属性：

id属性：代表对象的唯⼀标识。可以看做⼀个⼈的身份证号。

class属性：⽤来指定要创建的java对象的类名，这个类名必须是全限定类名（带包名）。

测试

public class Spring6Test {
    @Test
    public void testFirst() {
        // 初始化Spring容器上下⽂（解析beans.xml⽂件，创建所有的bean对象）
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        // 根据id获取bean对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
    }
}

第一个程序剖析

1、bean标签的id属性可以重复吗？

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userBean" class="com.ssmtest.entity.User"/>
    <bean id="userBean" class="com.ssmtest.entity.Person"/>
</beans>

 

通过测试得出：在spring的配置⽂件中id是不能重名。 

2、底层是怎么创建对象的，是通过反射机制调⽤⽆参数构造⽅法吗？

public class User {
    public User(){
        System.out.println("无参构造被调用");
    }
}

通过测试得知：创建对象时确实调⽤了⽆参数构造⽅法。 如果提供⼀个有参数构造⽅法，不提供⽆参数构造⽅法会怎样呢？

 

通过测试得知：spring是通过调⽤类的⽆参数构造⽅法来创建对象的，所以要想让spring给你创建对 象，必须保证⽆参数构造⽅法是存在的。

Spring是如何创建对象的呢？原理是什么？ 

// dom4j解析beans.xml⽂件，从中获取class的全限定类名
// 通过反射机制调⽤⽆参数构造⽅法创建对象
Class clazz = Class.forName("com.powernode.spring6.bean.User");
Object obj = clazz.newInstance();

3、把创建好的对象存储到⼀个什么样的数据结构当中了呢？ 

4、spring配置⽂件的名字必须叫做beans.xml吗？ 

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");

通过以上的java代码可以看出，这个spring配置⽂件名字是我们负责提供的，显然spring配置⽂件的名字 是随意的。

5、像这样的beans.xml⽂件可以有多个吗？

再创建⼀个spring配置⽂件，起名：spring.xm

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml","spring.xml");

通过测试得知，spring的配置⽂件可以有多个，在ClassPathXmlApplicationContext构造⽅法的参数上 传递⽂件路径即可。这是为什么呢？通过源码可以看到参数可以多个

    public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
        this(configLocations, true, (ApplicationContext)null);
    }

 6、在配置⽂件中配置的类必须是⾃定义的吗，可以使⽤JDK中的类吗，例如：java.util.Date？

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myDate" class="java.util.Date"/>
</beans>

测试 

public class Spring6Test {
    @Test
    public void testFirst() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        Object object = applicationContext.getBean("myDate");
        System.out.println(object);//Tue Sep 05 15:06:41 CST 2023
    }
}

 通过测试得知，在spring配置⽂件中配置的bean可以任意类，只要这个类不是抽象的，并且提供了⽆参 数构造⽅法。

7、getBean()⽅法调⽤时，如果指定的id不存在会怎样？

提示错误：org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'testBean' available

8、 getBean()⽅法返回的类型是Object，如果访问⼦类的特有属性和⽅法时，还需要向下转型，有其它 办法可以解决这个问题吗？

User user = applicationContext.getBean("userBean", User.class);

9、ClassPathXmlApplicationContext是从类路径中加载配置⽂件，如果没有在类路径当中，⼜应该如 何加载配置⽂件呢？ 

public class Spring6Test {
    @Test
    public void testFirst() {
        ApplicationContext applicationContext2 = new FileSystemXmlApplicationContext("d:/spring6.xml");
        User vip = applicationContext2.getBean("userBean", User.class);
        System.out.println(vip);
    }
}

六、集成Log4j2⽇志框架

从Spring5之后，Spring框架⽀持集成的⽇志框架是Log4j2.如何启⽤⽇志框架： 第⼀步：引⼊Log4j2的依赖

<!--log4j2的依赖-->
<dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 <version>2.19.0</version>
</dependency>
<dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-slf4j2-impl</artifactId>
 <version>2.19.0</version>
</dependency>

第⼆步：在类的根路径下提供log4j2.xml配置⽂件（⽂件名固定为：log4j2.xml，⽂件必须放到类根路径 下。）

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
 <loggers>
 <!--
 level指定⽇志级别，从低到⾼的优先级：
 ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF
 -->
 <root level="DEBUG">
 <appender-ref ref="spring6log"/>
 </root>
 </loggers>
 <appenders>
 <!--输出⽇志信息到控制台-->
 <console name="spring6log" target="SYSTEM_OUT">
 <!--控制⽇志输出的格式-->
 <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3le
vel %logger{1024} - %msg%n"/>
 </console>
 </appenders>
</configuration>

第三步：使⽤⽇志框架

Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
logger.info("我是⼀条⽇志消息");