详解Springboot工程中如何快速判断web应用服务器类型_Java

在 spring boot 工程中快速判断 web 应用服务器类型，可以从运行时环境、spring boot 特有 api、底层类加载器、http 响应和外部命令等多个层面入手。下面是几种常见方法的速览表：

方法	原理简述	代码复杂度	通用性	推荐度
注入 servletcontext	直接调用 `getserverinfo()` 获取服务器信息	★☆☆☆☆	极高 (适用于所有 servlet 容器)	⭐⭐⭐⭐⭐
检查特定类是否存在	通过 `class.forname()` 加载特定服务器的关键类	★★☆☆☆	高	⭐⭐⭐⭐
利用 spring boot 条件注解	使用 `@conditionalonclass` 注解声明 bean	★★☆☆☆	一般 (适用于 spring 环境)	⭐⭐⭐
监听容器初始化事件	在应用启动时监听 `servletwebserverinitializedevent` 事件	★★☆☆☆	一般 (适用于 spring boot)	⭐⭐⭐
查看启动日志	直接观察应用启动时的控制台日志输出	☆☆☆☆☆	极高	⭐⭐⭐⭐⭐
使用 actuator 端点	访问 `/actuator/env` 端点查看服务器相关配置	★★☆☆☆	一般	⭐⭐⭐
检查特定系统属性或 jmx	读取 `java.vm.vendor` 或查询 jmx mbean	★★★☆☆	中	⭐⭐
通过外部命令或端口号推断	使用 `netstat` 或 `ps` 命令在操作系统层面查询	★★★☆☆	低 (仅限手动排查)	⭐

方法一：通过 servletcontext 获取服务器信息（推荐）

这是最直接、最可靠的方式。你可以在任何 spring bean 中注入 servletcontext 对象，并调用 getserverinfo() 方法。该方法会返回一个字符串，其中包含了当前正在运行的 servlet 容器的名称和版本信息。

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import javax.servlet.servletcontext;
@service
public class serverinfoservice {
    @autowired
    private servletcontext servletcontext;
    public void printserverinfo() {
        string serverinfo = servletcontext.getserverinfo();
        system.out.println("服务器信息: " + serverinfo);
        // 对于 tomcat，输出可能是 "apache tomcat/9.0.83" 
        // 对于 jetty，输出可能是 "jetty/9.4.53.v20231009"
        // 对于 undertow，输出可能是 "undertow - 2.2.24.final"
    }
}

根据 getserverinfo() 返回的内容进行判断时，注意对版本号部分进行清理，避免因版本差异导致匹配失败。

方法二：检查特定类的存在性

通过 class.forname() 方法检测特定服务器的关键类是否存在于当前应用的 classpath 中，从而判断其类型。

import org.springframework.stereotype.component;
import javax.annotation.postconstruct;
@component
public class serverdetector {
    public enum servertype {
        tomcat, jetty, undertow, jboss, weblogic, websphere, unknown
    }
    private static servertype detectedserver;
    @postconstruct
    public void detect() {
        detectedserver = determineservertype();
        system.out.println("检测到服务器类型: " + detectedserver);
    }
    public static servertype determineservertype() {
        if (isclasspresent("org.apache.catalina.startup.tomcat")) return servertype.tomcat;
        if (isclasspresent("org.eclipse.jetty.server.server")) return servertype.jetty;
        if (isclasspresent("io.undertow.undertow")) return servertype.undertow;
        if (isclasspresent("org.jboss.main")) return servertype.jboss;
        if (isclasspresent("weblogic.server")) return servertype.weblogic;
        if (isclasspresent("com.ibm.websphere.product.versioninfo")) return servertype.websphere;
        return servertype.unknown;
    }
    private static boolean isclasspresent(string classname) {
        try {
            class.forname(classname);
            return true;
        } catch (classnotfoundexception e) {
            return false;
        }
    }
}

方法三：利用 spring boot 的条件注解

这种方式适合用于控制某些特定服务器下 bean 的加载，是一种声明式的判断方法。

import org.springframework.boot.autoconfigure.condition.conditionalonclass;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
@configuration
public class serverspecificconfig {
    @bean
    @conditionalonclass(name = "org.apache.catalina.startup.tomcat")
    public string tomcatonlybean() {
        return "仅当应用运行在 tomcat 服务器上时，此 bean 才会被创建";
    }
}

这个例子也可以作为快速判断的依据，当你看到 tomcatonlybean 在应用上下文中被创建，就可以认为当前运行的是 tomcat 容器。

方法四：监听容器初始化事件

通过实现 applicationlistener<servletwebserverinitializedevent> 接口，可以在 servlet 容器完成初始化后获取 webserver 实例，从而获取服务器的具体实现类，反推出其类型。

