Spring 6（一）【Spring 入门】

前言

好久没有写博客了，最近刚忙完考试，眼下又是英语四六级。Flink 按说应该是大数据学习的主线任务，但是长时间学一门技术还是心累的。正好之前对 Java 注解有了进一步的熟悉，一直想着熟悉巩固。所以，今天开始就来深入学习一下 Spring，之前其实已经草率的过了一遍了，但当时基础一般般，理解的一般般，Spring 这门技术是非常值得深入研究的。所以，相信这次刷过去，再用到以后的 Java 开发中相信会十分方便（比如 JavaFX + SpringBoot 以及以后的大数据开发）。

1、概述

1.1、Spring是什么？

Spring 是一款主流的 Java EE 轻量级开源框架，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于 简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益（包括我一直再学习的 JavaFX 应用）。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力（Mybatis 等）。

Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然成为了 Java EE 代名词，成为了构建 Java EE 应用的事实标准。自 2004 年 4 月，Spring 1.0 版本正式发布以来，Spring 已经步入到了第 6 个大版本，也就是 Spring 6。

1.2、Spring 的狭义和广义

在不同的语境中，Spring 所代表的含义是不同的。

广义的 Spring：Spring 技术栈

广义上的 Spring 泛指以 Spring Framework 为核心的 Spring 技术栈。

经过十多年的发展，Spring 已经不再是一个单纯的应用框架，而是逐渐发展成为一个由多个不同子项目（模块）组成的成熟技术，例如 Spring Framework、Spring MVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，其中 Spring Framework 是其他子项目的基础。

这些子项目涵盖了从企业级应用开发到云计算等各方面的内容，能够帮助开发人员解决软件发展过程中不断产生的各种实际问题，给开发人员带来了更好的开发体验。

狭义的 Spring：Spring Framework

狭义的 Spring 特指 Spring Framework，通常我们将它称为 Spring 框架。

Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的

Spring 有两个最核心模块： IoC 和 AOP。

IOC：Inverse of Control 的简写，译为“控制反转”。指把创建对象过程交给 Spring 进行管理（也就是 Spring 帮我们管理对象的整个生命周期，我们使用时只需要通过 Spring 来获取对象即可）。
AOP：Aspect Oriented Programming 的简写，译为“面向切面编程”。AOP 用来封装多个类的公共行为，将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度（这个在学设计模式中了解过）。另外，AOP 还解决一些系统层面上的问题，比如日志、事务、权限等。

1.3、Spring Framework特点

非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
控制反转：IoC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。
面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。
容器：Spring IoC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。（我们不用自己写 JavaBean）
组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML 和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。
一站式：在 IoC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且 Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。

1.4、Spring 模块组成

可以看到，Spring 对很多其它框架进行了整合，使得我们使用起来更加方便。

2、Spring 入门

2.1、环境搭建

JDK 17+
Maven 3.6.3
Spring 6.0.2

2.2、模块构建

我们尽量不要把所有代码都放到一个模块，而是在主模块下多建几个子模块。

创建普通 Maven 项目（名为 Sping6） -> 创建子模块（Spirng-01）

2.3、开发测试

2.3.1、导入依赖

<dependencies>
    <!--spring context依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.2</version>
    </dependency>

    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>

2.3.2、创建 Java 类

package com.lyh.study;

public class User {
    void add(){
        System.out.println("add...");
    }
}

简单起见，这里的 POJO 我们只定义一个方法。

2.3.3、创建 Spring 配置文件

Spring 配置文件是一个 XML 文件，名字可以随便起（比如 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="user" class="com.lyh.study.User"/>

</beans>

这里的 User 我们把它注册到了 Spring 的配置文件中，同样简单起见，这个 bean 标签只用了两个属性：

id：这个对象唯一标识（默认是单例模式，即返回同一个对象）
class：这个对象的全类名

    @Test
    public void testUser(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        User user1 = (User)ac.getBean("user");
        User user2 = (User)ac.getBean("user");
        System.out.println(user1.hashCode());
        System.out.println(user2.hashCode());
    }

运行结果：

124323713
124323713

单例模式？

结果说明，在Spring框架中，bean的默认作用域是单例（singleton）。这意味着Spring IoC容器在整个应用中只为每个bean创建一个实例。当你向容器请求一个bean时，它返回对该单例实例的引用。

如果希望每次返回是不同的对象，只需要修改 Bean 标签：

<bean id="user" class="com.lyh.study.User" scope="prototype"/>

我们的返回的 bean 对象为什么要强转？

因为反射返回的对象都是 Object 对象。

2.3.4、测试

创建测试类：

package com.lyh.study;

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

public class UserTest {

    @Test
    public void testUser(){
        // 加载spirng配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        // 获取bean对象
        User user = (User)ac.getBean("user");
        // 调用对象方法测试
        user.add();
    }
}

