spring使用内置jetty创建提供http接口服务

最新推荐文章于 2025-07-23 13:57:24 发布
原创 最新推荐文章于 2025-07-23 13:57:24 发布 · 1.5k 阅读 · 30 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#spring #jetty #http

1、添加pom文件依赖

<dependency>
	<groupId>org.eclipse.jetty</groupId>
	<artifactId>jetty-server</artifactId>
	<version>9.4.22.v20191022</version>
</dependency>
<dependency>
	<groupId>org.eclipse.jetty</groupId>
	<artifactId>jetty-deploy</artifactId>
	<version>9.4.22.v20191022</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-web</artifactId>
	<version>5.2.9.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>5.2.9.RELEASE</version>
</dependency>

2、编写代码

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.XmlWebApplicationContext;

/**
 * Spring root context keeper
 */
@Component
public class ApplicationContextKeeper implements ApplicationContextAware {

    private static WebApplicationContext webAppCtx;

    @Override
    public void setApplicationContext(ApplicationContext appCtx)
            throws BeansException {
        XmlWebApplicationContext xmlWebAppCtx = new XmlWebApplicationContext();
        xmlWebAppCtx.setParent(appCtx);
        xmlWebAppCtx.setConfigLocation("");
        xmlWebAppCtx.setClassLoader(appCtx.getClassLoader());
        xmlWebAppCtx.refresh();
        xmlWebAppCtx.registerShutdownHook();
        webAppCtx = xmlWebAppCtx;
    }

    public static WebApplicationContext getWebAppCtx() {
        return webAppCtx;
    }

}

import org.eclipse.jetty.server.Server;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

/**
 * 服务生命周期辅助程序, 用于:
 * 1. 优雅关闭API服务, 加入JVM钩子, 保护数据.
 * 2. 可用于缓存持久化至数据库, 文件等操作
 */
public final class Bootstrap implements Lifecycle, InitializingBean, ApplicationListener<ContextRefreshedEvent> {
    private static final Logger LOG = LoggerFactory.getLogger(Bootstrap.class);

    private Server jettyServer;

    @Value("${rest.status}")
    private int status;

    @Value("${server.port}")
    private int port;

    /**
     * The set of registered LifecycleListeners for event notifications.
     */
    private LifecycleListener[] listeners = new LifecycleListener[0];

    private final Object listenersLock = new Object(); // Lock object for changes to listeners

    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        synchronized (listenersLock) {
            LifecycleListener[] results = new LifecycleListener[listeners.length + 1];
            System.arraycopy(listeners, 0, results, 0, listeners.length);
            results[listeners.length] = listener;
            listeners = results;
        }
    }

    @Override
    public void removeLifecycleListener(LifecycleListener listener) {
        synchronized (listenersLock) {
            int n = -1;
            for (int i = 0; i < listeners.length; i++) {
                if (listeners[i] == listener) {
                    n = i;
                    break;
                }
            }
            if (n < 0) {
                return;
            }
            LifecycleListener[] results = new LifecycleListener[listeners.length - 1];
            int j = 0;
            for (int i = 0; i < listeners.length; i++) {
                if (i != n) {
                    results[j++] = listeners[i];
                }
            }
            listeners = results;
        }
    }

    /**
     * @return true: no error, false: has error
     */
    private boolean doStop() {
        try {
            jettyServer.stop(); // 1. Gracefully shutdown

            // 2
            for (LifecycleListener listener : listeners) {
                listener.lifecycleEvent(new LifecycleEvent(this, Lifecycle.AFTER_STOP_EVENT));
            }
            return true;
        } catch (Exception e) {
            LOG.error("Shutdown jetty server error: ", e);
        }
        return false;
    }

    @Override
    public void afterPropertiesSet() {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            if (doStop()) {
                LOG.info("Shutdown completed");
            } else {
                LOG.warn("Shutdown completed with error, please check logs !!!");
            }
        }));
        LOG.info("Added JVM shutdown hook ...");
    }

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) { // Notify when ROOT CONTEXT loaded
            try {
                /*
                 * Start Jetty container after all bean have been initialize.
                 *
                 * 1.In case of load big data from DB slowly but the WEB PORT
                 *   have been open, some request maybe send to here but
                 *   application can't process them.
                 *
                 * 2. Jetty will parse web.xml, DispatcherServlet need WebApplicationContext to make
                 *    handlerMapping (URL -> process bean), so if the Spring Container haven't load
                 *    controllers specified on "springmvc-context.xml" and Jetty parse web.xml,
                 *    springmvc maybe not found the beans, finally will throw 404 error to client.
                 */
                if (status == 1) {
                    jettyServer.start();
                    System.out.println("Start http server on port:" + port);
                }
            } catch (Exception e) {
                LOG.error("Start jetty server error: ", e);
                System.exit(1);
                throw new RuntimeException(e);
            }
        }
    }

    public void setJettyServer(Server jettyServer) {
        this.jettyServer = jettyServer;
    }

}

