第2章 Spring框架介绍 -- Spring4.3.8参考文档中文版

最新推荐文章于 2024-04-24 19:52:50 发布

DN-CS BISHA

最新推荐文章于 2024-04-24 19:52:50 发布

阅读量1.3k

点赞数

分类专栏： Spring参考文档4.3.8 文章标签： spring spring framework 框架文档

Spring参考文档4.3.8 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

2 Spring框架介绍

@sunRainAmazing

Spring Framework是一个Java平台，为开发Java应用程序提供全面的基础设施支持。
Spring处理基础设施，以便您可以专注于您的应用程序。
Spring使您能够从”简单的Java对象”（POJO）构建应用程序，并将企业服务非侵入式应用于POJO。
此功能适用于Java SE编程模型以及完整和部分Java EE。
作为应用程序开发人员，您可以从Spring平台中获益如何：

使Java方法在数据库事务中执行，而不必处理事务API。
使本地Java方法成为HTTP端点，而无需处理Servlet API。
使本地Java方法成为消息处理程序，而无需处理JMS API。
使本地Java方法成为管理操作，而无需处理JMX API。

2.1依赖注入和控制反转

Java应用程序 - 从受限嵌入式应用程序到n层服务器端企业应用程序
运行范围的宽松术语通常由协作形成应用程序的对象组成。
因此，应用程序中的对象彼此有依赖关系。
虽然Java平台提供了丰富的应用程序开发功能，但它缺乏将基本构建块组织成一个连贯的整体的方法，将该任务留给架构师和开发人员。
虽然您可以使用Factory，Abstract Factory，Builder，Decorator和Service Locator等设计模式来构成应用程序的各种类和对象实例，
但这些模式只是简单的说明：给出名称的最佳实践，以及什么样的模式，应用于哪里，它解决的问题等等。
模式是您必须在应用程序中实现自己的正式的最佳实践。
Spring框架反转控制（IoC）组件通过提供将不同组件组成完整工作应用程序的正式方法来解决这一问题。
Spring Framework将形式化的设计模式作为可以集成到您自己的应用程序中的第一类对象进行编译。
许多组织和机构以这种方式使用Spring框架来设计强大的，可维护的应用程序。

背景
” 问题是，他们在什么方面的反转？ “Martin Fowler 在2004年在他的网站上提出了关于控制反转（IoC）的这个问题 .Fowler建议重新命名这个原则，使其更加自明，并提出依赖注入。

2.2框架模块

Spring框架由组织成约20个模块的功能组成。
这些模块分为Core Container，Data Access / Integration，Web，AOP（面向对象编程），Instrumentation，Messaging和Test，如下图所示。

图2.1 Spring框架概述
这里写图片描述

以下部分列出了每个功能的可用模块及其工件名称及其涵盖的主题。
人工制品名称( Artifact names)与依赖关系管理工具中使用的工件ID(artifact IDs)相关。

2.2.1核心集装箱

所述核心容器由以下部分组成spring-core， spring-beans，spring-context，spring-context-support，和spring-expression （spring表达式语言）模块。
spring-core和spring-beans模块提供框架的基本零件，包括IOC和依赖注入特征。
它消除了对编程单例的需要，并允许您将依赖关系的配置和规范与实际程序逻辑分离。
所述Context（spring-context）模块建立由设置在固体基体上 Core and Beans模块：
它是访问一个框架式的方式是类似于一个JNDI注册表对象的装置。
上下文模块从Beans模块继承其功能，并增加了对国际化的支持（例如使用资源束），事件传播，资源加载以及例如Servlet容器透明创建上下文。
Context模块还支持Java EE功能，如EJB，JMX和基本远程处理。
该ApplicationContext接口是语境模块的焦点。
spring-context-support支持将常见的第三方库集成到用于缓存的Spring应用程序环境（EhCache，Guava，JCache），邮件（JavaMail），调度（CommonJ，Quartz）和模板引擎（FreeMarker，JasperReports，Velocity）中。

该spring-expression模块提供了强大的表达式语言，用于在运行时查询和操作对象图。
它是JSP 2.1规范中规定的统一表达语言（统一EL）的扩展。
该语言支持设置和获取属性值，属性分配，方法调用，访问数组，集合和索引器的内容，逻辑和算术运算符，命名变量以及从Spring的IoC容器中以名称检索对象。
它还支持列表投影和选择以及常见列表聚合。

2.2.2 AOP和仪器

