devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring6-基础概念_spring 6

作者：小丑西瓜9 | 2024-06-15 01:52:38

赞

踩

spring 6

1. 概述

1.1. Spring是什么

Spring 是一套广泛应用于 Java 企业级应用开发领域的轻量级开源框架，由 Rod Johnson 创立，旨在显著降低 Java 企业应用的复杂性，缩短开发周期，并提升开发效率。Spring 不仅适用于服务器端开发，也因其简单的设计、卓越的可测试性和倡导的松耦合原则，使得几乎所有类型的 Java 应用都能从中获得好处。

Spring 框架的核心价值在于提供了诸如控制反转（IoC）、面向切面编程（AOP）等机制，增强了代码的可维护性和可扩展性，并且集成了众多第三方库和框架，如数据库访问、事务管理、MVC、RESTful API 构建、安全控制等，从而形成了一个全方位的企业级应用开发解决方案。

随着版本的不断迭代升级，Spring 已发展到第 6 个主要版本——Spring 6.1.4，这个版本代表了 Spring 团队在响应式编程、模块化支持、性能优化、以及与现代 Java 和云原生环境兼容等方面的最新成果。

须知：现在是更新到了6.1.4，该笔记是基于尚硅谷的6.0.2

1.2. Spring 的狭义和广义

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

广义的 Spring：Spring 技术生态体系
在广义上，Spring 指的是围绕 Spring Framework 扩展建立的一个庞大的技术生态系统，其中包括多个紧密关联的子项目或模块。这个技术栈致力于满足不同层次的开发需求，例如 Web 开发（Spring MVC）、快速应用搭建（Spring Boot）、分布式服务治理（Spring Cloud）、数据访问抽象（Spring Data）、安全控制（Spring Security）等等。每一个子项目都基于 Spring Framework 的核心能力进行构建，为开发者提供了从基础架构到高级应用场景的一整套解决方案。

狭义的 Spring：Spring Framework
狭义上的 Spring 即 Spring Framework，这是整个 Spring 生态系统的核心部分，通常我们称之为 Spring 框架。它是一种轻量级的 Java 应用开发框架，通过提供 IoC（控制反转）和 AOP（面向切面编程）两大核心技术，简化了企业级应用的复杂性，提升了开发效率。

  • IoC (Inver of Control 控制反转)：这是一种设计思想，意味着对象的创建不再由程序本身直接控制，转而交由 Spring 容器统一管理和负责创建、注入。这样可以降低代码之间的耦合度，提高组件重用性和可测试性。
  • AOP (Aspect of Control 面向切面编程)：AOP 主要是针对横切关注点进行处理的技术，它可以将分散在各个业务模块中的通用功能（如日志记录、事务管理、权限验证等）抽取出来形成“切面”，然后织入到目标组件执行的过程中。这种机制极大地减少了代码重复，提高了系统的可维护性和灵活性，同时降低了模块间的耦合度。

总结简单解释就是

广义的 Spring可以理解为一个完整的 Java 技术生态系统，包括一系列由 Spring 团队开发和维护的子项目，这些项目各具特色，互相配合，共同服务于企业级应用的开发全过程，从基础的依赖注入、面向切面编程，到 Web 开发、微服务架构、数据访问、安全性控制等方面均有覆盖，极大地方便了开发者构建高质量、高效率的软件系统。

狭义的 Spring则特指 Spring Framework 这一具体框架，它是整个 Spring 生态系统的基石。Spring Framework 通过实现控制反转（IoC）来解耦组件之间的依赖关系，让代码更加灵活易管理；同时，它引入了面向切面编程（AOP）机制，使得开发者能方便地在系统中定义和应用横切关注点，如日志、事务管理等，进而增强代码复用性和系统可维护性。

1.3. Spring Framework特点