import org.springframework.web.servlet.DispatcherServlet;
public class CustomDispatcherServlet extends DispatcherServlet {

    private static final long serialVersionUID = 1L;

    public CustomDispatcherServlet() {
        super(ApplicationContextKeeper.getWebAppCtx());
    }

}

public interface Lifecycle {

    String BEFORE_START_EVENT = "before_start";
    String AFTER_START_EVENT = "after_start";

    String BEFORE_STOP_EVENT = "before_stop"; // Before jetty gracefully shutdown
    String AFTER_STOP_EVENT = "after_stop"; // After jetty gracefully shutdown

    void addLifecycleListener(LifecycleListener listener);

    void removeLifecycleListener(LifecycleListener listener);

}


import java.util.EventObject;

public class LifecycleEvent extends EventObject {
    private static final long serialVersionUID = 1L;

    /**
     * The event type this instance represents.
     */
    private final String type;

    public LifecycleEvent(Object source, String type) {
        super(source);
        this.type = type;
    }

    public String getType() {
        return type;
    }

}


/**
 * Interface defining a listener for significant events (including "server
 * start" and "server stop")
 */
public interface LifecycleListener {

    /**
     * Acknowledge the occurrence of the specified event.
     *
     * @param event LifecycleEvent that has occurred
     */
    void lifecycleEvent(LifecycleEvent event);

}

3、配置bean

<bean id="bootstrap" class="com.xuanwu.msggate.mto.mos.server.Bootstrap">
	<property name="jettyServer" ref="jettyServer" />
</bean>

4、配置mvc注解驱动

<mvc:annotation-driven />

通过mvc:annotation-driven/配置，Spring MVC会启用对注解的支持，使得可以在控制器类和方法上使用注解来定义请求映射、参数绑定等操作。

具体来说，mvc:annotation-driven/会启用以下功能：
支持@Controller注解，用于标识控制器类
支持@RequestMapping注解，用于定义请求映射
支持@RequestParam注解，用于绑定请求参数
支持@ResponseBody注解，用于将方法返回值直接作为HTTP响应体返回
支持@PathVariable注解，用于绑定URI模板变量

注意： 如果没有mvc注解支持。则会出现No mapping for POST

5、添加jetty配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context-4.3.xsd">

	<bean id="contextHandlerCollection" class="org.eclipse.jetty.server.handler.ContextHandlerCollection"></bean>
	
	<bean id="jettyServer" class="org.eclipse.jetty.server.Server" destroy-method="stop">
		<constructor-arg name="pool">
			<bean class="org.eclipse.jetty.util.thread.QueuedThreadPool">
				<constructor-arg name="minThreads" value="${rest.api.jetty.poolSize.minThreads}" />
				<constructor-arg name="maxThreads" value="${rest.api.jetty.poolSize.maxThreads}" />
			</bean>
		</constructor-arg>
		<property name="stopAtShutdown" value="true" />
		<property name="stopTimeout" value="3000" />
		<property name="connectors">
			<array>
				<bean class="org.eclipse.jetty.server.ServerConnector">
					<constructor-arg name="server" ref="jettyServer" />
					<property name="port" value="${server.port}" />
					<property name="acceptQueueSize" value="1024" />
				</bean>
			</array>
		</property>
		<property name="handler">
			<bean class="org.eclipse.jetty.server.handler.HandlerCollection">
				<property name="handlers">
					<list>
						<ref bean="contextHandlerCollection" />
					</list>
				</property>
			</bean>
		</property>
		<property name="beans">
			<list>
				<ref bean="deploymentManager" />
			</list>
		</property>
	</bean>
	
	<bean id="deploymentManager" class="org.eclipse.jetty.deploy.DeploymentManager">
		<property name="contexts" ref="contextHandlerCollection" />
		<property name="appProviders">
			<list>
				<ref bean="webAppProvider" />
			</list>
		</property>
	</bean>
	
	<bean id="webAppProvider" class="org.eclipse.jetty.deploy.providers.WebAppProvider">
		<property name="monitoredDirName" value="${webapps.dir}webapps" />
		<property name="scanInterval" value="5" />
		<property name="extractWars" value="true" />
		<property name="configurationManager">
			<bean class="org.eclipse.jetty.deploy.PropertiesConfigurationManager" />
		</property>
	</bean>
	
