目录 

一：Spring的入门程序

1. Spring的下载

2. Spring的jar文件

3. 第一个Spring程序

4. 第一个Spring程序详细剖析

5. Spring6启用Log4j2日志框架

一：Spring的入门程序

1. Spring的下载

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

官网地址（中文）：Spring 中文网 官网

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

我们即将要学习的就是Spring Framework；怎么下载呢？

第一步：进入github

第二步：找到下图位置，点击超链接

第三步：找到下图位置，点击仓库地址的超链接

第四步：按照下图步骤操作，找到springframwork

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

第六步：选择对应的版本 

第七步：点击上图的url

点击spring-5.3.9-dist.zip下载spring框架；将下载的zip包解压，看到几个文件夹：

docs：spring框架的API帮助文档

libs：spring框架的jar文件（用spring框架就是用这些jar包）

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

2. Spring的jar文件

打开libs目录，会看到很多jar包，以核心jar包为例：

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

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

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

 其它所有的jar包，当然这些jar包也对应这jar文件，这里就不列出来了：

注意：如果只是想用Spring的IoC功能，仅需要引入：spring-context即可，将这个jar包添加到classpath当中。如果采用maven只需要引入context的依赖即可！

现在我们学习的是Spring6，但是并没有Spring6只发布了里程碑版，并没有jar包（当然使用maven做项目管理也不需要下载jar包）；需要引入依赖，并且引入依赖的同时也要引入仓库地址（因为还没有正式发布，需要内部的仓库地址）

注：其实spring-context会依赖core和bean的jar包等，但是我们使用maven就只需引入context的jar包即可，其它依赖的会自动导入！

<!--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>

3. 第一个Spring程序

前期准备：

①打开IDEA创建Empty Project：spring6

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

③设置IDEA的Maven：关联自己的maven

④在空的工程spring6中创建第一个模块：spring6-001-first

第一步：添加spring context的依赖和单元测试junit依赖，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://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjpowernode</groupId>
    <artifactId>spring6-001-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!--配置多个仓库-->
    <repositories>
        <!--spring6里程碑的仓库-->
        <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>
        <!--单元测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</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表达式

第二步：定义bean：User，默认会调用无参构造方法

package com.bjpowernode.spring6.bean;
// 这是一个Bean，封装了用户的信息。Spring可以帮助我们创建User对象吗？
public class User {
   
}

第三步：编写spring的配置文件：spring.xml（名字随意），该文件放在类的根路径下（便于移植）。下图是使用IDEA工具自带的spring配置文件的模板进行创建。

此时就需要在配置文件中进行bean的配置，bean的id和class属性：

id属性：代表对象的唯一标识。

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

<?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，这样spring才能帮助我们管理这个对象-->
        <bean id="userBean" class="com.bjpowernode.spring6.bean.User" />
</beans>

第四步：编写测试程序

①先创建ClassPathXmlApplicationContext对象，参数是spring配置文件的路径；返回的是ApplicationContext 翻译为：应用上下文，其实就是Spring容器。
解释：ApplicationContext 就是一个接口，接口下有很多实现类，其中有一个实现类叫做：ClassPathXmlApplicationContext，是专门从类路径当中加载spring配置文件的一个Spring上下文对象。
②创建好ClassPathXmlApplicationContext对象，就可以调用getBean方法，参数是spring.xml配置文件当中的id，这样就可以根据bean的id从Spring容器中获取这个对象！      

package com.bjpowernode.spring6.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        // 第一步：获取Spring容器对象
        // 这行代码只要执行：就相当于启动了Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        // 第二步：根据bean的id从Spring容器中获取这个对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
    }
}

第五步：运行测试程序，验证Spring容器确实可以帮我们创建对象 

4. 第一个Spring程序详细剖析

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

Vip.java

package com.powernode.spring6.bean;

public class Vip {
}

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userBean" class="com.powernode.spring6.bean.User"/>
    <bean id="userBean" class="com.powernode.spring6.bean.Vip"/>
</beans>

运行测试程序：

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

（2）底层是怎么创建对象的？

 User.java：在User类中添加上无参数构造方法

package com.powernode.spring6.bean;

public class User {
    public User() {
        System.out.println("User的无参数构造方法执行");
    }
}

运行测试程序：

通过测试得知：创建对象时确实调用了无参数构造方法，并且是通过反射机制调用无参数构造方法。

如果提供一个有参数构造方法，不提供无参数构造方法会怎样呢？

package com.powernode.spring6.bean;

public class User {
    public User(String name){
        System.out.println("User的有参数构造方法执行");
    }
}

运行测试程序：

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

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

先通过dom4j解析spring.xml文件，从中获取class的全限定类名；然后通过反射机制调用无参数构造方法创建对象！

Class clazz = Class.forName("com.powernode.spring6.bean.User");
Object obj = clazz.newInstance();

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

存到一个Map集合，Map的key就是id，value就是创建的对象！

（4）spring配置文件的名字必须叫做spring.xml吗？

①这个spring配置文件名字是我们负责提供的，显然spring配置文件的名字是随意的。

②并且这个配置文件不一定就放在跟目录下，也可以先创建xml目录，然后把配置文件放到这个目录下也可以！

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("xml/beans.xml");

（5）像这样的beans.xml文件可以有多个吗？

再创建一个spring配置文件，起名：beans.xml，放到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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

      <bean id="vipBean" class="com.bjpowernode.spring6.bean.Vip" />
</beans>

编写测试

package com.bjpowernode.spring6.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        // 第一步：获取Spring容器对象
        // 这行代码只要执行：就相当于启动了Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml","xml/beans.xml");
        // 第二步：根据bean的id从Spring容器中获取这个对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
        Object vipBean = applicationContext.getBean("vipBean");
        System.out.println(vipBean);

    }
}