Spring Framework 的五大特点：

  1. 非侵入式设计：
  • Spring 在不影响应用程序原有结构的前提下提供强大的功能支持。它允许开发者保持领域模型的纯净，仅需在功能性组件上添加少量注解，即可无缝集成 Spring 功能，使整体架构更为整洁、精炼。
  • Spring Framework 设计得非常巧妙，就像一位隐形助手。在你使用它的功能时，不需要大幅改动你的原有代码结构或者模型。比如，你只需在需要的地方轻轻添加几个注解（像是贴标签一样），Spring 就能识别并帮你完成复杂的依赖管理，而不改变你的核心业务逻辑代码，让代码更清爽，易于理解和维护。

  1. 控制反转 (IoC)：
  • Spring 引入了 IoC 原则，即控制权由应用程序转移到容器，实现了资源的自动装配和管理。开发人员无需手动创建和管理对象，而是由 Spring 容器负责创建和组装对象，通过依赖注入的方式供应用程序使用。
  • IoC 就像一个贴心的管家。在没有 Spring 之前，你需要自己动手创建对象、找对象并管理它们的关系。有了 IoC 后，你就不用亲自操心这些事情了。你只需要告诉 Spring 容器你想要什么，Spring 会主动为你准备妥当，然后送到你面前（即所谓的资源注入）。这样一来，你的代码变得更专注于业务逻辑，而非对象的创建和管理。

  1. 面向切面编程 (AOP)：
  • Spring 支持 AOP，允许开发者在不修改原始代码的情况下，通过声明式的方式对程序进行功能增强。这种方式有助于提高代码的复用性和模块间的解耦。
  • AOP 就像是给代码加了一个神奇的调料包。在不修改主菜（业务代码）的前提下，你可以通过 AOP 添加一些通用的功能，比如“调味品”（如日志、权限检查、事务管理等）。这些“调料”会在合适的时间自动加入到“主菜”中，让你的代码具备更多功能的同时，保持主体部分干净简洁，避免了重复代码和过度耦合。

  1. 容器化管理：
  • Spring IoC 容器扮演着组件工厂的角色，全面管理组件对象的生命周期。容器提供的自动化管理大大减轻了开发者的负担，简化了对象的创建和管理过程，显著提高了开发效率。
  • Spring IoC 容器就如同一个全能的智能工场，它负责孕育和管理所有对象（组件）的生命周期。当你注册组件到容器后，容器会帮你实例化对象、管理对象间依赖关系，甚至还能自动回收无用的对象。这种容器化管理大大降低了编程的复杂度，让开发者更专注于业务逻辑的实现，而不是琐碎的底层对象管理工作。

  1. 组件化与一站式整合：
  • Spring 支持组件化开发，通过 XML 或 Java 注解等方式灵活组装对象，便于构建复杂的大型应用系统。此外，Spring 凭借其 IoC 和 AOP 的核心能力，可以很好地集成各类开源框架和第三方类库，实现一站式开发，满足企业级应用的多元化需求。Spring 旗下的诸多项目已覆盖云计算、微服务、数据访问等多个层面，成为构建完整 Java 应用生态的理想选择。
  • Spring 提倡组件化开发，就好比搭积木一样，每个积木块都是一个独立且功能明确的小组件。通过简单的配置（XML 或 Java 注解），你可以把这些组件拼接在一起，构建出庞大而复杂的应用系统。同时，Spring 拥有一站式的整合能力，可以轻松融入多种开源框架和第三方库，从而为开发者打造了一站式的开发环境，让开发 Java 应用变得更加高效便捷。

1.4. Spring模块组成

官网地址：Spring | Home