</beans>

6、在spring中导入

<import resource="classpath:/com/xuanwu/msggate/mto/mos/jetty-context.xml"/>

7、创建webapps目录并创建web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
	<display-name>rest api</display-name>
	
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>com.xuanwu.msggate.rest2mtreceiver.server.CustomDispatcherServlet</servlet-class>
		<init-param>
			<param-name>detectAllHandlerAdapters</param-name>
			<param-value>true</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>

	<!-- Spring字符集过滤器      建议放前面 不然拦截可能有问题-->
	<filter>
		<filter-name>SpringEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>SpringEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<filter>
		<filter-name>HttpRequestFilter</filter-name>
		<filter-class>com.xuanwu.msggate.rest2mtreceiver.rest.filter.HttpRequestFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>HttpRequestFilter</filter-name>
		<url-pattern>/api/authorization/*</url-pattern>
	</filter-mapping>

</web-app>

在这里插入图片描述

huan1213858
关注
jetty 整合spring
10-19
jetty spring 整合，新手整合过程，以后继续完善达梦数据整合
开源的Java HTTP服务器 Jetty介绍
u013558123的博客
05-14 1215
Jetty作为一个轻量级的Web服务器和Servlet容器，在实际工作中具有广泛的应用。掌握Jetty的原理、特点和优势，能够帮助开发者更加高效地开发和部署Web应用程序。随着Java和Web技术的发展，Jetty将继续演变，提供更多的功能和特性，以满足不断变化的用户需求。我们应该鼓励学生和专业人士学习和掌握Jetty，以确保他们在未来的工作中能够应对各种Web开发和部署的挑战。
jetty搭建http服务器
Super_Ninja的专栏
09-30 5943
以前习惯于tomcat，相对而言，jetty也有很多优点，
Spring Boot中集成Jetty，其实也就那么回事儿
独泪了无痕
06-13 8441
前言 在我们使用 SpringBoot 开发Web应用时，会引入spring-boot-starter-web这个starter组件，其内嵌 Jetty , Tomcat , Undertow三种servlet 容器供大家选择，默认是Tomcat容器，所以我们平时新建项目启动起来，会看见Tomcat相关的一些信息，如下图所示，可以看出 Spring Boot 默认使用的是 Tomcat 容器启动的。 在日常工作中，Spring Boot 默认推荐的配置并一定适用于所有情况，根据项目配置以及环境，选择合适.
Java Web 学习笔记之十：通过Spring启动Jetty服务器
johnson_moon的博客
03-05 3929
本文给出一个Spring与Jetty整合开发web应用的简单例子。
内嵌Jetty集成SpringMVC提供HTTP服务
Coding Road
05-26 2577
项目中需要内嵌Jetty提供HTTP服务，并且需要基于SpringMVC实现MVC模式和Restful接口。实现方案如下所示。 需要的jar包 本方案需要的核心jar包如下（其他jar包自行补充）： jackson-annotations-2.9.5.jar jackson-core-2.9.5.jar jackson-databind-2.9.5.jar jetty-all-9.4.1...
Spring Boot 如何使用 Jetty 容器
it_xushixiong的博客
06-20 4544
在本文中，我们介绍了 Spring Boot 如何使用 Jetty 容器，包括如何添加 Jetty 依赖、如何配置 Jetty 容器、如何处理 HTTP 请求和响应等内容，并提供了相应的代码示例。使用 Jetty 作为 Spring Boot Web 容器，可以提高 Web 应用程序的性能和稳定性，同时也可以灵活地控制容器的行为。希望本文对您有所帮助。
Spring Boot集成Jetty、Tomcat或Undertow及支持HTTP/2协议
不懂的博客
02-27 1453
Spring Boot集成Jetty、Tomcat或Undertow及支持HTTP/2协议
spring boot内置容器性能比较(Jetty、Tomcat、Undertow)
菜鸟
09-12 7707
spring boot内置容器性能比较(Jetty、Tomcat、Undertow) 一、准备工作 1.1 服务器环境 名称 配置 服务器操作系统 Ubuntu 18.04.2 LTS 内存 15.4 GiB 处理器 Intel® Core™ i7-7560U CPU @ 2.40GHz × 4 磁盘 SSD 177.2 GB 1.2 创建服务 新建spring b...
深入分析javaweb技术内幕5---Jetty、Spring、Spring MVC
zzhao114的博客
02-11 1080
Jetty的工作原理解析 1.Jetty的基本架构 2.Jetty也是一个Servlet引擎，也可以基于AJP(定向包协议)工作，一般基于AJP 3.Jetty的基本的数据模型是Handler，所有被拓展的组件都可以被作为一个Handler添加到Server中，Jetty将帮你管理这些Handler 4.Container是管理Mbean(可管理的java资源)的容器。Jetty的
Jetty：配置概览-怎么配置Jetty
热门推荐
宁静致远
05-29 1万+
Jetty POJO配置 Jetty的核心组件是Plain Old Java Objects（POJOs）；配置Jetty的大部分工作就是在Jetty POJOs上的初始化、装配和设置域的处理，你能通过下面的方式来实现：  1）直接通过Java代码初始化和装配Jetty对象。这个在后面Embedding Jetty讲。  2）用Jetty XML配置（一个控制反转（IoC）框架）初始化和装配
Jetty启动
xieyuemin的专栏
04-12 1228
package Jetty; import org.eclipse.jetty.server.NetworkTrafficServerConnector; import org.eclipse.jetty.server.Server; import org.eclipse.jetty.webapp.WebAppContext; //import org.eclipse.jetty.server
jetty与springmvc的使用（一）
Java_Fly1的博客
01-02 1331
jetty与springmvc的使用jar包项目结构图web.xml中配置springmvcspringmvc的配置文件controller编写创建视图访问路径 jar包 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:s...
Jetty 启动spring项目
Lili429的博客
08-27 7144
一、简介   传统的Web开发大部分是开发好web程序，通过打成war等程序包发布到web容器中部署。Jetty其实也可以像tomcat那样作为容器，将程序打包放在其中进行启动，但是我们这里主要是为了简化开发的操作，直接嵌入jetty 启动项目。 二、开发环境  1、由于分布式的兴起，代码复用变得很重要，我这边会把Jetty启动项目的代码做一个module，最后打包成jar包，方
org.eclipse.jetty.server.Server 实践HttpServer
opencn8的专栏
02-19 7460
@Service public class HttpServer { @Value("${webapp.ip}") private String ip; @Value("${webapp.port}") private int port; @Value("${webapp.path}") private String path; private Server server;
SpringBoot深度整合Jetty实现百万级并发架构设计
java思维导图
02-27 1086
前后端微服务商城项目，手把手教学！一、Jetty架构设计精髓解析Jetty作为Eclipse基金会旗下的高性能HTTP服务器，其独特的架构设计使其在云原生时代大放异彩。理解其核心机制是性能调优的基础：1. 模块化组件架构![Jetty架构分层图] （图示：Connector组件->Handler组件->ThreadPool组件的三层架构）连接器(Connector)：采用Selecto...
SpringBoot Web容器配置之Jetty
Sbaby~的博客
11-25 955
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> ...
在eclipse中使用jetty服务器
GodPluto的博客
12-17 2043
一、maven插件 1.1 插件maven项目 1.1.1 创建项目 1.1.2 选择模板 1.2 修改pom 1.2.1 修改pom <build> <finalName>jetty-demo</finalName> <plugins> <plugin> <groupId>org.mortbay.jetty</groupId> <artifactId>jetty-maven-p
Spring Boot中Jetty的集成与应用
最新发布
weixin_35752233的博客
07-23 1339
Spring Boot旨在简化Spring应用的初始搭建以及开发过程。Jetty是一个开源的servlet容器，它为基于Java的Web内容（例如JSP和Servlet）提供运行环境。当我们将Spring Boot与Jetty结合时，可以快速开发出轻量级且具有高度可配置的Web应用程序。在本章中，我们学习了如何集成Spring Security来提升Spring Boot应用的安全性能。
Jetty开发指导：嵌入
宁静致远
07-23 7842
Jetty嵌入的HelloWorld 这节提供一个指导展示你怎么使用Jetty API快速开发嵌入的代码。 下载Jars Jetty被分解到多个jars和依赖，方便你选择自己需要的最小jar集合。通常使用Maven是最好的，然而这里使用了一个聚集的jar，包含了所有的Jetty类。你能手动的下载聚集的jetty-all jar和servlet api jar，通过使用wget或者类似的命令（
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值