运行结果：

add...

2.4、实现原理分析

这里我们分析一下实现的原理，之前学习的反射的知识就要派上用场了。

2.4.1、无参构造会被调用吗？

答案是肯定的，毕竟我们都知道（我知道），Spring 本就是反射实现的嘛。而反射的原理：Class 对象调用 newInstance 方法会默认执行我们的无参构造方法来初始化对象。所以无参构造一定会被调用。

2.4.2、对象怎么创建出来的？

1. 加载 Spring 配置文件 beans.xml

2. 解析配置文件

3. 获取 bean 标签属性值（id 和 class）

4. 使用反射根据类的全类名创建对象

// 反射获得Class对象
Class<?> aClass = Class.forName("com.lyh.study.User");
// 调用方法创建对象
User user = (User)aClass.getDeclaredConstructor().newInstance();

这里需要注意的是，我们 JDK 8 中是直接 Class对象.newInstance() 创建对象的，但是我们 JDK17 已经把这个方法弃用了。

2.4.3、创建出来的对象放到了哪里？

查看源码我们可以发现，我们的 bean 对象其实都被存储在了 DefaultListableBeanFactory 这个类中：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

可以看到，我们的 Bean 被存储在了 Map 中，所以我们使用 Spring 创建对象时都是通过上下文对象（ApplicationContext）的 getBean 方法来创建对象，而这个 getBean 方法其实就是调用了 Map 的 get 方法通过 key（我们指定的 Bean 的唯一标识 id）来获得 value （也就是我们 Bean 的描述信息，即 Bean 标签的属性），只不过 getBean 方法帮我们进行了封装，使得我们直接通过 getBean 方法就可以获得一个创建好的 Bean 对象。

2.5、使用日志框架 Log4j2

2.5.1、Log4j2日志概述

在项目开发中，日志十分的重要，不管是记录运行情况还是定位线上问题，都离不开对日志的分析。日志记录了系统行为的时间、地点、状态等相关信息，能够帮助我们了解并监控系统状态，在发生错误或者接近某种危险状态时能够及时提醒我们处理，同时在系统产生问题时，能够帮助我们快速的定位、诊断并解决问题。

Apache Log4j2 是一个开源的日志记录组件，使用非常的广泛。在工程中以易用方便代替了 System.out 等打印语句，是JAVA下最流行的日志输入工具。

Log4j2 主要由几个重要的组件构成：

日志信息的优先级。日志信息的优先级从高到低有TRACE < DEBUG < INFO < WARN < ERROR < FATAL
1. TRACE：追踪，是最低的日志级别，相当于追踪程序的执行
2. DEBUG：调试，一般在开发中，都将其设置为最低的日志级别
3. INFO：信息，输出重要的信息，使用较多
4. WARN：警告，输出警告的信息
5. ERROR：错误，输出错误信息 FATAL：严重错误
日志信息的输出目的地，日志信息的输出目的地指定了日志将打印到控制台还是文件中；
日志信息的输出格式，而输出格式则控制了日志信息的显示内容。

注意：

这些级别分别用来指定这条日志信息的重要程度；级别高的会自动屏蔽级别低的日志，也就是说，设置了WARN的日志，则INFO、DEBUG的日志级别的日志不会显示

2.5.2、引入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>

2.5.3、加入日志配置文件

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

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <loggers>
        <!--
            level指定日志级别，从低到高的优先级：
                TRACE < DEBUG < INFO < WARN < ERROR < FATAL
                trace：追踪，是最低的日志级别，相当于追踪程序的执行
                debug：调试，一般在开发中，都将其设置为最低的日志级别
                info：信息，输出重要的信息，使用较多
                warn：警告，输出警告的信息
                error：错误，输出错误信息
                fatal：严重错误
        -->
        <root level="DEBUG">
            <appender-ref ref="spring6log"/>
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="log"/>
        </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>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="log" fileName="d:/spring6_log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!-- 这个会打印出所有的信息，
            每次大小超过size，
            则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，
            作为存档-->
        <RollingFile name="RollingFile" fileName="d:/spring6_log/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
            <!-- DefaultRolloverStrategy属性如不设置，
            则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
    </appenders>
</configuration>

2.5.4、使用日志

package com.lyh.study;

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserTest {
    private Logger logger = LoggerFactory.getLogger(UserTest.class);
    @Test
    public void testUser(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)ac.getBean("user");
        user.add();
        logger.info("执行成功");
    }
}

运行结果:

2023-12-15 12:46:22 485 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6b3e12b5
2023-12-15 12:46:22 645 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 1 bean definitions from class path resource [beans.xml]
2023-12-15 12:46:22 677 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'user'
add...
2023-12-15 12:46:22 717 [main] INFO com.lyh.study.UserTest - 执行成功