上图中包含了 Spring 框架的所有模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。下面分别对这些模块的作用进行简单介绍。

  1. Spring Core（核心容器）
    • spring-core：提供Spring框架的基础功能，包括控制反转（IoC）和依赖注入（DI）的基本实现，使得开发者无需手动管理对象的创建和依赖关系。
    • spring-beans：定义了BeanFactory接口和相关的类，用于管理和装配Java Bean对象，这是Spring IoC容器的基础组件。
    • spring-context：扩展了BeanFactory，提供了ApplicationContext上下文，它是完整功能的IoC容器，还包含国际化、资源加载、事件传播等功能。
    • spring-expression（SpEL）：Spring表达式语言，提供了在运行时查询和操作对象图的强大的表达式语言。

  1. Spring AOP（面向切面编程）
    • spring-aop：实现面向切面编程的基础模块，支持代理机制如JDK动态代理、CGLIB字节码生成等方式。
    • spring-aspects：集成了AspectJ，增强了Spring框架的AOP能力，允许在程序中无缝插入横切关注点。
    • spring-instrument：提供了类加载器级别的代理工具类，主要用于监控和处理类加载过程，以便于进行AOP代理和其他类型的类增强。

  1. Spring Data Access
    • spring-jdbc：简化了JDBC的操作，提供了一套方便的API进行数据库访问。
    • spring-orm：提供了与主流ORM框架（如Hibernate、MyBatis等）的集成支持。
    • spring-oxm：提供对象与XML之间的映射支持，方便数据的序列化和反序列化。
    • spring-jms：对Java消息服务（JMS）的抽象封装，便于在分布式系统中实现消息传递。
    • spring-tx：实现了声明式事务管理，可以方便地在业务逻辑层进行事务控制。

  1. Spring Web
    • spring-web：提供了基本的Web应用支持，构建在Spring Context之上，可以通过Servlet或者监听器初始化IoC容器。
    • spring-webmvc：基于模型-视图-控制器（MVC）架构模式的实现，简化了Web应用程序的开发。
    • spring-websocket：提供WebSocket的支持，实现服务器与客户端的全双工实时通信。
    • spring-webflux：Spring 5.0后新增的非阻塞式Reactive Web框架，适用于异步、非阻塞、事件驱动的Web应用开发。

  1. Spring Messaging
    • spring-messaging：为Spring框架增加了对消息传递（Messaging）的支持，比如处理HTTP请求、WebSocket消息等。

  1. Spring Test
    • spring-test：提供了对JUnit和其他测试框架的集成支持，简化了对Spring应用进行集成测试的过程。

2. 入门案例开发

2.1. 环境要求

  • JDK：Java17+（Spring6要求JDK最低版本是Java17）
  • Maven：3.6+
  • Spring：6.0.2

注：我自己笔记上面演示的IDEA版本是2023.3.3，也是我现在用的版本

2.2. 构建模块

  1. 构建父模块spring6

这里Spring6是父工程，它的src文件可有可无，其中的子模块才是重点

  1. 构建子模块Spring6-First

2.3. 程序开发

第1步 引入spring相关依赖

第2步 创建类，定义属性和方法

第3步 按照spring要求创建配置文件(xml格式)

第4步 在spring配置文件配置相关信息

第5步 进行最终测试

  1. 第1步 引入Spring相关依赖

在Maven或Gradle项目中，通过pom.xml或build.gradle文件添加Spring框架及其相关的依赖项，例如Spring Core、Spring Context、Spring DAO等，以便在项目中使用Spring的功能。

在子模块下的Spring-First的pom.xml文件配置以下依赖

  1. <!-- 依赖关系定义 -->
  2.     <dependencies>
  3.         <!-- 引入Spring Context依赖，它是Spring框架的基础模块，提供了环境配置、Bean生命周期管理、事件传播等功能 -->
  4.         <dependency>
  5.             <groupId>org.springframework</groupId>
  6.             <artifactId>spring-context</artifactId>
  7.             <version>6.0.2</version>
  8.         </dependency>
  9.  
  10.         <!-- 引入JUnit5测试框架，用于编写和运行单元测试 -->
  11.         <dependency>
  12.             <groupId>org.junit.jupiter</groupId>
  13.             <artifactId>junit-jupiter-api</artifactId>
  14.             <version>5.3.1</version>
  15.         </dependency>
  16.     </dependencies>

刷新后并查看依赖

  1. 第2步 创建类，定义属性和方法
  • 根据业务逻辑，创建Java类，包括实体类（Entity）、数据访问接口（DAO，Data Access Object）、实现类、服务类（Service）以及控制器类（Controller）等。在类中定义属性及相应的getter/setter方法，以及业务处理方法。

  1. 第3步 按照Spring要求创建配置文件（XML格式）
  • 在项目的资源目录下创建Spring的核心配置文件，如applicationContext.xml或spring-config.xml，用于配置Spring容器如何管理和装配bean。

