03 Spring的入门程序

，## 3.1 Spring 的下载

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

![[03.01-1.webp]] 官网地址（中文）：http://spring.p2hp.com/

![[03.01-2.webp]]

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

![[03.01-3.webp]]

我们即将要学习的就是 Spring Framework。
怎么下载呢？
- 第一步：进入 github

![[03.01-4.webp]]

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

![[03.01-5.webp]]

第三步：找到下图位置，点击超链接 ![[03.01-6.webp]]

第四步：按照下图步骤操作 ![[03.01-7.webp]] 第五步：继续在 springframework 目录下找下图的 spring，点开之后你会看到很多不同的版本 ![[03.01-8.webp]] 第六步：选择对应的版本 ![[03.01-9.webp]] 第七步：点击上图的 url

![[03.01-10.webp]]

点击 spring-5.3.9-dist. zip 下载 spring 框架。
将下载的 zip 包解压：

![[03.01-11.webp]]

docs：spring 框架的 API 帮助文档
libs：spring 框架的 jar 文件（用 spring 框架就是用这些 jar 包）
schema：spring 框架的 XML 配置文件相关的约束文件

3.2 Spring 的 jar 文件¶

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

![[03.02-1.webp]]

spring-core-5.3.9. jar：字节码（这个是支撑程序运行的 jar 包）
spring-core-5.3.9-javadoc. jar：代码中的注释
spring-core-5.3.9-sources. jar：源码

我们来看一下 spring 框架都有哪些 jar 包： ![[03.02-2.webp]]

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 以及进行 Inversion ofControl / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的 IoC/DI 支持，引入 spring-core. jar 及 spring-beans. jar 文件就可以了。
spring-context-5.3.9. jar	这个 jar 文件为 Spring 核心提供了大量扩展。可以找到使用 Spring ApplicationContext 特性时所需的全部类，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	Spring 3.0 对服务器的代理接口。
spring-jcl-5.3.9. jar	Spring 的日志模块。JCL，全称为"Jakarta Commons Logging"，也可称为"Apache Commons Logging"。
spring-jdbc-5.3.9. jar	Spring 对 JDBC 的支持。
spring-jms-5.3.9. jar	这个 jar 包提供了对 JMS 1.0.2/1.1 的支持类。JMS 是 Java 消息服务。属于 JavaEE 规范之一。
spring-messaging-5.3.9. jar	为集成 messaging api 和消息协议提供支持
spring-orm-5.3.9. jar	Spring 集成 ORM 框架的支持，比如集成 hibernate，mybatis 等。
spring-oxm-5.3.9. jar	为主流 O/X Mapping 组件提供了统一层抽象和封装，OXM 是 Object Xml Mapping。对象和 XML 之间的相互转换。
spring-r 2 dbc-5.3.9. jar	Reactive Relational Database Connectivity (关系型数据库的响应式连接) 的缩写。这个 jar 文件是 Spring 对 r 2 dbc 的支持。
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 是 Spring 5 添加的新模块，用于 web 的开发，功能和 SpringMVC 类似的，Webflux 使用当前一种比较流程响应式编程出现的框架。
spring-webmvc-5.3.9. jar	SpringMVC 框架的类库
spring-websocket-5.3.9. jar	Spring 集成 WebSocket 框架时使用
注意：
如果你只是想用 Spring 的 IoC 功能，仅需要引入：spring-context 即可。将这个 jar 包添加到 classpath 当中。

如果采用 maven 只需要引入 context 的依赖即可。

```XML title:spring bean 的依赖.xml

repository.spring.milestone Spring Milestone Repository https://repo.spring.io/milestone

org.springframework spring-context 6.0.0-M2

---
## 3.3 第一个 Spring 程序

前期准备：  
- 打开 IDEA 创建 Empty Project：spring 6

![[03.03-3.webp]]

设置 JDK 版本 17，编译器版本 17
![[03.03-4.webp]]

设置 IDEA 的 Maven：关联自己的 maven
![[03.03-5.webp]]

在空的工程 spring 6 中创建第一个模块：spring 6-001-first
![[03.03-6.webp]]


第一步：添加 spring context 的依赖，pom. xml 配置如下

```XML title: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.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 表达式

![[03.03-7.webp]]

第二步：添加 junit 依赖

```XML title:pom.xml

4.0.0

<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>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

第三步：定义 bean：User

```Java title:User.java
package com.powernode.spring6.bean;

/**
 * bean，封装用户信息。
 * @author 动力节点
 * @version 1.0
 * @since 1.0
 */
public class User {
}

第四步：编写 spring 的配置文件：beans. xml。该文件放在类的根路径下。 ![[03.03-8.webp]]

上图是使用 IDEA 工具自带的 spring 配置文件的模板进行创建。
配置文件中进行 bean 的配置。

```XML title:beans.xml

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

bean 的 id 和 class 属性： - id 属性：代表对象的唯一标识。可以看做一个人的身份证号。 - class 属性：用来指定要创建的 java 对象的类名，这个类名必须是全限定类名（带包名）。第五步：编写测试程序Java title:Spring6test.java package com.powernode.spring6.test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; 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); } } ```

