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 6(一)【Spring 入门】_第1张图片

可以看到,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、导入依赖


    
    
        org.springframework
        spring-context
        6.0.2
    

    
    
        org.junit.jupiter
        junit-jupiter-api
        5.3.1
    

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)。




    

这里的 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 对象为什么要强转?

 因为反射返回的对象都是 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 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:严重错误
  2. 日志信息的输出目的地,日志信息的输出目的地指定了日志将打印到控制台还是文件中
  3. 日志信息的输出格式,而输出格式则控制了日志信息的显示内容。

注意:

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

2.5.2、引入Log4j2依赖



    org.apache.logging.log4j
    log4j-core
    2.19.0


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

2.5.3、加入日志配置文件

在类的根路径下提供log4j2.xml配置文件(文件名固定为:log4j2.xml,文件必须放到类根路径下。)



    
        
        
            
            
            
        
    

    
        
        
            
            
        

        
        
            
        

        
        
            
            
            
            
        
    

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 代码的编写)学之前觉得浪费时间,现在发现不仅理解更加深刻了,而且似乎也不需要多么仔细地听视频的讲解,直接刷刷地过,哪里不懂点哪里,难道这就是所谓的新手福利期?希望如此。

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

你可能感兴趣的:(Spring,spring,java,后端)