运行测试程序：

通过测试得知，spring的配置文件可以有多个，在ClassPathXmlApplicationContext构造方法的参数上传递文件路径即可！这是为什么呢？通过源码可以看到参数是一个可变长度参数：

（6）在配置文件中配置的类必须是自定义的吗，可以使用JDK中的类吗，例如：java.util.Date？

spring.xml中增加配置

<bean id="dateBean" class="java.util.Date"/>

编写测试

package com.bjpowernode.spring6.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        // 第一步：获取Spring容器对象
        // 这行代码只要执行：就相当于启动了Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml","xml/beans.xml");
        // 第二步：根据bean的id从Spring容器中获取这个对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
        Object vipBean = applicationContext.getBean("vipBean");
        System.out.println(vipBean);

        // 使用JDK中的类
        Object bean = applicationContext.getBean("dateBean");
        System.out.println(bean);

    }
}

运行测试程序：当然是可以的

（7）getBean()方法调用时，如果指定的id不存在会怎样？

运行测试程序：

通过测试得知：当id不存在的时候，会出现异常，而不是返回null！

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

对获取的时间进行格式化

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--配置bean，这样spring才能帮助我们管理这个对象-->
        <bean id="dateBean" class="java.util.Date" />
</beans>

编写测试

第一种方法：直接进行强制类型转换。

第二种方法：多传一个参数，这个参数指定要转换的类型，例如：要转换成Date类型就是Date.class。

package com.bjpowernode.spring6.test;

import com.bjpowernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        // -------------第一种方法
        // 返回的是一个Object类型
        Object dateBean = applicationContext.getBean("dateBean");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 这个里面要传Date，需要强转
        Date date = (Date) dateBean;
        String nowDate = sdf.format(date);
        System.out.println(nowDate);
        // -------------第二种方法
        Date dateBean1 = applicationContext.getBean("dateBean", Date.class);
        String nowDate1 = sdf.format(dateBean1);
        System.out.println(nowDate1);
    }
}

执行结果：

（9）ClassPathXmlApplicationContext是从类路径中加载配置文件，如果没有在类路径当中，又应该如何加载配置文件呢？

例如：在d盘下的spring.xml，怎样去加载？

调用的方法都不同了，调用的是FileSystemXmlApplicationContext方法，并把文件的绝对路径传过去！

User.java

package com.bjpowernode.spring6.bean;

public class User {
    public void doSome(){
        System.out.println("doSome方法执行了");
    }
}

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--配置bean，这样spring才能帮助我们管理这个对象-->
        <bean id="userBean" class="com.bjpowernode.spring6.bean.User" />
        <bean id="dateBean" class="java.util.Date" />
</beans>

编写测试

package com.bjpowernode.spring6.test;

import com.bjpowernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        FileSystemXmlApplicationContext applicationContext = new FileSystemXmlApplicationContext("D:\\spring.xml");
        User user = applicationContext.getBean("userBean", User.class);
        user.doSome();
    }
}

运行结果：也能正常的加载创建对象 

（10）ApplicationContext的超级父接口BeanFactory

①ApplicationContext接口的一个超级父接口是：BeanFactory，翻译为Bean工厂，就是能够生产Bean对象的一个工厂对象。
②BeanFactory是IoC容器的顶级接口！
③实际上Spring的IoC容器底层实际上使用了：工厂模式。
④Spring底层的IoC是怎么实现的？XML解析 + 工厂模式 + 反射机制

（11）何时创建对象？

User.java

package com.bjpowernode.spring6.bean;

public class User {
    public User() {
        System.out.println("User的无参数构造方法执行。");
    }
}

spring.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--配置bean，这样spring才能帮助我们管理这个对象-->
        <bean id="userBean" class="com.bjpowernode.spring6.bean.User" />
</beans>

编写测试

package com.bjpowernode.spring6.test;

import com.bjpowernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        // 此时就把对象已经创建出来了
        new ClassPathXmlApplicationContext("spring.xml");
    }
}

执行结果：

①实际上在执行new ClassPathXmlApplicationContext(“spring.xml”);时对象就创建出来了。

②调用getBean方法，只是从集合当中把数据取出来！

5. Spring6启用Log4j2日志框架

从Spring5之后，Spring框架支持集成的日志框架是Log4j2；如何启用日志框架？

第一步：在pom.xml中引入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] %-3level %logger{1024} - %msg%n"/>
        </console>
    </appenders>

</configuration>

第三步：使用日志框架 

①第一步：调用LoggerFactory的getLogger方法，返回日志记录器对象，参数是某个具体的类，例如：获取FirstSpringTest类的日志记录器对象，参数就是FirstSpringTest.class，也就是说只要是FirstSpringTest类中的代码执行记录日志的话，就输出相关的日志信息。

②第二步：记录日志，根据不同的调用级别来输出日志。

package com.bjpowernode.spring6.test;

import com.bjpowernode.spring6.bean.User;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

public class FirstSpringTest {
    @Test
    public void testFirstSpringTest(){
        new ClassPathXmlApplicationContext("spring.xml");

        // 第一步：创建日志记录器对象
        Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
        // 第二步：记录日志，根据不同的级别来输出日志
        logger.info("我是一条消息");
        logger.debug("我是一条调试信息");
        logger.error("我是一条错误信息");
    }
}

执行结果：

前面我们设置的级别是 DEBUG ，级别比info和error级别都低，级别越高输出的信息越少，级别越低输出的信息越多；所以这三条日志都会输出！