import org.springframework.boot.web.context.webserverinitializedevent;
import org.springframework.context.applicationlistener;
import org.springframework.stereotype.component;
@component
public class webserverlistener implements applicationlistener<webserverinitializedevent> {
    @override
    public void onapplicationevent(webserverinitializedevent event) {
        // 获取 webserver 实例，其实现类通常是 tomcatwebserver、jettywebserver、undertowwebserver 等
        class<?> webserverclass = event.getwebserver().getclass();
        system.out.println("webserver 实现类: " + webserverclass.getname());
        // 可根据实现类名判断服务器类型
        if (webserverclass.getname().contains("tomcat")) {
            system.out.println("当前运行在 tomcat 服务器上");
        }
    }
}

补充说明

通用性与准确性：servletcontext.getserverinfo() 是标准 java servlet 规范的一部分，在所有支持 servlet 规范的容器中均可使用，且直接提供官方定义的服务器名称，是最可靠的方法。

为什么可能有“多种判断”：在某些特殊场景下（例如需要与不支持 servlet api 的老旧代码集成），可能需要采用其他方式。另外，getserverinfo() 返回的字符串版本号格式因服务器而异，有时需要自行解析。

方法选择建议：对绝大多数 spring boot 应用，最推荐 servletcontext.getserverinfo()。若无法获取 servletcontext，可使用“检查类是否存在”的方法作为替代。若要根据服务器类型选择性加载 bean，应优先使用 spring 的条件注解。

方法补充

该代码片段通过检查spring应用上下文中的bean定义来判断当前使用的是tomcat还是jetty容器。使用@postconstruct注解在初始化时执行检测逻辑，通过扫描bean名称是否包含embeddedtomcat或embeddedjetty来设置相应的布尔标志，并输出日志记录检测结果。这种动态识别方式适用于需要针对不同嵌入式容器做差异化处理的场景。

核心源码

    boolean istomcat;
    
    boolean isjetty;
    
    @autowired
    applicationcontext applicationcontext;
    
    @postconstruct
    private void init()
    {
        istomcat = stream.of(applicationcontext.getbeandefinitionnames()).anymatch(name -> stringutils.containsignorecase(name, "embeddedtomcat"));
        isjetty = stream.of(applicationcontext.getbeandefinitionnames()).anymatch(name -> stringutils.containsignorecase(name, "embeddedjetty"));
        log.info("#### istomcat: {}", istomcat);
        log.info("#### isjetty: {}", isjetty);
    }

典型应用

import java.io.file;
import java.io.ioexception;
import java.util.stream.stream;

import javax.annotation.postconstruct;

import org.apache.commons.io.fileutils;
import org.apache.commons.lang3.randomutils;
import org.apache.commons.lang3.stringutils;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.applicationcontext;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.requestparam;
import org.springframework.web.bind.annotation.restcontroller;
import org.springframework.web.multipart.multipartfile;

import com.fly.demo.common.jsonresult;

import io.swagger.annotations.api;
import io.swagger.annotations.apioperation;
import lombok.extern.slf4j.slf4j;

@slf4j
@api(tags = "文件上传(simple)")
@restcontroller
@requestmapping("/simple/file")
public class simplefilecontroller
{
    boolean istomcat;
    
    boolean isjetty;
    
    @autowired
    applicationcontext applicationcontext;
    
    @postconstruct
    private void init()
    {
        istomcat = stream.of(applicationcontext.getbeandefinitionnames()).anymatch(name -> stringutils.containsignorecase(name, "embeddedtomcat"));
        isjetty = stream.of(applicationcontext.getbeandefinitionnames()).anymatch(name -> stringutils.containsignorecase(name, "embeddedjetty"));
        log.info("#### istomcat: {}", istomcat);
        log.info("#### isjetty: {}", isjetty);
    }
    
    @apioperation("文件上传")
    @postmapping("/upload")
    public jsonresult<?> upload(@requestparam multipartfile file)
        throws ioexception
    {
        file rootdir = new file("upload");
        file dest;
        if (istomcat)
        {
            if (randomutils.nextboolean())
            {
                log.info("### transferto");
                dest = new file(rootdir.getcanonicalpath() + file.separator + file.getoriginalfilename());
                file.transferto(dest);
            }
            else
            {
                log.info("### copyinputstreamtofile");
                dest = new file(rootdir, file.getoriginalfilename());
                fileutils.copyinputstreamtofile(file.getinputstream(), dest);
            }
        }
        else
        {
            log.info("### copyinputstreamtofile");
            dest = new file(rootdir, file.getoriginalfilename());
            fileutils.copyinputstreamtofile(file.getinputstream(), dest);
        } 
        return jsonresult.success(dest.getname());
    }
}

到此这篇关于详解springboot工程中如何快速判断web应用服务器类型的文章就介绍到这了,更多相关springboot判断web应用服务器类型内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！