在resources文件夹创建Spring配置文件，名字无所谓，但后缀要为 . xml

我这里为 bean.xml

  1. 第4步 在Spring配置文件配置相关信息
  • 在配置文件中声明bean，包括数据源、事务管理器、DAO实现类、服务类等，并通过<bean>标签定义它们的生命周期和依赖关系，也可以配置AOP、事务管理等相关设置。

创建完bean.xml配置文件后，配置该文件，像下面这样

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.  
  6.     <!-- 定义一个Bean实例，id为"helloWorld"，类型为com.sakurapaid.spring6_01.HelloWorld类 -->
  7.     <bean id="helloWorld" class="com.sakurapaid.spring6_01.HelloWorld">
  8.  
  9.     </bean>
  10.     
  11. </beans>

进一步说明：

Bean：在Spring框架中，Bean是一个由Spring IoC（控制反转）容器管理的对象。它是由Spring容器负责创建、装配以及管理其完整生命周期的Java对象。

id属性：每个Bean都需要一个唯一的标识符，id就是用来满足这一需求的属性。通过这个唯一的ID，开发者可以在Spring容器中方便地查找和获取所需的Bean。

class属性：class属性指定用来创建Bean实例的Java类的全限定名。当Spring容器读取到这个配置时，它会根据提供的类名创建对应的类实例，并依据需要进行依赖注入和其他配置处理，最终生成一个可操作的Bean对象供应用程序使用。

创建一个测试类HelloWorldTest，并写上对应内容

  1. package com.sakurapaid.spring6;
  2.  
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6.  
  7. public class HelloWorldTest {
  8.     @Test
  9.     public void test() {
  10.         //加载spring配置文件，对象创建
  11.         ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
  12.  
  13.         //获取创建对象
  14.         HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
  15.  
  16.         //调用方法，输出结果
  17.         helloWorld.sayHello();
  18.     }
  19. }

  1. 第5步 进行最终测试
  • 编写单元测试和集成测试，确保各个组件能够按照预期与Spring容器一起工作。启动应用并测试整体功能是否正常，如通过HTTP请求测试控制器层是否能正确调用服务层并返回响应。

2.4. 案例分析

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

修改HelloWorld类：

  1. public class HelloWorld {
  2.     //无参构造
  3.     public HelloWorld() {
  4.         System.out.println("这是无参构造输出的HelloWorld");
  5.     }
  6.     public void sayHello(){
  7.         System.out.println("HelloWorld");
  8.     }
  9. }

执行结果：

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

  1. Spring是如何创建对象的呢？原理是什么？
  1. // dom4j解析beans.xml文件，从中获取class属性值，类的全类名
  2.  // 通过反射机制调用无参数构造方法创建对象
  3.  Class clazz = Class.forName("com.sakurapaid.spring6.HelloWorld");
  4.  //Object obj = clazz.newInstance();
  5.  Object object = clazz.getDeclaredConstructor().newInstance();

当Spring框架读取配置文件（如beans.xml）时，它会通过DOM4J等XML解析工具解析出各个bean的定义信息，其中包括bean的类名。之后，Spring利用Java反射机制，通过Class.forName()方法加载指定类的字节码，然后调用getDeclaredConstructor().newInstance()方法创建该类的对象实例，这就相当于调用了无参构造函数来初始化对象。

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

bean对象最终存储在spring容器中，在spring源码底层就是一个map集合，存储bean的map在DefaultListableBeanFactory类中：

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

Spring容器加载到Bean类时 , 会把这个类的描述信息, 以包名加类名的方式存到beanDefinitionMap 中,Map<String,BeanDefinition> , 其中 String是Key , 默认是类名首字母小写 , BeanDefinition , 存的是类的定义(描述信息) , 我们通常叫BeanDefinition接口为 : bean的定义对象。

