Spring 6(一)【Spring 入门】

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: 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 主要由几个重要的组件构成:

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

注意:

       这些级别分别用来指定这条日志信息的重要程度;级别高的会自动屏蔽级别低的日志,也就是说,设置了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 - 执行成功

总结

       过了大半年再学一遍,明显要感觉理解起来要轻松多了,得益于课下对 Java 基础的不断深入练习(比如算法、大量的 JavaFX 代码的编写)学之前觉得浪费时间,现在发现不仅理解更加深刻了,而且似乎也不需要多么仔细地听视频的讲解,直接刷刷地过,哪里不懂点哪里,难道这就是所谓的新手福利期?希望如此。

       关于概念的东西,必须框架的特点啥的我认为是有必要知道的,作为一名准程序员,我觉得不应该每天只停留在编写程序上,那整个人太无趣了。多一些概念性的东西(背景也好、用词也好),至少让自己的表达能力多扩展一点。

相关实践学习
日志服务之数据清洗与入湖
本教程介绍如何使用日志服务接入NGINX模拟数据,通过数据加工对数据进行清洗并归档至OSS中进行存储。
相关文章
|
2月前
|
XML Java 数据格式
Spring框架入门:IoC与DI
【5月更文挑战第15天】本文介绍了Spring框架的核心特性——IoC(控制反转)和DI(依赖注入)。IoC通过将对象的创建和依赖关系管理交给容器,实现解耦。DI作为IoC的实现方式,允许外部注入依赖对象。文章讨论了过度依赖容器、配置复杂度等常见问题,并提出通过合理划分配置、使用注解简化管理等解决策略。同时,提醒开发者注意过度依赖注入和循环依赖,建议适度使用构造器注入和避免循环引用。通过代码示例展示了注解实现DI和配置类的使用。掌握IoC和DI能提升应用的灵活性和可维护性,实践中的反思和优化至关重要。
52 4
|
2月前
|
前端开发 Java 数据库连接
Spring系列文章1:Spring入门程序
Spring系列文章1:Spring入门程序
|
4天前
|
监控 安全 Java
Spring Boot最佳实践:从入门到精通
Spring Boot最佳实践:从入门到精通
|
18天前
|
Java 开发者 Spring
从入门到精通,Spring 框架带你玩转 Java 企业应用开发!
【6月更文挑战第25天】Spring框架简化了Java企业开发,通过依赖注入降低耦合,如使用构造函数注入`UserService`中的`UserDao`。它还提供声明式事务管理,如`@Transactional`注解自动处理事务,减少手动错误。此外,Spring的AOP支持允许在不侵入业务逻辑的情况下实现横切关注点,如`LoggingAspect`所示。无论是新手还是资深开发者,Spring以其全面的功能和灵活性成为企业应用开发的强大工具。
|
11天前
|
前端开发 Java 数据库连接
Spring6(一):入门案例
Spring6(一):入门案例
9 0
|
12天前
|
监控 安全 Java
Spring Boot最佳实践:从入门到精通
Spring Boot最佳实践:从入门到精通
|
1月前
|
Java 数据库连接 数据库
Spring日志完结篇,MyBatis操作数据库(入门)
Spring日志完结篇,MyBatis操作数据库(入门)
|
1月前
|
存储 自动驾驶 Java
Spring IoC&DI(1)—入门
Spring IoC&DI(1)—入门
16 1
|
1月前
|
JSON 前端开发 Java
Spring Web MVC入门(3)——响应
Spring Web MVC入门(3)——响应
29 1
|
23天前
|
Java 程序员 开发工具
Spring - SpringBoot入门之环境搭建
Spring - SpringBoot入门之环境搭建
20 0