该spring-aop模块提供了一个符合AOP联盟标准的面向方面的编程实现，允许您定义方法拦截器和切入点，以清理分离实现应分离的功能的代码。
使用源级元数据功能，您还可以以类似于.NET属性的方式将行为信息合并到代码中。
单独的spring-aspects模块提供与AspectJ的集成。
该spring-instrument模块提供了在某些应用服务器中使用的类仪器支持和类加载器实现。
该spring-instrument-tomcat 模块包含Spring的Tomcat测试代理。

2.2.3消息传递

Spring框架4包括spring-messaging从关键抽象模块 Spring集成项目，例如Message，MessageChannel，MessageHandler，和其他人作为基于消息的应用奠定了基础。
该模块还包括一组用于将消息映射到方法的注释，类似于基于Spring MVC注释的编程模型。

2.2.4数据访问/集成

所述数据访问/集成层由JDBC，ORM，OXM，JMS和交易模块。

该spring-jdbc模块提供了一个JDBC抽象层，可以省去冗长的JDBC编码和解析数据库供应商特定错误代码的需要。

该spring-tx模块支持用于实现特殊接口和所有POJO（普通Java对象）的类的编程和声明式事务管理。

该spring-orm模块为流行的对象关系映射 API 提供集成层，包括JPA， JDO和Hibernate。
使用该spring-orm模块，您可以将所有这些O / R映射框架与Spring提供的所有其他功能结合使用，例如前面提到的简单的声明式事务管理功能。

该spring-oxm模块提供了一个支持Object / XML映射实现（如JAXB，Castor，XMLBeans，JiBX和XStream）的抽象层。

该spring-jms模块（Java消息服务）包含用于生成和消费消息的功能。自Spring Framework 4.1以来，它提供了与spring-messaging模块的集成。

2.2.5 Web

所述网络层由的spring-web，spring-webmvc，spring-websocket，和 spring-webmvc-portlet模块。

该spring-web模块提供基本的面向Web的集成功能，例如多部分文件上传功能，以及使用Servlet侦听器和面向Web的应用程序上下文初始化IoC容器。
它还包含一个HTTP客户端和Spring的远程支持的Web相关部分。
该spring-webmvc模块（也称为Web-Servlet模块）包含用于Web应用程序的Spring的模型视图控制器（MVC）和REST Web Services实现。
Spring的MVC框架提供了领域模型代码和Web表单之间的清晰分离，并与Spring Framework的所有其他功能集成。

该spring-webmvc-portlet模块（也称为Web-Portlet模块）提供了在Portlet环境中使用的MVC实现，并反映了基于Servlet的spring-webmvc模块的功能。

2.2.6测试

该spring-test模块支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。
它提供了Spring 的一致加载ApplicationContext和这些上下文的缓存。它还提供可用于孤立测试代码的模拟对象。

2.3使用场景

之前描述的构建块使Spring成为许多场景中的逻辑选择，从在资源受限设备上运行的嵌入式应用程序到使用Spring的事务管理功能和Web框架集成的全面的企业应用程序。

图2.2 典型的成熟的Spring Web应用程序
这里写图片描述

Spring的声明式事务管理功能使Web应用程序完全事务性，就像使用EJB容器管理的事务一样。
所有您的定制业务逻辑都可以使用简单的POJO实现，并由Spring的IoC容器进行管理。
附加服务包括支持发送电子邮件和独立于Web层的验证，可让您选择执行验证规则的位置。
Spring的ORM支持与JPA，Hibernate和JDO集成; 例如，当使用Hibernate时，您可以继续使用现有的映射文件和标准的Hibernate SessionFactory配置。
表单控制器将Web层与域模型无缝集成，消除了ActionForms将HTTP参数转换为域模型值的需求或其他类。

图2.3 Spring中间层使用第三方网络框架
这里写图片描述

有时情况不允许你完全切换到不同的框架。
Spring框架并没有强迫你在它使用的一切; 这不是一个完全没有任何解决方案。
使用Struts，Tapestry，JSF或其他UI框架构建的现有前端可以与基于Spring的中间层集成，从而允许您使用Spring事务功能。
您只需使用一个连接您的业务逻辑，ApplicationContext并使用它WebApplicationContext来集成您的Web层。

图2.4 远程使用场景
这里写图片描述

当你需要通过Web服务来访问现有的代码，你可以使用Spring的 Hessian-，Burlap-，Rmi-或JaxRpcProxyFactory类。
启用对现有应用程序的远程访问并不困难。