创建好的对象并不是立即丢弃，而是由Spring IoC（Inversion of Control，控制反转）容器统一管理。在Spring的底层实现中，对象是以Bean的形式存储在一个名为beanDefinitionMap的ConcurrentHashMap中。这个Map的键是Bean的名字（通常是类名首字母小写，遵循默认命名规则），值是BeanDefinition对象。BeanDefinition是一个接口，它包含了创建和配置Bean所需的所有元数据信息，如类名、构造函数参数、属性值、依赖关系等。这样，Spring容器就能根据需要随时查找、获取并初始化Bean对象。

  1. Spring创建对象的过程：
  • 当你在Spring配置文件中定义了一个Bean（比如HelloWorld类），Spring会读取这个配置文件，并找到你所指定的类名。
  • 然后，Spring利用Java的反射API，通过Class.forName()加载指定类的字节码（也就是类的定义）。
  • 接下来，Spring调用类的无参构造方法（即没有参数的构造函数）来创建这个类的一个实例，就像我们手动用new关键字创建对象一样。
  1. Spring管理对象的方式：
  • 创建出来的对象并不是单独存在，而是被Spring的IoC（控制反转）容器统一管理。
  • 这个容器实际上维护了一个类似字典的数据结构，也就是一个Map（具体是ConcurrentHashMap类型），其中：
    • 键（key）是Bean的名称，通常按照约定（如类名首字母小写）来命名。
    • 值（value）是BeanDefinition对象，它包含了创建和配置Bean所需要的所有细节，比如类的具体位置、属性值、依赖关系等。

简单来说，Spring通过读取配置文件，利用反射技术自动创建对象，并把这些对象的相关信息保存在一个特殊的“容器”中。当你需要使用某个对象时，只需告诉Spring它的名称，Spring就会从容器中取出已经创建好的对象给你使用。这样不仅简化了对象的创建过程，也使得对象间的依赖关系更容易管理和维护。这就是Spring框架的核心机制之一——IoC容器的作用。

总结起来就是，Spring通过解析配置文件获取类的信息，运用反射创建对象，并将这些对象以及对象的配置信息以一种高效的数据结构（Map）进行管理，实现了对Bean对象的集中控制和生命周期管理，这就是Spring框架的核心功能之一——IoC容器的运作机制

2.5. Log4j2日志框架

2.5.1. Log4j2概述

Apache Log4j2 是一款专为Java应用程序设计的强大且灵活的开源日志框架。在软件开发领域，尤其是在Java项目中，日志扮演着至关重要的角色，它能详尽地记录下系统运行过程中的各种事件和状态变化，就像一本详细的电子日记，涵盖了何时（when）、何地（where）、何种行为（what）以及为何发生（why）等重要信息。

Log4j2 是原始Log4j项目的重大升级版本，相较于传统的System.out.println()方法，它提供了更高级别的功能和控制能力，使得开发者能够根据不同的需求定制日志输出格式、级别、存储位置等，并且支持异步日志处理，提高了系统的性能表现。

以下几个关键特性体现了Log4j2的优势：

  1. 多级日志：Log4j2 支持多种日志级别，包括 TRACE、DEBUG、INFO、WARN、ERROR 和 FATAL，允许开发者根据实际需要调整日志详细程度，确保既能获取足够的调试信息，又不会因为过多的日志而影响性能或占用过多存储空间。
  2. 配置灵活：通过XML、JSON或Properties等格式的配置文件，开发者可以轻松地定义日志输出的格式、过滤规则、输出目的地（如控制台、文件、数据库等），甚至可以动态地重新加载配置文件，无需重启应用。
  3. 性能优化：Log4j2 引入了异步日志处理机制，这意味着即使在大量日志生成的情况下，也不会阻塞应用的主线程，显著提升了系统的响应速度。
  4. 扩展性好：Log4j2 设计上考虑了扩展性，开发者可以通过插件机制添加自定义的Appenders（输出器）、Filters（过滤器）和其他组件，满足特定应用场景的需求。

