当前位置:   article > 正文

Spring6-基础概念_spring 6

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. <!-- 引入JUnit5测试框架,用于编写和运行单元测试 -->
  10. <dependency>
  11. <groupId>org.junit.jupiter</groupId>
  12. <artifactId>junit-jupiter-api</artifactId>
  13. <version>5.3.1</version>
  14. </dependency>
  15. </dependencies>

刷新后并查看依赖

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

  1. 第3步 按照Spring要求创建配置文件(XML格式)
  • 在项目的资源目录下创建Spring的核心配置文件,如applicationContext.xmlspring-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. <!-- 定义一个Bean实例,id为"helloWorld",类型为com.sakurapaid.spring6_01.HelloWorld类 -->
  6. <bean id="helloWorld" class="com.sakurapaid.spring6_01.HelloWorld">
  7. </bean>
  8. </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. import org.junit.jupiter.api.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. public class HelloWorldTest {
  6. @Test
  7. public void test() {
  8. //加载spring配置文件,对象创建
  9. ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
  10. //获取创建对象
  11. HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
  12. //调用方法,输出结果
  13. helloWorld.sayHello();
  14. }
  15. }

  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. <appenders>
  21. <!--输出日志信息到控制台-->
  22. <console name="spring6log" target="SYSTEM_OUT">
  23. <!--控制日志输出的格式-->
  24. <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
  25. </console>
  26. <!--文件会打印出所有信息,这个log每次运行程序会自动清空,由append属性决定,适合临时测试用-->
  27. <File name="log" fileName="F:/Program/Spring6Log/test.log" append="false">
  28. <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
  29. </File>
  30. <!-- 这个会打印出所有的信息,
  31. 每次大小超过size
  32. 则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩,
  33. 作为存档-->
  34. <RollingFile name="RollingFile" fileName="F:/Program/Spring6Log/app.log"
  35. filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
  36. <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
  37. <SizeBasedTriggeringPolicy size="50MB"/>
  38. <!-- DefaultRolloverStrategy属性如不设置,
  39. 则默认为最多同一文件夹下7个文件,这里设置了20 -->
  40. <DefaultRolloverStrategy max="20"/>
  41. </RollingFile>
  42. </appenders>
  43. </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. import org.junit.jupiter.api.Test;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class HelloWorldTest {
  8. @Test
  9. public void test() {
  10. //获取日志对象
  11. Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);
  12. //加载spring配置文件,对象创建
  13. ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
  14. //获取创建对象
  15. HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
  16. //调用方法,输出结果
  17. helloWorld.sayHello();
  18. //输出日志
  19. logger.info("### 手动输入日志~");
  20. }
  21. }

测试结果

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

闽ICP备14008679号