图2.5 EJBs - 包装现有的POJO
这里写图片描述

Spring Framework还为Enterprise JavaBeans 提供了一个访问和抽象层，使您能够重用现有的POJO，
并将其包装在无状态会话bean中，以便在可能需要声明式安全性的可扩展的，故障安全的Web应用程序中使用。

2.3.1依赖管理和命名约定

依赖关系管理和依赖注入是不同的。
为了将Spring的这些不错的功能引入到应用程序（如依赖注入）中，您需要组装所有需要的库（jar文件），
并在运行时，并可能在编译时将它们导入到类路径中。
这些依赖关系不是注入的虚拟组件，而是文件系统中的物理资源（通常为）。
依赖关系管理的过程包括定位这些资源，存储它们并将其添加到类路径中。
依赖关系可以是直接的（例如，我的应用程序依赖于Spring在运行时）或间接（例如我的应用程序取决于commons-dbcp哪个依赖于 commons-pool）。
间接依赖关系也被称为”传递性”，它们是最难识别和管理的依赖关系。

如果你要使用Spring，你需要获得一个包含你所需要的Spring块的jar库的副本。
为了使这更容易，Spring被打包为一组尽可能分离依赖关系的模块，例如，如果您不想编写Web应用程序，则不需要spring-web模块。
要参照本指南中，我们使用速记命名约定到Spring库模块spring-或 spring-.jar,其中*代表该模块的短名称（例如spring-core，spring-webmvc，spring-jms等）。
您使用的实际jar文件名通常是与版本号连接的模块名称（例如spring-core-4.3.8.RELEASE.jar）。
Spring Framework的每个版本都会将工件发布到以下位置：

Maven Central，它是Maven查询的默认存储库，不需要任何特殊配置。
Spring的许多常见的库也可以从Maven Central获得，
Spring社区的大部分使用Maven进行依赖关系管理，所以这对他们来说很方便。
这里的jar的名称是形式spring-*-.jar，Maven groupId是org.springframework。
在专门用于Spring的公共Maven存储库中。
除了最终的GA版本，该存储库还承载开发快照和里程碑。
jar文件名与Maven Central格式相同，因此这是一个有用的地方，可以将开发版本的Spring与在Maven Central中部署的其他库配合使用。
该存储库还包含捆绑分发zip文件，其中包含所有Spring jar，捆绑在一起以便于下载。

所以你需要决定的第一件事是如何管理你的依赖关系：
我们通常建议使用像Maven，Gradle或Ivy这样的自动化系统，但你也可以通过自己下载所有的jar来手动执行。

下面你将会看到Spring工件的列表。
有关每个模块的更完整的描述，请参见第2.2节”框架模块”。

表2.1 spring框架工件(部分)
这里写图片描述

spring依赖
虽然Spring为大量企业和其他外部工具提供集成和支持，但它有意将其强制性依赖性保持在最低限度：
您不必定位和下载（甚至自动）大量的jar库，以便使用Spring用于简单的用例。对于基本依赖注入，只有一个强制性的外部依赖关系，
也就是用于日志记录（有关日志记录选项的更详细描述，请参阅下文）。

接下来，我们概述了配置依赖于Spring的应用程序所需的基本步骤，首先是使用Maven，然后使用Gradle，最后使用Ivy。
在任何情况下，如果不清楚，请参阅依赖关系管理系统的文档，或查看一些示例代码 -
Spring本身在构建时使用Gradle来管理依赖关系，而且我们的示例主要使用Gradle或【Maven】。

Maven依赖管理
例如，要创建应用程序上下文并使用依赖注入来配置应用程序，您的Maven依赖项将如下所示：

<dependencies> 
  <dependency> 
        <groupId> org.springframework </ groupId> 
    <artifactId> spring-context </ artifactId> 
    <version> 4.3.8.RELEASE </ version> 
    <scope> runtime </ scope> 
  </ dependency>
 </dependencies>

注意，如果您不需要针对Spring API进行编译，那么范围可以被声明为运行时，通常情况下这是基本依赖注入用例的情况。
以上示例适用于Maven Central存储库。
要使用Spring Maven存储库（例如，用于里程碑或开发人员快照），您需要在Maven配置中指定存储库位置。完整版本：