总之，Apache Log4j2 提供了一个全面、高效且可高度定制的日志解决方案，有助于提高软件开发效率、简化运维工作，并为系统的稳定性和可靠性提供有力支撑。对于任何Java项目，特别是大型企业级应用来说，选择Log4j2作为日志框架都是一个明智之举。

2.5.2. 引入Log4j2依赖

在pom.xml引入相关依赖

  1. <!--log4j2的依赖-->
  2. <dependency>
  3.     <groupId>org.apache.logging.log4j</groupId>
  4.     <artifactId>log4j-core</artifactId>
  5.     <version>2.19.0</version>
  6. </dependency>
  7. <dependency>
  8.     <groupId>org.apache.logging.log4j</groupId>
  9.     <artifactId>log4j-slf4j2-impl</artifactId>
  10.     <version>2.19.0</version>
  11. </dependency>

注意，我这里是写在了父工程里的子工程(Spring6-First)里面的pom文件

2.5.3. 加入日志配置文件

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3.     <loggers>
  4.         <!--
  5.             level指定日志级别，从低到高的优先级：
  6.                 TRACE < DEBUG < INFO < WARN < ERROR < FATAL
  7.                 trace：追踪，是最低的日志级别，相当于追踪程序的执行
  8.                 debug：调试，一般在开发中，都将其设置为最低的日志级别
  9.                 info：信息，输出重要的信息，使用较多
  10.                 warn：警告，输出警告的信息
  11.                 error：错误，输出错误信息
  12.                 fatal：严重错误
  13.         -->
  14.         <root level="DEBUG">
  15.             <appender-ref ref="spring6log"/>
  16.             <appender-ref ref="RollingFile"/>
  17.             <appender-ref ref="log"/>
  18.         </root>
  19.     </loggers>
  20.  
  21.     <appenders>
  22.         <!--输出日志信息到控制台-->
  23.         <console name="spring6log" target="SYSTEM_OUT">
  24.             <!--控制日志输出的格式-->
  25.             <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
  26.         </console>
  27.  
  28.         <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
  29.         <File name="log" fileName="F:/Program/Spring6Log/test.log" append="false">
  30.             <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
  31.         </File>
  32.  
  33.         <!-- 这个会打印出所有的信息，
  34.             每次大小超过size，
  35.             则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，
  36.             作为存档-->
  37.         <RollingFile name="RollingFile" fileName="F:/Program/Spring6Log/app.log"
  38.                      filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
  39.             <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  40.             <SizeBasedTriggeringPolicy size="50MB"/>
  41.             <!-- DefaultRolloverStrategy属性如不设置，
  42.             则默认为最多同一文件夹下7个文件，这里设置了20 -->
  43.             <DefaultRolloverStrategy max="20"/>
  44.         </RollingFile>
  45.     </appenders>
  46. </configuration>

在resources文件夹右键创建文件——log4j2.xml

注意，log4j2日志运行时会在本地生产日志文件，所以在配置文件里要设置日志文件的存放位置，比如我这里就是F盘下的

F:/Program/Spring6Log/test.log 和 F:/Program/Spring6Log/app.log

根据自己的实际情况来

2.5.4. 测试

运行刚才的程序 HelloWorldTest.java得到运行结果

2.5.5. 手动使用日志

上述为自动写入日志，其实也是可以手动写入日志的，如下述步骤

把刚才的测试类改为这样

  1. package com.sakurapaid.spring6_01;
  2.  
  3. import org.junit.jupiter.api.Test;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.context.ApplicationContext;
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;
  8.  
  9. public class HelloWorldTest {
  10.     @Test
  11.     public void test() {
  12.         
  13.         //获取日志对象
  14.         Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);
  15.  
  16.         //加载spring配置文件，对象创建
  17.         ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
  18.  
  19.         //获取创建对象
  20.         HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
  21.  
  22.         //调用方法，输出结果
  23.         helloWorld.sayHello();
  24.         
  25.         //输出日志
  26.         logger.info("### 手动输入日志~");
  27.         
  28.     }
  29.  
  30. }

测试结果

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/720414
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号