第七步：运行测试程序 ![[03.03-9.webp]]

3.4 第一个 Spring 程序详细剖析¶

```xml title:beans.xml

```java title=Spring6Test.testFirst()
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); Object userBean = applicationContext.getBean("userBean");

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

```java title:Vip.java package com.powernode.spring6.bean; /** * @author 动力节点 * @version 1.0 * @className Vip * @since 1.0 **/ public class Vip { }

```Xml title: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"
       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>

运行测试程序： ![[Java/Java_Spring/attachments/03 Spring的入门程序/03.04-1.webp]]

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

底层是怎么创建对象的，是通过反射机制调用无参数构造方法吗？

```java title:User.java package com.powernode.spring6.bean;

/** * bean，封装用户信息。 * @author 动力节点 * @version 1.0 * @since 1.0 */ public class User { public User() { System.out.println("User的无参数构造方法执行"); } }

运行测试程序：
![[03.04-2.webp]]


运行测试程序：
![[03.04-3.webp]]

通过测试得知：**创建对象时确实调用了无参数构造方法。**  


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

```java title:User.java
package com.powernode.spring6.bean;

/**
 * bean，封装用户信息。
 * @author 动力节点
 * @version 1.0
 * @since 1.0
 */
public class User {
    /*public User() {
        System.out.println("User的无参数构造方法执行");
    }*/

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

运行测试程序： ![[03.04-4.webp]]

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

Spring 是如何创建对象的呢？原理是什么？ ```java title:测试 // dom4j解析beans.xml文件，从中获取class的全限定类名 // 通过反射机制调用无参数构造方法创建对象 Class clazz = Class.forName("com.powernode.spring6.bean.User"); Object obj = clazz.newInstance();
```
3 把创建好的对象存储到一个什么样的数据结构当中了呢？
![[03.04-5.webp]]

- spring 配置文件的名字必须叫做 beans. xml 吗？

```java title:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
```

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

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

再创建一个 spring 配置文件，起名：spring. xml ```XML title:Spring.xml

```Java title:Spring6Test.testFirst()
package com.powernode.spring6.test;

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

public class Spring6Test {

    @Test
    public void testFirst(){
        // 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml","spring.xml");

        // 根据id获取bean对象
        Object userBean = applicationContext.getBean("userBean");
        Object vipBean = applicationContext.getBean("vipBean");

        System.out.println(userBean);
        System.out.println(vipBean);
    }
}

运行测试程序： ![[03.04-6.webp]]

通过测试得知，spring 的配置文件可以有多个，在 ClassPathXmlApplicationContext 构造方法的参数上传递文件路径即可。

这是为什么呢？通过源码可以看到： ![[03.04-7.webp]]

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

```XML title:beans.xml

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

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

Java title:通过测试得知：创建对象时确实调用了无参数构造方法。 package com.powernode.spring6.test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Spring6Test { @Test public void testFirst(){ // 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象） ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml","spring.xml"); // 根据id获取bean对象 Object userBean = applicationContext.getBean("userBean"); Object vipBean = applicationContext.getBean("vipBean"); Object dateBean = applicationContext.getBean("dateBean"); System.out.println(userBean); System.out.println(vipBean); System.out.println(dateBean); } } ```

运行测试程序： ![[03.04-8.webp]]

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

getBean() 方法调用时，如果指定的 id 不存在会怎样？ ![[03.04-10.webp]]

运行测试程序： ![[03.04-11.webp]]

通过测试得知，当 id 不存在的时候，会出现异常。

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

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

ClassPathXmlApplicationContext 是从类路径中加载配置文件，如果没有在类路径当中，又应该如何加载配置文件呢？ ![[03.04-12.webp]]

```XML title:Spring6.xml

```java
ApplicationContext applicationContext2 = new FileSystemXmlApplicationContext("d:/spring6.xml"); Vip vip = applicationContext2.getBean("vipBean2", Vip.class); System.out.println(vip);

没有在类路径中的话，需要使用 FileSystemXmlApplicationContext 类进行加载配置文件。
这种方式较少用。一般都是将配置文件放到类路径当中，这样可移植性更强。

ApplicationContext 的超级父接口 BeanFactory。

BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring.xml"); Object vipBean = beanFactory.getBean("vipBean"); System.out.println(vipBean);

BeanFactory 是 Spring 容器的超级接口。ApplicationContext 是 BeanFactory 的子接口。

3.5 Spring 6 启用 Log 4 j 2 日志框架¶

从 Spring 5 之后，Spring 框架支持集成的日志框架是 Log4j2. 如何启用日志框架：
第一步：引入 Log 4 j 2 的依赖

```XML title:porm.xml

org.apache.logging.log4j log4j-core 2.19.0 org.apache.logging.log4j log4j-slf4j2-impl 2.19.0

第二步：在类的根路径下提供 `log 4 j 2. xml` 配置文件（文件名固定为：`log 4 j 2. xml`，文件必须放到类根路径下。）
```XML title: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>

第三步：使用日志框架 Java 日志框架 Logger logger = LoggerFactory.getLogger(FirstSpringTest.class); logger.info("我是一条日志消息");