<repository> 
   <repository> 
    <id> io.spring.repo.maven.release </ id> 
    <url> http://repo.spring.io/release/ </ url> 
    <snapshots> <enabled> false </enabled> </ snapshots> 
   </ repository>
 </ repositories>

对于里程碑(milestones)：

<repository> 
    <repository> 
    <id> io.spring.repo.maven.milestone </ id> 
    <url> http://repo.spring.io/milestone/ </ url> 
    <snapshots> <enabled> false </enabled> </ snapshots> 
     </ repository> 
</ repositories>

而对于快照(snapshots)：

<repository> 
    <repository> 
        <id> io.spring.repo.maven.snapshot </id> 
        <url> http://repo.spring.io/snapshot/ </url> 
        <snapshots> <enabled> true </enabled> </snapshots> 
    </repository>
 </repositories>

Maven”物料清单”依赖
使用Maven时，可能会意外混合不同版本的Spring JAR。
例如，您可能会发现第三方库或另一个Spring项目会将旧的版本的依赖关系传递给旧版本。如果您忘记自己明确声明直接依赖，可能会出现各种意外问题。
为了克服这些问题，Maven支持”物料单”（BOM）依赖的概念。
您可以导入spring-framework-bom您的dependencyManagement 部分，以确保所有spring依赖（直接和传递）都是相同的版本。

<dependencyManagement> 
    <dependencies> 
      <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-framework-bom </artifactId> 
        <version> 4.3.8.RELEASE </version> 
        <type> pom </type > 
        <scope> import </scope> 
      </dependency> 
    </dependencies> 
</dependencyManagement>

使用BOM的一个额外的好处是，您不再需要根据Spring Framework工件指定属性：

<dependencies> 
    <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-context </artifactId> 
    </ dependency> 
    <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-web </artifactId> 
    </dependency> 
</dependencies>

渐进依赖管理
要使用具有Gradle构建系统的Spring存储库，请在该repositories部分中包含相应的URL ：

repositories{
    mavenCentral（）
    //和可选的... 
        maven {url "http://repo.spring.io/release" }
}

您可以更改repositories从URL /release到/milestone或/snapshot适当。一旦存储库被配置，你可以通常使用Gradle方式来声明依赖：

repositories{
    compile（"org.springframework：spring-context：4.3.8.RELEASE"）
    testCompile（"org.springframework：spring-test：4.3.8.RELEASE"）
}
Ivy Dependency Management

如果您喜欢使用Ivy来管理依赖关系，那么还有类似的配置选项。
要配置Ivy以指向Spring存储库，请将以下解析器添加到 ivysettings.xml：

<resolvers> 
   <ibiblio name = "io.spring.repo.maven.release" m2compatible = "true" 
       root = "http://repo.spring.io/release/" /> 
 </resolvers>

您可以更改root从URL /release/到/milestone/或/snapshot/适当。
配置完成后，您可以按通常的方式添加依赖项。例如（in ivy.xml）：

<dependency  org = "org.springframework" 
    name = "spring-core"  rev = "4.3.8.RELEASE"  conf = "compile-> runtime" />

分发Zip文件
虽然使用支持依赖关系管理的构建系统是推荐的获取Spring框架的方法，但仍然可以下载分发zip文件。
分发拉链已发布到Spring Maven存储库（这仅仅是为了我们的方便，您不需要Maven或任何其他构建系统才能下载它们）。
要下载分发zip打开Web浏览器到 http://repo.spring.io/release/org/springframework/spring，并为所需的版本选择适当的子文件夹。
分发文件结束-dist.zip，例如spring-framework- {spring-version} -RELEASE-dist.zip。
发行版还会发布里程碑和快照。

2.3.2记录

日志记录是Spring非常重要的依赖，因为a）它是唯一的强制性外部依赖关系，b）每个人都喜欢看到他们使用的工具的一些输出，以及c） Spring集成了许多其他工具，选择日志依赖关系。
应用程序开发人员的目标之一通常是将统一的日志记录配置在整个应用程序的中央位置，包括所有外部组件。
这比以前有更多的困难，因为有这么多的日志框架选择。

