精华内容
下载资源
问答
  • 内嵌服务器
    2021-08-05 05:56:14

    为了完成web工程的测试,最近内嵌jetty也要搞起来.第一次搞还是挺焦头烂额的.直接上成果:

    package com.test.action;

    import java.io.File;

    import org.eclipse.jetty.server.Connector;

    import org.eclipse.jetty.server.Server;

    import org.eclipse.jetty.server.nio.SelectChannelConnector;

    import org.eclipse.jetty.util.thread.QueuedThreadPool;

    import org.eclipse.jetty.webapp.WebAppContext;

    public class RunTest {

    public static void main(String[] args) {

    tt();

    }

    public static void tt() {

    Server server = new Server();// 创建jetty web容器

    server.setStopAtShutdown(true);// 在退出程序是关闭服务

    // 创建连接器,每个连接器都是由IP地址和端口号组成,连接到连接器的连接将会被jetty处理

    Connector connector = new SelectChannelConnector();// 创建一个连接器

    connector.setHost("127.0.0.1");// ip地址

    connector.setPort(8080);// 连接的端口号

    server.addConnector(connector);// 添加连接

    QueuedThreadPool threadPool = new QueuedThreadPool();

    threadPool.setMaxThreads(3000);

    server.setThreadPool(threadPool);

    // 配置服务

    WebAppContext context = new WebAppContext();// 创建服务上下文

    context.setContextPath("/strutsDemo");// 访问服务路径 http://{ip}:{port}/

    context.setConfigurationDiscovered(true);

    String baseDir = Thread.currentThread().getContextClassLoader()

    .getResource("").getPath();

    context.setDescriptor(baseDir + File.separator + "/WEB-INF/web.xml");// 指明服务描述文件,就是web.xml

    // context.setDescriptor("/E:/workspace/strutsDemo/target/classes/\\/WEB-INF/web.xml");//

    // 指明服务描述文件,就是web.xml

    context.setResourceBase(System.getProperty("user.dir")

    + "/src/main/webapp/");// 指定服务的资源根路径,配置文件的相对路径与服务根路径有关

    server.setHandler(context);// 添加处理try {

    server.start();// 开启服务

    server.join();

    } catch (Exception e) {

    e.printStackTrace();

    System.exit(1);

    }

    }

    }

    启动访问就可以了.主要是context的配置花了很多功夫,老是配不好.还有据说jetty版本或者jar包不同会有配置差异,我用的是8.0.4版本,顺便贴上maven依赖:

    org.eclipse.jetty.aggregate

    jetty-all

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-webapp

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-server

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-servlet

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-deploy

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-xml

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-security

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-client

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-ajp

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-annotations

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-websocket

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-util

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-io

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-http

    8.0.4.v20111024

    org.eclipse.jetty

    jetty-continuation

    8.0.4.v20111024

    org.mortbay.jetty

    jsp-2.1-glassfish

    2.1.v20100127

    事实上不需要这么多,我这是一劳永逸的偷懒做法,你们可以改进哟

    更多相关内容
  • Tomcat7内嵌服务器

    2019-04-21 01:36:20
    NULL 博文链接:https://liuguxing.iteye.com/blog/1928161
  • ... 概述 ...SpringBoot使用main方法启动的一个重要特性是,不需要打包成war部署到Tomcat这种Servlet容器中,而是只需打包成jar,然后通过java或mvn...SpringBoot学习(二):内嵌服务器引擎(Tomcat,Jetty)实现原理

     

    http://www.zijin.net/news/tech/1088822.html

    概述

    • SpringBoot使用main方法启动的一个重要特性是,不需要打包成war部署到Tomcat这种Servlet容器中,而是只需打包成jar,然后通过java或mvn等命令运行这个jar包,然后应用就可以在指定的端口监听客户端的连接请求了。
    • 在SpringBoot内部主要是引用了embedded的Tomcat或Jetty等作为Servlet引擎,由该Servlet引擎负责接收Web请求并交给应用处理和生成响应,从而可以将应用打包成jar,直接在命令行启动,以独立进程的方式运行,无需依赖Tomcat等Servlet容器,但是可以实现跟部署到Tomcat中的war包一样处理Web请求和响应。

    接口设计

    • 在接口设计层面,对Spring容器而言,是通过拓展ApplicationContext接口来增加Spring容器对Servlet引擎的支持;对Servlet引擎而言,则是定义了WebServer接口来代表Servlet引擎或者说是Web服务器,WebServer接口实现类为具体的Servlet引擎实现。
    • Spring容器通过包含WebServer的引用来负责Servlet引擎的启动关闭。同时与普通Servlet容器实现(如Tomcat)一样,将Spring应用通过关联一个ServletContext引用来建立与Servlet引擎的关联,同时将自身保存为ServletContext引用的attribute。
    • 应用自身在启动的时候,会创建和启动Spring容器,在Spring容器中通过该WebServer引用来启动对应的Servlet引擎。并在启动Servlet引擎过程中,创建该应用对应的ServletContext,由该ServletContext来间接建立当前应用与Servlet引擎的关联。

    Spring容器ApplicationContext体系

    • WebServerApplicationContext接口:定义获取WebServer引用的方法

     

     

    • ServletWebServerApplicationContext:WebServerApplicationContext接口的具体实现类,包含WebServer的引用,类定义如下:

     

     

    • 由继承体系可知,继承了GenericWebApplicationContext,在GenericWebApplicationContext中定义了ServletContext引用。
    • 由代码注释可知,Spring容器管理了一个ServletWebServerFactory引用,ServletWebServerFactory为WebServer实现类对象的工厂类,通过ServletWebServerFactory来创建servlet引擎WebServer,其中由ServletWebServerFactory创建的WebServer默认在8080端口监听请求,具体为在基类AbstractConfigurableWebServerFactory中定义。
    • 同时注册到Spring容器的Servlet,Filter接口的实现类会自动注册到Servlet引擎,具体为应用对应的ServletContext。
    • AnnotationConfigServletWebServerApplicationContext:基于注解的Spring容器,继承了ServletWebServerApplicationContext。
    • XmlServletWebServerApplicationContext:基于XML的Spring容器,继承了ServletWebServerApplicationContext。

    Servlet引擎体系

    • WebServer接口:声明Servlet引擎启动,关闭的方法,相应的实现类实现这些方法来定义启动和关闭逻辑,而对Spring容器ServletWebServerApplicationContext而言,只需依赖这个接口即可,不依赖具体实现,这也是遵循了依赖倒置设计原则。

     

     

    • ServletWebServerFactory接口:Servlet引擎WebServer的工厂接口,接口定义如下,声明了getWebServer方法。也是遵循依赖倒置设计原则,即Spring容器ServletWebServerApplicationContext只依赖这个接口,具体为这个接口的getWebServer方法来获取一个Servlet引擎WebServer对象,而该接口的具体实现类,负责实现这个接口。实现类包括:TomcatServletWebServerFactory,JettyServletWebServerFactory,UndertowServletWebServerFactory,具体在embedded包定义。

     

     

    Spring容器和Servlet引擎启动过程

    • Spring容器是在ApplicationContext的refresh方法定义启动流程的,具体为在AbstractApplicationContext中定义refresh方法的流程模板:关于Servlet引擎的启动,是在onRefresh和finishRefresh方法定义的,由onRefresh方法的注释可知,这个方法是设计用来注册有特殊功能的bean对象到Spring容器内部的BeanFactory的。所以Spring容器的设计拓展性是很好的。

     

     

    • ServletWebServerApplicationContext的refresh方法,onRefresh方法,finishRefresh方法。其中onRefresh方法负责Server引擎和ServletContext的创建;finishOnRefresh方法负责Servlet引擎的启动,即调用WebServer的start方法,然后在指定的端口,如8080,监听客户端的请求。

     

     

    • createWebServer方法实现:创建servlet引擎WebServer和ServletContext。

     

     

    • startWebServer方法实现:调用Servlet引擎的start方法完成启动。

     

     

    • 以下为TomcatWebServer的start方法实现:启动应用在Servlet规范中对应的Context,即TomcatEmbeddedContext

     

     

    欢迎投稿本站:紫金网 » SpringBoot学习(二):内嵌服务器引擎(Tomcat,Jetty)实现原理

    展开全文
  • Jetty内嵌服务器实例

    2014-03-20 11:41:40
    jetty服务器内嵌实例,运行JettTest后即可访问
  • 本文主要针对内嵌服务器的原理以及如何切换不同内嵌服务器进行介绍。 下面针对springBoot2.3.4版本进行简单的介绍。springBoot主要内嵌的服务器从官方文档可以看到: 由此可知,主要集成了jetty,netty,tomcat以及...

    SpringBoot 集成的服务器源码分析

    本文主要针对内嵌服务器的原理以及如何切换不同内嵌服务器进行介绍。
    下面针对springBoot2.3.4版本进行简单的介绍。springBoot主要内嵌的服务器从官方文档可以看到:
    在这里插入图片描述
    由此可知,主要集成了jetty(适合交互式消息),tomcat以及undertow(不支持JSP,并发性能较高)三种,spring-boot-starter-web默认使用的是tomcat服务器。我们在启动springboot的时候就会发现,不需要导入tomcat组件就可以直接运行,这就是内嵌服务器。这与传统的打war包不同,内嵌服务器直接将项目打包成jar包,使用 java -jar + jar包名 来直接部署,而打war包需将war包放入tomcat目录下的webapps,启动Tomcat才可以。

    如何修改这些内嵌服务器的配置

    查看ServerProperties.class类

    public class ServerProperties {
     private Integer port;
     private InetAddress address;
     @NestedConfigurationProperty
     private final ErrorProperties error = new ErrorProperties();
     private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
     private String serverHeader;
     private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
     private Shutdown shutdown;
     @NestedConfigurationProperty
     private Ssl ssl;
     @NestedConfigurationProperty
     private final Compression compression;
     @NestedConfigurationProperty
     private final Http2 http2;
     private final ServerProperties.Servlet servlet;
     private final ServerProperties.Tomcat tomcat;
     private final ServerProperties.Jetty jetty;
     private final ServerProperties.Netty netty;
     private final ServerProperties.Undertow undertow;
    

    这些配置都可在application.yml/application-{profiles}.yml/application.properties等配置文件下配置,例如:

    server:
      port: 8089
      #开启压缩
      compression:
        enable: true
        #压缩文件类型
        # 触发压缩的最小内容长度
        min-response-size: 2048
        mime-types: /*
      servlet:
        # session 过期时间,注意单位是秒
        session:
          timeout: 3600
      undertow:
        threads:
          io: 8
          worker: 256
    

    如何切换内嵌服务器

    由于我们在引入spring-boot-starter-web模块的时候,默认会将tomcat作为servlet容器。因此,在pom.xml中更改如下:

    <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
             <exclusions>
                 <exclusion>
                     <groupId>org.springframework.boot</groupId>
                     <artifactId>spring-boot-starter-tomcat</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-undertow</artifactId>
         </dependency>
    

    内嵌服务器自动配置原理介绍(如何使用)

    在SpringBoot的自动配置类路径下找到:org\springframework\boot\spring-boot-autoconfigure\2.3.4.RELEASE\spring-boot-autoconfigure-2.3.4.RELEASE.jar!\org\springframework\boot\autoconfigure\web\servlet\ServletWebServerFactoryAutoConfiguration.class,

    @Configuration(
     proxyBeanMethods = false
    )
    @AutoConfigureOrder(-2147483648)
    @ConditionalOnClass({ServletRequest.class})
    @ConditionalOnWebApplication(
     type = Type.SERVLET
    )
    @EnableConfigurationProperties({ServerProperties.class})
    @Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
    

    这里主要关注两个注解:
    @EnableConfigurationProperties({ServerProperties.class})//加载可配置的属性
    @Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})//导入内嵌服务器插件
    下面对具体实现进行分析:

    public class ServletWebServerFactoryAutoConfiguration {
        public ServletWebServerFactoryAutoConfiguration() {
        }
    
        @Bean
        public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
            return new ServletWebServerFactoryCustomizer(serverProperties);
        }
    
        @Bean
        @ConditionalOnClass(
            name = {"org.apache.catalina.startup.Tomcat"}
        )
        public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
            return new TomcatServletWebServerFactoryCustomizer(serverProperties);
        }
    
        @Bean
        @ConditionalOnMissingFilterBean({ForwardedHeaderFilter.class})
        @ConditionalOnProperty(
            value = {"server.forward-headers-strategy"},
            havingValue = "framework"
        )
        public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
            ForwardedHeaderFilter filter = new ForwardedHeaderFilter();
            FilterRegistrationBean<ForwardedHeaderFilter> registration = new FilterRegistrationBean(filter, new ServletRegistrationBean[0]);
            registration.setDispatcherTypes(DispatcherType.REQUEST, new DispatcherType[]{DispatcherType.ASYNC, DispatcherType.ERROR});
            registration.setOrder(-2147483648);
            return registration;
        }
    //前面主要注册了三个Bean对象,分别为ServletWebServerFactoryCustomizer、TomcatServletWebServerFactoryCustomizer和FilterRegistrationBean。
    
        public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
            private ConfigurableListableBeanFactory beanFactory;
    
            public BeanPostProcessorsRegistrar() {
            }
    
            public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
                if (beanFactory instanceof ConfigurableListableBeanFactory) {
                    this.beanFactory = (ConfigurableListableBeanFactory)beanFactory;
                }
    
            }
    
            public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
                if (this.beanFactory != null) {
                    this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);
                    this.registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class);
                }
            }
    
            private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {
                if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                    RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
                    beanDefinition.setSynthetic(true);
                    registry.registerBeanDefinition(name, beanDefinition);
                }
    
            }
        }
    }
    //后续三个函数主要注册了WebServerFactoryCustomizerBeanPostProcessor.class和ErrorPageRegistrarBeanPostProcessor.class两个类。
    

    分析:
    WebServerFactoryCustomizerBeanPostProcessor.class:后置处理器。bean初始化前后(创建完对象,还没赋值),执行初始化工作。
    //如果当前初始化的是一个webServerFactory对象,就执行postProcessBeforeInitialization
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof WebServerFactory) {
    this.postProcessBeforeInitialization((WebServerFactory)bean);
    }
    return bean;
    }
    //获取所有的定制器,调用每一个定制器的customize方法为其赋值。这里的customize方法就是为其做赋值处理的。
    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
    ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
    customizer.customize(webServerFactory);
    });
    }

    展开全文
  • Spring boot 之内嵌服务器

    千次阅读 2022-03-09 11:47:57
    什么是内嵌服务器 所谓内嵌服务器就是不需要我们单独部署,集成到Spring Boot中的服务器。 回想一下,我们如何访问传统的web项目?首先我们需要在系统(如linux系统)中安装web服务器(如tomcat),然后将我们的...

    什么是内嵌式服务器

    所谓内嵌式服务器就是不需要我们单独部署,集成到Spring Boot中的服务器。
    回想一下,我们如何访问传统的web项目?首先我们需要在系统(如linux系统)中安装web服务器(如tomcat),然后将我们的应用程序打包成war,再将war包放入tomcat目录下的webapps,启动Tomcat,才可以正常访问我们的web项目。
    那内嵌式服务器有什么好处呢?好处就是不需要我们进行上述繁琐的操作了,Spring boot会直接将项目打包成jar包,但是这个jar包和我们传统意义的jar不一样,这个jar可以使用 java -jar *.jar命令直接运行,但是不可以被其他项目依赖,而传统的jar可以被其他项目依赖,但是不能够被直接运行,所以虽然两者都被称为jar包,但是两者在目录结构上是有很大不同的。

    Spring Boot支持哪些内嵌式服务器

    我们以 2.2.6.RELEASE版本的Spring Boot为例,其支持三种内嵌式服务器:tomcatjettyundertow
    三者的区别:

    • jetty适合交互式消息
    • 不支持JSP,并发性能较高

    Spring Boot中默认使用tomcat作为内嵌的服务器,但是细心的小伙伴会发现,我们并没有引入tomcat的依赖,那Spring boot是如何知道使用tomcat作为默认的内嵌服务器的呢?其实很简单spring-boot-starter-web中已经包含了spring-boot-starter-tomcat依赖。

    改变Spring Boot的内嵌服务器

    我们知道Spring Boot使用tomcat作为默认的内嵌服务器,并且有关tomcat 的依赖是在spring-boot-starter-web中默认包含的,所以要改变spring boot的内嵌服务器,首先要剔除默认的tomcat依赖:

    <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
             <exclusions>
                 <exclusion>
                     <groupId>org.springframework.boot</groupId>
                     <artifactId>spring-boot-starter-tomcat</artifactId>
                 </exclusion>
             </exclusions>
    </dependency>
    

    然后引入其他服务器依赖,这里以jetty为例:

    <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
    

    这样就完成了内嵌服务器的修改,如果想使用undertow作为内嵌服务器,方式是一样的,这里不再赘述。

    内嵌服务器的常用配置参数

    日常开发中,除了会修改内嵌服务器外,有时还会根据需要修改内嵌服务器的配置参数,例如:

    //修改请求的端口
    server.port=8089
    //是否启用压缩
    server.compression.enabled=
    //针对压缩的类型
    server.compression.mime-types=
    //响应结果大小超过多大使用压缩
    server.compression.min-response-size=
    

    官方提供了很多有关内嵌服务器的配置,如果全都列出来完全没有必要。为了让我们在需要的时候可以方便的找到这些配置参数,我们可以总结一些规律:首先,与内嵌服务器配置相关的参数,一般都是以server开头 ,例如上面的配置;其次,如果我们要配置指定内嵌服务器(如tomcat)的参数,我们可以找server.tomcat开头的参数,同理,如要想要配置jetty的相关参数就找server.jetty开头的参数。

    SpringBoot内嵌式服务器的启动原理

    详见Spring boot内嵌服务器引擎的实现原理
    详见详解SpringBoot内嵌WEB服务器的启动过程

    Spring boot中配置SSL

    SSL(Secure Sockets Layer 安全套接层)是为网络通信提供安全及数据完整性的一种安全协议,SSL在网络传输层对网络连接进行加密,SSL协议位于TCP/IP协议与各种应用层协议之间,为数据通信提供安全支持。SSL协议分为两层,SSL记录协议建立在TCP之上,为高层协议提供数据封装、压缩、加密等基本功能支持。SSL握手协议建立在SSL记录协议之上,用户实际数据传输开始前进行身份验证、协商加密算法、交换加密秘钥。

    HTTPS (全称:Hyper Text Transfer Protocol over SecureSocket Layer),是以安全为目标的 HTTP 通道,在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性 [1] 。HTTPS 在HTTP 的基础下加入SSL 层,HTTPS 的安全基础是 SSL,因此加密的详细内容就需要 SSL。 HTTPS 存在不同于 HTTP 的默认端口及一个加密/身份验证层(在 HTTP与 TCP 之间)。这个系统提供了身份验证与加密通讯方法。它被广泛用于万维网上安全敏感的通讯,例如交易支付等方面。

    在了解Spring boot中配置ssl之前,我们先介绍了两个概念:ssl和https,这将有助于我们理解为什么要在springboot中使用ssl配置。

    我们知道spring boot项目默认支持http请求,但是http是非安全的,而https是安全的,如果想要spring boot支持https请求,需要怎么做呢?这就需要在spring boot项目中进行ssl有关的配置。

    # 是否开启ssl ,true:开启,false:不开启
    server.ssl.enabled=true
    #证书路径。注意:根绝证书放置位置不同,证书路径的配置也不同,例如:
    	1.可以写证书的绝对路径
    	2.如果证书放在项目中resources目录下且和application.properties在同级目录下,写成:classpath:keystore.jks,也就是代码中的写法
    	3.如果证书和src目录同级,就直接配置:server.ssl.key-store=keystore.jks
    server.ssl.key-store: classpath:keystore.jks
    #证书密码,此密码与.keystore文件中的一致
    server.ssl.key-store-password: 123456  
     #证书文件类型  注意我们是在Java环境中,常用的证书形式有p12、pkcs12格式、jks格式,如果不是该格式,需要转换;p12、pkcs12是同一个,只是证书的后缀不同而已。
    server.ssl.keyStoreType: JKS  
    # 设定key store的提供者
    server.ssl.key-store-provider
    #证书别名  
    server.ssl.keyAlias: tomcat 
    

    如果使用了上面的配置就表示springboot应用程序不再在端口8080上支持HTTP连接请求,SpringBoot不支持通过配置application.properties(或yaml)来实现既支持HTTP连接又支持HTTPS连接,如果想要同时支持HTTP和HTTPS,则需要以编程方式配置其中的一个,建议使用application.properties文件来配置HTTPS,以编程方式配置HTTP,这是比较容易的方法。

    上面仅仅是springboot中使用https的配置,细心的小伙伴可能会有这样的疑问:keystore.jks是什么?从哪里来的?123456这个密码又是从哪里来的?其实keystore.jks是ssl证书,可以通过不同的方式生成,下面具体讲,而12345就是生成证书中的密码。

    获取SSL证书的方式

    获取ssl证书的方式大致有两种:利用JDK工具生成证书(测试使用)和从SSL证书授权中心购买证书(生产环境使用)。

    利用JDK工具生成证书

    每一个JDK或者JRE里都有一个工具叫keytool,它是一个证书管理工具,可以用来生成自签名的证书。具体步骤
    1.首先安装好JDK并配置好环境变量
    2.打开cmd控制台,输入:keytool -genkey -alias tomcat,然后回车。如下图:
    在这里插入图片描述
    3.按着图中提示一步步操作
    在这里插入图片描述
    字段解释

    • C字段:Country,单位所在国家,为两位数的国家缩写,如:CN 表示中国;
    • ST 字段:State/Province,单位所在州或省;
    • L 字段:Locality,单位所在城市/或县区;
    • O 字段:Organization,此网站的单位名称;
    • OU 字段:Organization Unit,下属部门名称,也常常用于显示其他证书相关信息,如证书类型,证书产品名称或身份验证类型或验证内容等;
    • CN 字段:Common Name,网站的域名;

    4.找到用户所在盘符目录,这里是C:/users/administrator ,看自己的实际情况,找到生成的证书文件
    在这里插入图片描述
    .keystore 这文件就是证书。
    5.然后将证书放置到项目中,具体放置方式上面在介绍server.ssl.key-store参数时已经介绍过,这里不再赘述。到此,就算配置完成了,就可以通过https来请求项目了。

    从SSL证书授权中心购买证书

    此种方式用于生产的证书获取。阿里云和腾讯云都有这样的服务,具体的这里不再介绍。但是同样可以得到我们想要的证书文件,供我们进行相关的配置。

    需要注意的是,日常生产中,微服务一般都是通过网关(gateway)访问的,而网关又是通过nginx访问的,所以很多时候ssl工作直接就在nginx这层完成了,甚至是在F5中完成。

    Springboot如何支持同时支持http和https

    上面说过,SpringBoot不支持通过配置application.properties(或yaml)来实现既支持HTTP连接又支持HTTPS连接,一种可行的方式是:使用application.properties文件来配置HTTPS,以编程方式配置HTTP,这是比较容易的方法。完成上面的关于https的配置后,下面我们看看如何通过编程的方式实现支持http请求。

    代码如下

    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication .class, args);
        }
    
        // SpringBoot2.x配置HTTPS,并实现HTTP访问自动转向HTTPS
        @Bean
        public ServletWebServerFactory servletContainer() {
            TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory(){
                @Override
                protected void postProcessContext(Context context) {
                    SecurityConstraint securityConstraint = new SecurityConstraint();
                    securityConstraint.setUserConstraint("CONFIDENTIAL");
                    SecurityCollection collection = new SecurityCollection();
                    collection.addPattern("/*");
                    securityConstraint.addCollection(collection);
                    context.addConstraint(securityConstraint);
                }
            };
            tomcat.addAdditionalTomcatConnectors(httpConnector());
            return tomcat;
        }
    
        @Bean
        public Connector httpConnector() {
            Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
            connector.setScheme("http");
            connector.setPort(8080); // 监听Http的端口
            connector.setSecure(false);
            connector.setRedirectPort(8443); // 监听Http端口后转向Https端口
            return connector;
        }
    }
    

    这样配置后,我们的项目就即支持http请求又支持https请求了。

    嵌入式Reactive Web容器

    我们知道,Spring Framework 5.0引入Spring WebFlux,Spring WebFlux是一个新的reactive web应用框架。与Spring MVC不同的是,它不需要the Servlet API,是完全异步和非阻塞的。而我们上面所讲的都属于嵌入式Servlet Web容器,很显然是无法运行一个reactive web应用的,幸运的是Spring boot 2.0开始支持了嵌入式Reactive Web 容器,但这并不是默认的选项。

    需要注意的是,当spring-boot-starter-web和spring-boot-starter-webflux同时存在时,spring-boot-starter-webflux实际上是会被默认忽略掉的,真正其作用的是spring-boot-starter-web,所以在使用spring-boot-starter-webflux的时候,我们需要把spring-boot-starter-web注释掉。修改后的pom文件如下:

    <dependencies>
            <!--<dependency>-->
                <!--<groupId>org.springframework.boot</groupId>-->
                <!--<artifactId>spring-boot-starter-web</artifactId>-->
                <!--<exclusions>-->
                    <!--&lt;!&ndash; Exclude the Tomcat dependency &ndash;&gt;-->
                    <!--<exclusion>-->
                        <!--<groupId>org.springframework.boot</groupId>-->
                        <!--<artifactId>spring-boot-starter-tomcat</artifactId>-->
                    <!--</exclusion>-->
                <!--</exclusions>-->
            <!--</dependency>-->
            <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
            </dependency>
    ​
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-webflux</artifactId>
            </dependency>
     </dependencies>
    
    展开全文
  • Spring MVC 使用 Jetty 作为内嵌服务器

    千次阅读 2018-03-27 23:53:53
    在本文中,我们将使用 Spring Web MVC 技术来实现 REST 接口,并使用 使用 Jetty 作为内嵌服务器,方便测试。 接口设计 我们将会在系统中实现两个接口: GET http://localhost:8080/hello GET ...
  • 为什么Sprint Boot要内嵌服务器呢? 想象一下如果要部署一个Java应用都需要做些什么呢? 安装JDK 安装Web/Application服务器(Tomcat/Jetty etc) 部署war包 如果我们想要简化这个流程,并且只要拥有Java运行环境...
  • JavaWeb之Jetty和Tomcat内嵌服务器实现

    千次阅读 2017-10-22 13:33:55
    在开发Java web项目时候,可以在项目中嵌入tomcat和jetty服务器的方式来运行web程序。
  • 本文介绍了Web服务器的工作原理,将CGI和Java Applet技术内嵌在嵌入式服务器上,通过客户端的浏览器可以实现嵌入式Web网络传感器的实时数据采集,节约了诸多的硬件资源和人力资源,使得对远程数据自动采集变得更加...
  • 1、源码分析SpringBoot如何内嵌Tomcat服务器? 2、SpringBoot中如何启动Tomcat? 3、SpringBoot中如何关闭Tomcat?
  • 嵌入式Web网络传感器技术是传感器、嵌入式、分布式信息处理和Internet等相关技术交叉结合的技术,它是在智能传感器的基础上把TCP/IP协议作为一种嵌入式应用,嵌入现成智能服务器的ROM中,利用传感器内建的Web服务器...
  • 在SpringBoot框架中,大家应该发现了有一个内嵌的tomcat,在之前的开发流程中,每次写好代码之后必须将项目部署到一个额外的web服务器中,只有这样才能运行,这个明显要麻烦很多,而使用SpringBoot的时候,你会发现...
  • 下面小编就为大家带来一篇使用Libmicrohttpd搭建内嵌(本地)服务器的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • maven中的pom依赖 org.eclipse.jetty jetty-server 8.1.7.v20120910 org.eclipse.jetty jetty-webapp 8.1.7.v20120910
  • 内嵌Tomcat服务器是SpringBoot辅助功能之一
  • 背景因项目需求,需要在Android(7.1.2)中内嵌web服务器(lighttpd+PHP环境)硬件平台: RK3399方案选择最终选择用方案3, 采用buildroot+chroot自己构建过程buildroot构建最小文件系统具体过程可参考博文:文件系统中需...
  • 文章目录 1.Jetty 的切换 ...《Spring Boot 揭秘与实战(五) 服务器篇 - 内嵌服务器 Tomcat剖析》一文,已经讲解了内嵌服务器 Tomcat,那么,这篇文章大概讲解下另外两个内嵌服务器 Jetty...
  • (1)SpringBoot底层有Tomcat、Jetty、undertow服务器的组件,但各个组件需要满足特定条件(如对应的类存在)才会加载入IOC容器。 (2)SpringBoot依靠服务器的工厂来创建服务器组件。 (3)可以通过修改application...
  • Undertow是一个非常轻量并高性能的web server,它来自 JBoss。支持blocking和non-blocking两种NIO API。接下来通过本文给大家介绍使用Spring Boot 内嵌容器 Undertow创建服务器的方法,感兴趣的朋友一起看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,090
精华内容 32,436
关键字:

内嵌服务器