Spring中的强制性日志依赖关系是Jakarta Commons Logging API（JCL）。
我们针对JCL进行编译，我们也使JCL Log对象对于扩展Spring Framework的类可见。
对于用户来说，所有版本的Spring都使用相同的日志库很重要：迁移很简单，因为即使扩展Spring的应用程序仍然保留向后兼容性。
我们这样做的方法是使Spring中的一个模块明确地依赖于commons-logging（JCL的规范实现），然后在编译时使所有其他模块依赖于它。
例如，如果您使用Maven，并且想知道您在哪里选择依赖关系commons-logging，那么它来自Spring，特别是来自中央模块spring-core。
好在的是commons-logging不需要任何其他东西来使你的应用程序工作。
它具有运行时发现算法，可以在类路径中的众所周知的地方查找其他日志记录框架，并使用它认为合适的记录框架（或者您可以告诉它需要哪一个）。
如果没有其他可用的，您可以从JDK（简称java.util.logging或JUL）获得非常漂亮的日志。
您应该发现，在大多数情况下，您的Spring应用程序可以快乐地登录到控制台，这很重要。
使用Log4j 1.2或2.x
Log4j 1.2在此期间是EOL。此外，
【–Log4j 2.3是最新的Java 6兼容版本，较新的Log4j 2.x版本需要Java 7+版本–】。

许多人使用Log4j作为配置和管理目的的日志框架。
它是高效和成熟的，实际上它是我们在构建Spring时在运行时使用的。
Spring还提供了一些用于配置和初始化Log4j的实用程序，因此它在某些模块中对Log4j具有可选的编译时依赖性。

要使Log4j 1.2使用默认的JCL依赖项（commons-logging），您需要做的就是将Log4j放在类路径上，并为其提供配置文件（log4j.properties或log4j.xml在类路径的根目录中）。
所以对于Maven用户来说，这是你的依赖声明：

<dependencies> 
    <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-core </artifactId> 
        <version> 4.3.8.RELEASE </version> 
    </dependency> 
    <dependency> 
        <groupId> log4j </groupId> 
        <artifactId> log4j </artifactId> 
        <version> 1.2.17 </version> 
    </dependency> 
</dependencies>

以下是用于登录控制台的log4j.properties示例：

log4j.rootCategory = INFO，stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =％d {ABSOLUTE}％5p％t％c {2}：％L  - ％m％n
log4j.category.org.springframework.beans.factory = DEBUG

要使用Log4j 2.X与JCL，所有你需要做的就是把Log4j的在类路径，并为其提供一个配置文件
（log4j2.xml，log4j2.properties或其他支持的配置格式）。对于Maven用户，所需的最小依赖关系是：

<dependencies> 
    <dependency> 
        <groupId> org.apache.logging.log4j </groupId> 
        <artifactId> log4j-core </artifactId> 
        <version> 2.6.2 </version> 
    </ dependency> 
    <dependency> 
        <groupId> org.apache.logging.log4j </groupId> 
        <artifactId> log4j-jcl </artifactId> 
        <version> 2.6.2 </version> 
    </dependency> 
</dependencies>

如果您还希望启用SLF4J委托Log4j，例如默认使用SLF4J的其他库，则还需要以下依赖关系：

<dependencies> 
    <dependency> 
        <groupId> org.apache.logging.log4j </groupId> 
        <artifactId> log4j-slf4j-impl </artifactId> 
        <version> 2.6.2 </version> 
    </dependency> 
</dependencies>

以下是log4j2.xml登录控制台的示例：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
    <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Logger name="org.springframework.beans.factory" level="DEBUG"/>
    <Root level="error">
    <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

避免使用Commons Logging
不幸的是，标准commons-loggingAPI中的运行时发现算法对于最终用户来说方便，可能是有问题的。
如果你想避免JCL的标准查找，基本上有两种方法来关闭它：
从spring-core模块中排除依赖关系（因为它是唯一明确依赖的模块commons-logging）

取决于一个特殊的commons-logging依赖关系，用空的jar代替库（更多的细节可以在SLF4J FAQ中找到）

要排除公共记录，请将以下内容添加到您的dependencyManagement部分：

<dependencies> 
    <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-core </artifactId> 
        <version> 4.3.8.RELEASE </version> 
        <exclusions> 
          <exclude> 
                <groupId> commons-logging </groupId> 
                <artifactId> commons-logging </artifactId> 
          </exclude> 
        </exclusions> 
    </dependency> 
</dependencies>

现在这个应用程序目前被破坏，因为在类路径中没有实现JCL API，所以要修复它，必须提供一个新的JCL API。
在下一节中，我们向您展示如何使用SLF4J提供JCL的替代实现。
使用SLF4J与Log4j或Logback
Java简单日志门面（SLF4J）是Spring常用的其他库使用的流行API。
它通常用于 Logback，它是SLF4J API的本地实现。

SLF4J提供了绑定到许多常见的日志记录框架，包括Log4j，并且它也是相反的：其他日志记录框架和本身之间的桥梁。
所以要使用SLF4J与Spring，您需要commons-logging用SLF4J-JCL桥替换依赖关系。
一旦完成，那么在Spring中记录调用将被转换为对SLF4J API的记录调用，因此如果应用程序中的其他库使用该API，那么您有一个地方来配置和管理日志记录。

常见的选择可能是将Spring链接到SLF4J，然后提供从SLF4J到Log4j的显式绑定。
您需要提供几个依赖关系（并排除现有的 commons-logging）：JCL桥接器，SLF4j绑定到Log4j以及Log4j提供程序本身。
在Maven你会这样做

<dependencies> 
    <dependency> 
        <groupId> org.springframework </groupId> 
        <artifactId> spring-core </artifactId> 
        <version> 4.3.8.RELEASE </version> 
        <exclusions> 
           <exclude> 
                <groupId> commons-logging </groupId> 
                <artifactId> commons-logging </artifactId> 
           </exclude > 
        </exclusions> 
    </dependency> 
    <dependency> 
        <groupId> org.slf4j </groupId> 
        <artifactId> jcl-over-slf4j </artifactId > 
        <version> 1.7.21 </version> 
    </dependency> 
    <dependency> 
        <groupId> org.slf4j </groupId> 
        <artifactId> SLF4J-log4j12 </artifactId> 
        <version> 1.7.21 </version> 
    </dependency> 
    <dependency> 
        <groupId> log4j </groupId> 
        <artifactId> log4j </artifactId> 
        <version> 1.2.17 </version> 
    </dependency> 
</dependencies>

使用较少步骤并生成较少依赖关系的SLF4J用户中更为常见的选择是直接绑定到Logback。
这消除多余的绑定步骤，因为直接的logback实现SLF4J，所以你只需要仅仅依靠两个库，即jcl-over-slf4j和logback）：

<dependencies> 
    <dependency> 
        <groupId> org.slf4j </groupId> 
        <artifactId> jcl-over-slf4j </artifactId> 
        <version> 1.7.21 </version> 
    </dependency> 
    <dependency> 
        <groupId> ch.qos.logback </groupId> 
        <artifactId> logback-classic </artifactId> 
        <version> 1.1.7 </version> 
    </dependency>
 </dependencies>

使用JUL（java.util.logging）
Commons Logging将java.util.logging默认委派，只要在类路径中没有检测到Log4j。
所以没有什么特别的依赖关系：只要java.util.logging在独立的应用程序（在JDK级别使用自定义或默认的JUL设置）
或应用程序服务器的日志系统（和它的系统级JUL设置）。
Commons登录WebSphere
Spring应用程序可以在本身提供JCL实现的容器上运行，例如IBM的WebSphere Application Server（WAS）。
这并不会导致问题本身，而是导致需要了解的两种不同的场景：
在”父级第一”ClassLoader授权模型（WAS中的默认值）中，应用程序将始终选择Commons Logging提供的服务器版本，委托给WAS记录子系统（实际上基于JUL）。
JCL的应用程序提供的变体，无论是标准的Commons Logging还是JCL-over-SLF4J桥，都将被有效地被忽略，以及任何本地包含的日志提供程序。
使用”父进程”委托模式（常规Servlet容器中的默认值，WAS上的显式配置选项），将提取应用程序提供的Commons Logging变体，
使您能够设置本地包含的日志提供程序，例如Log4j或Logback，在您的应用程序。
在没有本地日志提供程序的情况下，默认情况下，常规Commons Logging将委托给JUL，有效地记录到WebSphere的日志记录子系统，如”父第一”方案。

总而言之，我们建议将”Spring”应用程序部署在”父进程”模式中，因为它自然地允许本地提供程序以及服务器的日志子系统。

DN-CS BISHA

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第2章 Spring框架介绍 -- Spring4.3.8参考文档中文版

2 Spring框架介绍 @sunRainAmazingSpring Framework是一个Java平台，为开发Java应用程序提供全面的基础设施支持。 Spring处理基础设施，以便您可以专注于您的应用程序。 Spring使您能够从”简单的Java对象”（POJO）构建应用程序，并将企业服务非侵入式应用于POJO。此功能适用于Java SE编程模型以及完整和部分Java EE。
复制链接

扫一扫