springboot配置https

合集下载

spring cloudspring boot同时支持http和https访问

spring cloudspring boot同时支持http和https访问前言关于spring boot同时支持http和https访问，在spring boot官网73.9已经有说明文档了，同样在github上也有官网的例子。

在这里，我向大家讲述一下，我是怎么实现的。

方式一一、相关配置server:port: 4000https:port: 8443ssl:key-store: classpath:sample.jkskey-store-password: secretkey-password: password可以看到，只是简简单单添加端口的信息，sample.jks可以自己生成（记得对应密码），也可以在官网例子里面下载。

二、spring boot启动文件读取配置信息（注：请添加必要的jar）@SpringBootApplicationpublic class GatewayApplication {public static void main(String[] args) throws Exception {SpringApplication.run(GatewayApplication.class, args);}@Value("${https.port}")private Integer port;@Value("${https.ssl.key-store-password}")private String key_store_password;@Value("${https.ssl.key-password}")private String key_password;/* --------------------请按照自己spring boot版本选择start--------------------- */// 这是spring boot 1.5.X以下版本的添加了这个，下一个就不用添加了@Beanpublic EmbeddedServletContainerFactory servletContainer() {TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();tomcat.addAdditionalTomcatConnectors(createSslConnec tor()); // 添加httpreturn tomcat;}// 这是spring boot 2.0.X版本的添加这个，上一个就不用添加了@Beanpublic ServletWebServerFactory servletContainer() { TomcatServletWebServerFactory tomcat = newTomcatServletWebServerFactory();tomcat.addAdditionalTomcatConnectors(createSslConnec tor()); // 添加httpreturn tomcat;}/* -------------------请按照自己spring boot版本选择end---------------------- */// 配置httpsprivate Connector createSslConnector() {Connector connector = newConnector("org.apache.coyote.http11.Http11NioProtocol");Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();try {File keystore = newClassPathResource("sample.jks").getFile();/*File truststore = new ClassPathResource("sample.jks").getFile();*/connector.setScheme("https");connector.setSecure(true);connector.setPort(port);protocol.setSSLEnabled(true);protocol.setKeystoreFile(keystore.getAbsolutePath());protocol.setKeystorePass(key_store_password);protocol.setKeyPass(key_password);return connector;}catch (IOException ex) {throw new IllegalStateException("can't access keystore: [" + "keystore"+ "] or truststore: [" + "keystore" + "]", ex);}}}启动项目后，可以看到两个端口，说明已经成功方式二一、相关配置server:port: 8443ssl:key-store: classpath:sample.jkskey-store-password: secretkey-password: passwordhttp:port: 8080二、spring boot启动文件读取配置信息（注：请添加必要的jar）@SpringBootApplicationpublic class SampleTomcatTwoConnectorsApplication {@Value("${http.port}")private Integer port; /* --------------------请按照自己spring boot版本选择start--------------------- */// 这是spring boot 1.5.X以下版本的添加了这个，下一个就不用添加了@Beanpublic EmbeddedServletContainerFactory servletContainer() {TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();tomcat.addAdditionalTomcatConnectors(createStandardC onnector()); // 添加httpreturn tomcat;}// 这是spring boot 2.0.X版本的添加这个，上一个就不用添加了@Beanpublic ServletWebServerFactory servletContainer() { TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();tomcat.addAdditionalTomcatConnectors(createStandardC onnector()); // 添加httpreturn tomcat;}/* --------------------请按照自己spring boot版本选择end--------------------- */// 配置httpprivate Connector createStandardConnector() {Connector connector = newConnector("org.apache.coyote.http11.Http11NioProtocol");connector.setPort(port);return connector;}public static void main(String[] args) throws Exception {SpringApplication.run(SampleTomcatTwoConnectorsAppli cation.class, args);}}启动项目后，可以看到两个端口，说明已经成功总结对比两种方法可以看出方式二比方式一简单一点，主要是因为方式二用的代码比较少，我也不知道这两种方式有什么区别，我自己测试过，无论是spring boot还是spring cloud,这两个方式都没问题，就算是方式二，同样可以帮服务注册到eureka上。

springboot重定向传递参数

springboot重定向传递参数在Spring Boot中，重定向和传递参数是很常见的需求。

Spring Boot提供了多种方式来实现重定向并传递参数的功能。

一种常见的重定向和传递参数的方式是使用RedirectAttributes。

RedirectAttributes是Spring MVC提供的一种特殊的Model对象，它可以在重定向的过程中传递参数。

使用RedirectAttributes可以将参数添加到重定向的URL中，也可以将参数作为FlashAttribute传递。

首先，我们需要在处理重定向的方法中使用RedirectAttributes参数。

例如，我们有一个处理POST请求的方法，该方法在处理完请求后需要重定向到另一个页面，并传递参数：```javapublic String submitForm(Model model, RedirectAttributes redirectAttributes)//处理表单提交的数据//...//添加参数到重定向URLredirectAttributes.addAttribute("message", "成功提交表单");//重定向到另一个页面return "redirect:/result";```在上面的例子中，我们使用了addAttribute方法将参数"message"和它的值"成功提交表单"添加到重定向的URL中。

注意，这里的addAttribute方法是将参数添加到URL的查询字符串中。

```javamodel.addAttribute("message", message);return "result";```除了使用addAttribute方法将参数添加到URL的查询字符串中，我们还可以使用addFlashAttribute方法将参数作为FlashAttribute传递。

解决SpringBoot加载application.properties配置文件的坑

解决SpringBoot加载application.properties配置⽂件的坑SpringBoot加载application.properties配置⽂件的坑事情的起因是这样的⼀次，本⼈在现场升级程序，升级完成后进⾏测试，结果接⼝调⽤都报了这么个错误：⼤概意思是https接⼝需要证书校验，这就奇怪了，项⽬启动加载的是包外的application.properties配置⽂件，配置⽂件⾥没有配置使⽤https啊。

本⼈马上检查了下包内的application.properties配置⽂件，发现包内确实配置了https相关的配置项：明明包外的配置⽂件优先级⾼于包内的，为啥包内的⼀部分配置项起作⽤了呢，我们了解的配置⽂件优先级是这样的：这是为啥呢？后来才了解到除了⾼优先级覆盖低优先级外，还有⼀条重要的规则：如有不同内容，⾼优先级和低优先级形成互补配置。

这下才恍然⼤悟，我包外的配置⽂件⾥把https相关的配置项注释掉了，相当于没有这个配置项，但是包内的配置⽂件有，根据互补原则，包内的这⼏个配置项起作⽤了。

问题原因找到了，如何解决呢？要不我把包内的那⼏个配置项也注释掉，重新打个包？其实不必这么⿇烦，通过-Dspring.config.location命令直接指定包外的配置⽂件就可以了，试了下，果然没有问题了。

问题虽然解决了，但是还有些疑问，为啥指定包外的配置⽂件后就不存在互补情况了呢？通过阅读springboot相关源码，找到了答案：⼤概意思是：如果-Dspring.config.location指定了配置⽂件，则只加载指定的那⼀个配置⽂件，如果没有专门指定配置⽂件则遍历包外、包内相关的配置⽂件，按照⾼优先级覆盖低优先级和互补原则进⾏加载。

弄明⽩这些问题后，实地部署项⽬的时候，保险起见还是通过-Dspring.config.location命令直接指定加载的配置⽂件⽐较好，避免出现⼀些不必要的⿇烦。

Spring Boot加载application.properties探究基于Spring Boot的多Module项⽬中，有许多公共的配置项，为避免在每个接⼊层都配置⼀遍，⼀个设想是在公共依赖的Module的application.properties(application.yml)中进⾏配置。

本地开发环境，SpringBoot如何支持HTTPS访问

2、进入到springboot 的resouce目录，利用java/bin目录下的keytool生成证书，需配置java环境变量证书生成命令
keytool -genkey -alias server_cert -keypass 12345678 -keyalg RSA -keysize 1024 -validity 365 -keystore server.keystore -storepass 12345678
在resource会出现server.keystore文件，则生成成功，配置里server.ssl.key-store-password 为设置的密码 3、启动springboot 即可进行https访问二、查看本地添加证书
keytool -export -alias server_cert -keystore server.keystore -file tomcat_server.cer
网络错误503请刷新页面重试持续报错请尝试更换浏览器或网络环境
本地开发环境， SpringBoot如何支持 HTTPS访问
1、在配置文件里application.properties添加：
server.port=8443 server.ssl.protocol=TLS server.ssl.key-store=classpath:server.keystore server.ssl.key-store-password=12345678 server.ssl.key-store-type=JKS
生成tomcat_server.cer文件，双击文件，安装证书
自签名证书不受CA机构信任，客户端默认是不信任此证书的
Байду номын сангаас

springboot常见面试题

10道springboot常见面试题你需要了解下1.什么是Spring Boot？多年来，随着新功能的增加，spring变得越来越复杂。

只需访问https://spring.io/projects页面，我们就会看到可以在我们的应用程序中使用的所有Spring项目的不同功能。

如果必须启动一个新的Spring项目，我们必须添加构建路径或添加Maven依赖关系，配置应用程序服务器，添加spring配置。

因此，开始一个新的spring项目需要很多努力，因为我们现在必须从头开始做所有事情。

Spring Boot是解决这个问题的方法。

Spring Boot已经建立在现有spring框架之上。

使用spring启动，我们避免了之前我们必须做的所有样板代码和配置。

因此，Spring Boot可以帮助我们以最少的工作量，更加健壮地使用现有的Spring功能。

2.Spring Boot有哪些优点？▪减少开发，测试时间和努力。

▪使用JavaConfig有助于避免使用XML。

▪避免大量的Maven导入和各种版本冲突。

▪提供意见发展方法。

▪通过提供默认值快速开始开发。

▪没有单独的Web服务器需要。

这意味着你不再需要启动Tomcat，Glassfish或其他任何东西。

▪需要更少的配置因为没有web.xml文件。

只需添加用@ Configuration 注释的类，然后添加用@Bean注释的方法，Spring将自动加载对象并像以前一样对其进行管理。

您甚至可以将@Autowired添加到bean方法中，以使Spring 自动装入需要的依赖关系中。

▪基于环境的配置使用这些属性，您可以将您正在使用的环境传递到应用程序：-Dspring.profiles.active = {enviornment}。

在加载主应用程序属性文件后，Spring将在（application{environment} .properties）中加载后续的应用程序属性文件。

springboot搭建http2服务器和h2c服务器h2的httphttps请求服务器

springboot搭建http2服务器和h2c服务器h2的httphttps请求服务器HTTP/2使⽤和HTTP/1.1⼀样的 URI schemes："http" 和 "https"，并且还是共享同样的默认端⼝：http的80，https的443。

这意味着，对于"http" 和 "https"确定其是否⽀持HTTP/2协议的⽅式是不同的。

在官⽅⽂档中，为HTTP/2协议定义了两个版本：h2 和 h2c：1.虽然HTTP/2没有明确要求必须使⽤TLS，但当前⼏乎所有浏览器均只⽀持 HTTP/2 Over TLS。

所以在使⽤之前我们需要先制作⼀张证书。

3.我们制作的证书是不被浏览器认可的，所以会有安全提⽰，不能⽤于⽣产环境。

在本⽂的例⼦中使⽤的是undertow。

1.制作证书：使⽤JDK⾃带的keytool，证书类型为：PKCS12打开cmd 输⼊下⾯的命令：keytool -genkey -alias undertow -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -dname "CN=localhost,OU=localhost, O=localhost, L=hangzhou, ST=zhejiang, C=CN"输⼊密钥库⼝令:再次输⼊新⼝令:执⾏时会要求输⼊证书⼝令，这⾥输⼊的是123456。

执⾏完命令后会在执⾏的⽂件夹⽣成⼀个keystore.p12的⽂件。

keytool-genkey-alias undertow （别名）-storetype PKCS12 （证书类型）-keyalg RSA （算法）-keysize 2048 （秘钥长度）-keystore keystore.p12 (指定⽣成证书的位置和证书名称)-dname "CN=localhost,（姓名姓⽒）OU=localhost,（组织单位）O=localhost,（组织名称）L=hangzhou,（所在城市或者区域名称）ST=zhejiang,（所在的省/市/⾃治区名称）C=CN"（该单位的双字母国家/地区代码）keytool的详细⽤法：常见的证书格式及其说明参考：配置Web容器spring boot默认使⽤的是tomcat，我们需要先将tomcat移除，然后换成undertow。

springboot+mybatis-plus的logback+Slf4j日志配置及sql打印

springboot+mybatis-plus的logback+Slf4j⽇志配置及sql打印第⼀步加⼊如下log包// https:///artifact/org.projectlombok/lombokcompileOnly 'org.projectlombok:lombok:1.18.6'annotationProcessor 'org.projectlombok:lombok:1.18.6'// https:///artifact/org.springframework.boot/spring-boot-starter-loggingcompile group: 'org.springframework.boot', name: 'spring-boot-starter-logging', version: '2.3.1.RELEASE'　在resources下新建logback-spring.xml放在resources下springboot可⾃动装配。

如果想⾃定义可在mybatisplus配置中设置如下# 加载全局的配置⽂件configLocation: classpath:mybatis/mybatis-config.xmllogback-spring.xml⽂件<?xml version="1.0" encoding="UTF-8"?><configuration scan="true" scanPeriod="60 seconds" debug="false"><contextName>logback</contextName><property name="LOG_HOME" value="logs" /><conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" /><conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" /><conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" /><property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(% <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"><filter class="ch.qos.logback.classic.filter.ThresholdFilter"><level>debug</level></filter><encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"><pattern>${CONSOLE_LOG_PATTERN}</pattern></encoder></appender><appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><FileNamePattern>${LOG_HOME}/promotion.%d{yyyy-MM-dd}.log</FileNamePattern><MaxHistory>30</MaxHistory></rollingPolicy><encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern></encoder><triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"><MaxFileSize>10MB</MaxFileSize></triggeringPolicy></appender><root level="debug"><appender-ref ref="STDOUT" /><appender-ref ref="FILE" /></root><root level="info"><appender-ref ref="STDOUT" /><appender-ref ref="FILE" /></root></configuration>mapper（sql）⽇志级别logging:level:com.example.gradle.mapper: debug　使⽤例⼦@RestController@RequestMapping("/pay-record")@Slf4jpublic class PayRecordController {@Autowiredprivate IPayRecordService service;/*** 查询列表* @return*/@GetMapping("/list")public AjaxResult list(PayRecord payRecord) {("⽇志测试");LambdaQueryWrapper<PayRecord> wrapper = new QueryWrapper<PayRecord>().lambda();if(null != payRecord.getPayId()){wrapper.eq(PayRecord::getPayId,payRecord.getPayId());}return AjaxResult.success(service.list(wrapper));}} 打印出的log2020-09-12 18:45:52.093 INFO 11740 --- [ main] o.s.s.concurrent.ThreadPoolTaskExecutor : Initializing ExecutorService 'applicationTaskExecutor'2020-09-12 18:45:52.256 INFO 11740 --- [ main] o.a.coyote.http11.Http11NioProtocol : Starting ProtocolHandler ["http-nio-8080"]2020-09-12 18:45:52.353 INFO 11740 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''2020-09-12 18:45:52.365 INFO 11740 --- [ main] com.example.DemoApplication : Started DemoApplication in 2.236 seconds (JVM running for 3.306)2020-09-12 18:45:56.119 INFO 11740 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring DispatcherServlet 'dispatcherServlet'2020-09-12 18:45:56.123 INFO 11740 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'2020-09-12 18:45:56.131 INFO 11740 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Completed initialization in 8 ms2020-09-12 18:45:56.171 INFO 11740 --- [nio-8080-exec-1] c.e.g.controller.PayRecordController : ⽇志测试2020-09-12 18:45:56.305 INFO 11740 --- [nio-8080-exec-1] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} inited2020-09-12 18:45:57.588 DEBUG 11740 --- [nio-8080-exec-1] c.e.g.mapper.PayRecordMapper.selectList : ==> Preparing: SELECT pay_id,receipt_by,dept_name,pay_time,remark,del_flag,paid_money,receipt_time,pay_money,pay_idnumber,upd 2020-09-12 18:45:57.620 DEBUG 11740 --- [nio-8080-exec-1] c.e.g.mapper.PayRecordMapper.selectList : ==> Parameters:2020-09-12 18:45:57.714 DEBUG 11740 --- [nio-8080-exec-1] c.e.g.mapper.PayRecordMapper.selectList : <== Total: 1 完美解决sql的打印⽣产环境只需吧mapper⽇志级别改为info即可。

SpringBoot（七）———Tomcat、Jetty优化以及Https配置

SpringBoot（七）———Tomcat、Jetty优化以及Https配置SpringBoot初始教程之Tomcat、Jetty优化以及Https配置(九)1.介绍在SpringBoot的Web项⽬中，默认采⽤的是内置Tomcat，当然也可以配置⽀持内置的jetty，内置有什么好处呢？1. ⽅便微服务部署。

2. ⽅便项⽬启动，不需要下载Tomcat或者Jetty在⽬前的公司已经把内置的Jetty部署到了线上项⽬中，⽬前来说并⽆太⼤问题，内置就算有⼀些性能损失，但是通过部署多台机器，其实也能够很轻松的解决这样的问题，内置容器之后其实是⽅便部署和迁移的。

1.1 优化策略针对⽬前的容器优化，⽬前来说没有太多地⽅，需要考虑如下⼏个点1. 线程数2. 超时时间3. jvm优化针对上述的优化点来说，⾸先线程数是⼀个重点，初始线程数和最⼤线程数，初始线程数保障启动的时候，如果有⼤量⽤户访问，能够很稳定的接受请求，⽽最⼤线程数量⽤来保证系统的稳定性，⽽超时时间⽤来保障连接数不容易被压垮，如果⼤批量的请求过来，延迟⽐较⾼，不容易把线程打满。

这种情况在⽣产中是⽐较常见的⼀旦⽹络不稳定，宁愿丢包也不愿意把机器压垮。

jvm优化⼀般来说没有太多场景，⽆⾮就是加⼤初始的堆，和最⼤限制堆,当然也不是⽆限增⼤，根据的情况进⾏调节2. 快速开始3.1 Tomcat SSLtomcat的SSL配置很简单,先通过JDK的⽅式⽣成.keystore，这种⽅式的证书⼀般来说不太被认可的，最好的⽅式去⽹上申请，阿⾥云和腾讯云都可以免费申请，这种⽅式配置出来的https，google浏览器会提⽰https不受认证keytool -genkey -alias tomcat -keyalg RSAapplication-tomcat.yaml这块对tomcat进⾏了⼀个优化配置，最⼤线程数是100，初始化线程是20,超时时间是5000msserver:tomcat:max-threads: 100min-spare-threads: 20connection-timeout: 5000ssl:key-store: classpath:.keystorekey-store-type: JKSkey-password: qq123456key-alias: tomcatport: 8443启动类启动类这块加上了⼀个httpConnector，为了⽀持https访问和http访问@SpringBootApplicationpublic class AppApplication {public static void main(String args[]) {SpringApplication.run(AppApplication.class, args);}@Beanpublic EmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() throws IOException {TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();tomcat.addAdditionalTomcatConnectors(httpConnector());return tomcat;}public Connector httpConnector() throws IOException {Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");Http11NioProtocol http11NioProtocol = (Http11NioProtocol) connector.getProtocolHandler();connector.setPort(8080);//设置最⼤线程数http11NioProtocol.setMaxThreads(100);//设置初始线程数最⼩空闲线程数http11NioProtocol.setMinSpareThreads(20);//设置超时http11NioProtocol.setConnectionTimeout(5000);return connector;}}上述就完成了https的配置，如果启动成功可以发现tomcat启动时候监听了两个端⼝2016-11-21 10:53:15.247 INFO 42382 --- [ main] com.start.AppApplication : Starting AppApplication on elemebjdeMacBook-Pro.local with PID 42382 (/Users/wangkang/code/SpringBoot-Learn/springboot-9/target/classes started 2016-11-21 10:53:15.251 INFO 42382 --- [ main] com.start.AppApplication : No active profile set, falling back to default profiles: default2016-11-21 10:53:15.426 INFO 42382 --- [ main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@489115ef: startup date [Mon No 2016-11-21 10:53:19.164 INFO 42382 --- [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8443 (https) 8080 (http)2016-11-21 10:53:19.193 INFO 42382 --- [ main] o.apache.catalina.core.StandardService : Starting service Tomcat2016-11-21 10:53:19.194 INFO 42382 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/8.5.3.2 jvm优化这块主要不是谈如何优化，jvm优化是⼀个需要场景化的，没有什么太多特定参数，⼀般来说在server端运⾏都会指定如下参数初始内存和最⼤内存基本会设置成⼀样的，具体⼤⼩根据场景设置，我们线上环境⼀般都是4G，因为机器是16G的，-server是⼀个必须要⽤的参数，⾄于收集器这些使⽤默认的就可以了，除⾮有特定需求java -Xms4g -Xmx4g -Xmn768m -server -jar springboot-9-1.4.1.RELEASE.jar4 jetty配置pom.xmlspringboot增加了⼀个starter针对jetty的，给pom增加⼀个依赖即可<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jetty</artifactId></dependency>下⾯是针对jetty的线程优化，进⾏了⼀个配置，当然不配置也是可以使⽤的，在线上环境中最好配置⼀下，进⾏优化@Profile("jetty")@Beanpublic JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory(JettyServerCustomizer jettyServerCustomizer) {JettyEmbeddedServletContainerFactory factory = new JettyEmbeddedServletContainerFactory();factory.addServerCustomizers(jettyServerCustomizer);return factory;}@Beanpublic JettyServerCustomizer jettyServerCustomizer() {return server -> {// Tweak the connection config used by Jetty to handle incoming HTTP// connectionsfinal QueuedThreadPool threadPool = server.getBean(QueuedThreadPool.class);threadPool.setMaxThreads(100);threadPool.setMinThreads(20);};}4.1 jetty https配置application-jetty.yamlhttps配置和tomcat的没有太多差别，这块是统⼀配置，SpringBoot做了⼀个抽象化⽽已server:connection-timeout: 5000ssl:key-store: classpath:.keystorekey-store-type: JKSkey-password: qq123456key-alias: tomcatport: 84443 总结⼀般来说在⽣产环境中不会⽤tomcat配置https，因为在我们的⽣产环境中，tomcat是⼀个统⼀的模板，只能够改线程数。

使用SpringBoot配置https（SSL证书）

使⽤SpringBoot配置https（SSL证书）⽬录SpringBoot配置https(SSL证书)仅需三步1.把tomcat⽬录⾥⾯的.jks⽂件2.配置application.yml3.接下来是重定向SpringBoot 改造成https访问1.⽣成密钥证书2.将⽣成的密钥证书拷贝到项⽬中的resource中3.修改项⽬配置⽂件application.properties4.启动项⽬，直接访问项⽬即可SpringBoot配置https(SSL证书)最近在做微信⼩程序，https是必须条件仅需三步SpringBoot2.x版本对⽐⼀下这个⼩锁头是不是莫名有点好看？嘤为很久以前就备案有域名，就直接申请了SSL证书，⼏分钟就下来了1.把tomcat⽬录⾥⾯的.jks⽂件复制到项⽬⾥⾯(注意路径)2.配置application.ymlssl:key-store: classpath:server.jkskey-store-password: 申请时设置的密码keyStoreType: JKS3.接下来是重定向在启动类底下添加；(把指定的http8080端⼝重定向到https8888)@Beanpublic ServletWebServerFactory servletContainer() {TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();tomcat.addAdditionalTomcatConnectors(createHTTPConnector());return tomcat;}private Connector createHTTPConnector() {Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");//同时启⽤http（8080）、https（8443）两个端⼝connector.setScheme("http");connector.setSecure(false);connector.setPort(8080);connector.setRedirectPort(443);return connector;}okSpringBoot 改造成https访问SpringBoot https改造1.⽣成密钥证书⽣成命令：keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650（1）关键字解释：alias：密钥别名storetype：指定密钥仓库类型keyalg：⽣证书的算法名称，RSA是⼀种⾮对称加密算法keysize：证书⼤⼩keystore：⽣成的证书⽂件的存储路径validity：证书的有效期（2）⽣成证书注意：在输⼊证书⽣成命令之后，会提⽰输⼊：密钥库⼝令：证书密码，在后⾯的项⽬中配置证书时⽤到姓⽒：⼀般没什么⽤，在浏览器中查看证书时会显⽰，⽤于正式场合的证书还是需要填写标准。

SpringBoot系列——启用https

SpringBoot系列——启⽤https 前⾔有时候我们需要使⽤https安全协议，本⽂记录在SpringBoot项⽬启⽤https ⽣成证书⾃签名证书使⽤java jdk⾃带的⽣成SSL证书的⼯具keytool⽣成⾃⼰的证书 1、打开cmd 2、输⼊命令⽣成证书keytool -genkeypair -alias tomcat_https -keypass 123456 -keyalg RSA -keysize 1024 -validity 365 -keystore d:/tomcat_https.keystore -storepass 123456 -alias 别名 -keypass 指定⽣成密钥的密码 -keyalg 指定密钥使⽤的加密算法（如 RSA） -keysize 密钥⼤⼩ -validity 过期时间，单位天 -keystore 指定存储密钥的密钥库的⽣成路径、名称 -storepass 指定访问密钥库的密码域名型证书 2020-01-10更新：今天使⽤内⽹穿透⼯具分给我们的⼆级域名去腾讯云申请证书，并记录⼀下 1、登录腾讯云 -> 证书管理 -> 申请免费证书 2、按照表单要求正确填写内容（填写的域名不需要www开头）⾸先看⽂档说明：在springBoot项⽬中的static⽂件夹新建，然后把⽂件内容复制进去等待 CA 机构扫描审核、颁发证书另外，内⽹穿透隧道协议类型要改成https，本地端⼝改成443，其他的不⽤变效果项⽬配置导⼊证书把⽣成的tomcat_https.keystore放在resources⾥（任意安全⽬录都可以）配置⽂件#https默认端⼝：443，http默认端⼝：80server.port=443server.http-port=80#开启https，配置跟证书⼀⼀对应server.ssl.enabled=true#指定证书server.ssl.key-store=classpath:tomcat_https.keystoreserver.ssl.key-store-type=JKS#别名server.ssl.key-alias=tomcat_https#密码server.ssl.key-password=123456server.ssl.key-store-password=123456=springboot-https 2021-12-21更新：启动总是报端⼝被占⽤，注释别名，另外server.ssl.key-password也不是必要的，可以注释起来#别名#server.ssl.key-alias=tomcat_https#密码#server.ssl.key-password=123456 测试与效果新增测试controllerpackage cn.huanzi.qch.springboothttps.controller;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HttpsController {@GetMapping("/hello")public String hello() {return "SpringBoot系列——启⽤https";}} 由于是⾃签名证书，浏览器不认可选择“⾼级”，选择继续访问即可成功访问客户端信任证书每次打开浏览器都阻⽌访问，很烦，因此需要导出.car⽂件证书，给客户端安装keytool -keystore d:/tomcat_https.keystore -export -alias tomcat_https -file d:/server.cer 双击安装，选择导⼊到受信任的跟证书颁发机构这样访问就不会再阻⽌了，但还是显⽰证书⽆效 http强制跳转https 注⼊TomcatServletWebServerFactory，监听http重定向到httpspackage cn.huanzi.qch.springboothttps.config;import org.apache.catalina.Context;import org.apache.catalina.connector.Connector;import org.apache.tomcat.util.descriptor.web.SecurityCollection;import org.apache.tomcat.util.descriptor.web.SecurityConstraint;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** http强制跳转https*/@Configurationpublic class Http2Https {@Value("${server.port}")private int sslPort;//https的端⼝@Value("${server.http-port}")private int httpPort;//http的端⼝@Beanpublic TomcatServletWebServerFactory servletContainerFactory() {TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {@Overrideprotected void postProcessContext(Context context) {//设置安全性约束SecurityConstraint securityConstraint = new SecurityConstraint();securityConstraint.setUserConstraint("CONFIDENTIAL");//设置约束条件SecurityCollection collection = new SecurityCollection();//拦截所有请求collection.addPattern("/*");securityConstraint.addCollection(collection);context.addConstraint(securityConstraint);}};Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");//设置将分配给通过此连接器接收到的请求的⽅案connector.setScheme("http");//true： http使⽤http, https使⽤https;//false： http重定向到https;connector.setSecure(false);//设置监听请求的端⼝号，这个端⼝不能其他已经在使⽤的端⼝重复，否则会报错connector.setPort(httpPort);//重定向端⼝号(⾮SSL到SSL)connector.setRedirectPort(sslPort);tomcat.addAdditionalTomcatConnectors(connector);return tomcat;}} 效果后记代码开源代码已经开源、托管到我的GitHub、码云：。

springboot配置多个请求服务代理的完整步骤

springboot配置多个请求服务代理的完整步骤springboot 配置服务代理有时候，我们可能有下边这样的需求：即，针对于分布式服务，我们会有多种业务接⼝服务，但是服务器上可能只要求开放⼀个服务的端⼝，⽐如上图的restA项⽬端⼝是对外开放的，但是restB项⽬端⼝并未对外开放，这样带来的问题就是，⽤户⽆法直接请求restB项⽬。

当然代理转发，有很多的解决办法，nginx 、zuul 等都可以实现，但是nginx 虽然简单，但是总要多装⼀个服务；zuul 配置较为⿇烦。

经过百度后，发现了⼀个特别简单的配置，即这⾥要说的东西，ServletRegistrationBean的注⼊，相当于是引⼊servlet ，没有具体看过。

下⾯写⼀下配置步骤：1、项⽬结构及介绍下⾯是我的项⽬结构，以下选中蓝⾊的项⽬为我们要配置的项⽬，其他的项⽬先忽略，是我们基于dubbo 和zookeeper 配置的时候⽤的。

项⽬已放到GitHub 上，下载项⽬关于这个项⽬的介绍是下边这样的，再配张图来介绍下：上图中关于suiteoneservice 、suitetwoservice、masterservice 项⽬是我们的服务接⼝发布⽅项⽬。

在这⾥我只是画出来，跟我们要配置的内容是⽆关的。

suiteone 、suitetwo 项⽬端⼝没有外放，⽤户不能直接访问，⽽master项⽬是可以直接访问的，所以⽤户是通过访问master 项⽬，再由master 项⽬对请求代理转发到这两个项⽬中。

2、具体配置步骤主要的配置很少，都在master 项⽬中。

（1）引⼊依赖：<dependency><groupId>org.mitre.dsmiley.httpproxy</groupId><artifactId>smiley-http-proxy-servlet</artifactId><version>1.7</version></dependency>（2）、配置⼀个配置类：该类可以参照下载下来的，master 项⽬中的配置。

springboot传参和获取参数方式

springboot传参和获取参数方式获取和传递参数是Spring Boot程序最常见的操作之一。

下面我们详细介绍Spring Boot的传参和获取参数方式：一、传递参数1. PathVariablePathVariable可以从请求URL中获取参数，并将参数值绑定到处理器方法参数上，以@PathVariable注解指定参数名称。

2. RequestParamRequestParam可以从请求参数中获取参数，将参数值绑定到处理器方法参数上，以@RequestParam注解指定即可。

3. RequestBodyRequestBody可以从请求参数中获取参数，并将获取的参数值绑定到处理器方法参数上，以@RequestBody注解指定即可。

4. ModelAttributeModelAttribute可以从请求参数中获取参数，并将获取的参数值绑定到处理器方法参数上，以@ModelAttribute注解指定即可。

二、获取参数1. @PathVariable方式从请求URL中获取参数，以@PathVariable注解指定参数名称，以实例：@PathVariable(“name”)进行指定，即使用name变量即可接受请求URL中的name参数。

2. @RequestParam方式从请求参数中获取参数，以@RequestParam注解指定参数名称，以实例：@RequestParam(“name”)进行指定，即使用name变量即可接受请求URL中的name参数。

3. @RequestBody方式从请求参数中获取参数，以@RequestBody注解指定，即可接受请求参数中的所有内容。

4. @CookieValue方式从Cookie中获取参数，以@CookieValue注解指定需要取值的Cookie 名称，即可接受Cookie中的指定值。

以上就是Spring Boot传参和获取参数的方式。

通过以上不同的获取参数方式，可以让我们更加便捷地处理参数，快速构建完整应用。

SpringBoot实现自定义参数注解

SpringBoot实现自定义参数注解要实现自定义参数注解，我们需要进行以下几个步骤：1.创建自定义注解类```String value( default "";```2.创建自定义参数解析器我们需要创建一个实现了HandlerMethodArgumentResolver接口的自定义参数解析器类。

该接口定义了用于解析控制器方法参数的方法。

在自定义参数解析器类中，我们可以使用自己的逻辑来解析参数。

例如，我们可以创建一个名为CustomParamResolver的自定义参数解析器类：```public class CustomParamResolver implements HandlerMethodArgumentResolverpublic boolean supportsParameter(MethodParameter parameter) returnparameter.getParameterAnnotation(CustomParam.class) != null;}public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws ExceptionCustomParam annotation =parameter.getParameterAnnotation(CustomParam.class);String value = annotation.value(;HttpServletRequest request =webRequest.getNativeRequest(HttpServletRequest.class);return request.getHeader(value);}```3.注册自定义参数解析器最后，我们需要在配置类中注册我们的自定义参数解析器。

springboot同时启用httphttps的配置方法

springboot同时启⽤httphttps的配置⽅法1. 启⽤HTTPS修改配置application.ymlserver:# port: 80port: 443ssl:enabled: truekey-store: /key_store.jkskey-store-password: key_store_pwd2. 添加http协议连接器增加JAVA配置@Beanpublic ServletWebServerFactory servletWebServerFactory() {TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();Connector connector = new Connector(TomcatServletWebServerFactory.DEFAULT_PROTOCOL);connector.setPort(80);tomcat.addAdditionalTomcatConnectors(connector);return tomcat;}扩展知识点：springboot如何配置，同时⽀持https和http使⽤jdk⾃带的keytools创建证书keytool -genkey -alias tomcat -keyalg RSA -keystore ./server.keystore按照提⽰完成操作输⼊密钥库⼝令:123456再次输⼊新⼝令:123456您的名字与姓⽒是什么?[Unknown]: kaibowang您的组织单位名称是什么?[Unknown]: yuxuelian您的组织名称是什么?[Unknown]: yuxuelian您所在的城市或区域名称是什么?[Unknown]: chengdu您所在的省/市/⾃治区名称是什么?[Unknown]: chengdushi该单位的双字母国家/地区代码是什么?[Unknown]: chinaCN=kaibowang, OU=yuxuelian, O=yuxuelian, L=chengdu, ST=chengdushi, C=china是否正确?[否]: y输⼊ <tomcat> 的密钥⼝令(如果和密钥库⼝令相同, 按回车):再次输⼊新⼝令:Warning:JKS 密钥库使⽤专⽤格式。

SpringBoot集成mqtt的多模块项目配置详解

SpringBoot集成mqtt的多模块项⽬配置详解⽬录前⾔开发⼯具及系统环境项⽬路径配置过程1.搭建⽗项⽬2.搭建⼦项⽬3.配置各个模块4.配置MQTT模块前⾔近期为了准备毕设，准备使⽤SpringBoot搭建mqtt后端，本篇主要记录了在IDEA中搭建SpringBoot mqtt的多模块项⽬的过程开发⼯具及系统环境IDE：IntelliJ IDEA 2020.2操作系统：Windows 10 2004Java Version：1.8SpringBoot Version：2.1.17.RELEASE项⽬路径Study|----study-common # 存放公共类|----study-mapper # mapper层|----study-mqtt # mqtt相关配置⽂件及接⼝|----study-service # service层|----study-serviceimpl # service的实现类|----study-web # web层|----pom.xml配置过程1. 搭建⽗项⽬在IDEA中新建⼀个SpringBoot⼯程这⾥我使⽤了阿⾥云的启动服务，正常使⽤可以直接⽤原本的启动服务根据你的需求选择Java版本，初始化类型并配置groupID和artifactId，我这⾥配置成我的域名的反写，并将artifactId定义成Study。

配置完成后单击Next这⼀步选择你需求的SpringBoot版本，我这⾥选择的是2.1.17.RELEASE，然后单击NEXT。

在这⼀步中不需要勾选任何依赖。

选择保存的路径，点击Finish完成创建。

删除不需要的⽂件。

将⽬录下的src/,HELP.md,mvnw,mvnw.cmd等⽂件全部删除（不包括.gitigore）⾄此，⽗项⽬⼀级已经创建完成，最后项⽬⽬录如下：2. 搭建⼦项⽬右键项⽬根⽬录->新建->新模块选择Maven，单击Next配置⽗项，项⽬名称以及构建坐标，完成后单击Finish。

springboot修改属性配置的三种方法

springboot修改属性配置的三种⽅法⼀、修改默认配置例1、spring boot 开发web应⽤的时候，默认tomcat的启动端⼝为8080，如果需要修改默认的端⼝，则需要在application.properties 添加以下记录：server.port=8888⼆、⾃定义属性配置在application.properties中除了可以修改默认配置，我们还可以在这配置⾃定义的属性，并在实体bean中加载出来。

1、在application.properties中添加⾃定义属性配置=samcom.sam.age=11com.sam.desc=magical sam2、编写Bean类，加载属性Sam类需要添加@Component注解，让spring在启动的时候扫描到该类，并添加到spring容器中。

第⼀种：使⽤spring⽀持的@Value()加载package com.sam.demo.conf;import org.springframework.beans.factory.annotation.Value;import ponent;/*** @author sam* @since 2017/7/15*/@Componentpublic class Sam {//获取application.properties的属性@Value("${}")private String name;@Value("${com.sam.age}")private int age;@Value("${com.sam.desc}")private String desc;//getter & setter}第⼆种：使⽤@ConfigurationProperties(prefix="") 设置前缀，属性上不需要添加注解。

package com.sam.demo.conf;import ponent;/*** @author sam* @since 2017/7/15*/@Component@ConfigurationProperties(prefix = "com.sam")public class Sam {private String name;private int age;private String desc;//getter & setter}三、⾃定义配置类在Spring Boot框架中，通常使⽤@Configuration注解定义⼀个配置类，Spring Boot会⾃动扫描和识别配置类，从⽽替换传统Spring框架中的XML配置⽂件。

Springboot跨域设置实例详解

Springboot跨域设置实例详解定义：跨域是指从⼀个域名的⽹页去请求另⼀个域名的资源1.原由公司内部有多个不同的⼦域，⽐如⼀个是 ,⽽应⽤是放在 , 这时想从去访问的资源就属于跨域本⼈是springboot菜鸟，但是做测试框架后端需要使⽤Springboot和前端对接，出现跨域问题，需要设置后端Response的Header.⾛了不少坑，在这总结⼀下以备以后使⽤2.使⽤场景浏览器默认不允许跨域访问，包括我们平时ajax也是限制跨域访问的。

产⽣跨域访问的情况主要是因为请求的发起者与请求的接受者1、域名不同；2、端⼝号不同如果⼀个⽹页可以随意地访问另外⼀个⽹站的资源，那么就有可能在客户完全不知情的情况下出现安全问题3.解决⽅案通过设置Access-Control-Allow-Origin来实现跨域访问4.具体解决@Configurationpublic class CorsConfig {private CorsConfiguration buildConfig() {CorsConfiguration corsConfiguration = new CorsConfiguration();corsConfiguration.addAllowedOrigin("*"); // 1corsConfiguration.addAllowedHeader("*"); // 2corsConfiguration.addAllowedMethod("*"); // 3return corsConfiguration;}@Beanpublic CorsFilter corsFilter() {UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();source.registerCorsConfiguration("/**", buildConfig()); // 4return new CorsFilter(source);}}后来改为Filter⽅式@Componentpublic class CorsFilter implements Filter {final static org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(CorsFilter.class);public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {HttpServletResponse response = (HttpServletResponse) res;HttpServletRequest reqs = (HttpServletRequest) req;response.setHeader("Access-Control-Allow-Origin","*");response.setHeader("Access-Control-Allow-Credentials", "true");response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");response.setHeader("Access-Control-Max-Age", "3600");response.setHeader("Access-Control-Allow-Headers", "x-requested-with");chain.doFilter(req, res);}public void init(FilterConfig filterConfig) {}public void destroy() {}}后来改为Filter⽅式@Componentpublic class CorsFilter implements Filter {final static org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(CorsFilter.class);public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {HttpServletResponse response = (HttpServletResponse) res;HttpServletRequest reqs = (HttpServletRequest) req;response.setHeader("Access-Control-Allow-Origin","*");response.setHeader("Access-Control-Allow-Credentials", "true");response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");response.setHeader("Access-Control-Max-Age", "3600");response.setHeader("Access-Control-Allow-Headers", "x-requested-with");chain.doFilter(req, res);}public void init(FilterConfig filterConfig) {}public void destroy() {}}⽹上很多资料都是教按以上⽅法设置，但是我这⾥就是设置不成功的。

SpringBootWebSocketSTOMP广播配置

SpringBootWebSocketSTOMP⼴播配置⽬录1. 前⾔WebSocket是⼀种在单个TCP连接上进⾏全双⼯通信的协议，常⽤于实时通信的场景。

在没有使⽤⾼层级线路协议的情况下，直接使⽤WebSocket是很难实现发布订阅的功能。

⽽STOMP是在WebSocket之上提供了⼀个基于帧的线路格式层，STOMP客户端可以同时作为⽣产者和消费者两种模式。

为发布订阅的功能提供了基础。

2. STOMP协议is a simple text-orientated messaging protocol. It defines an so that any of the available STOMP clients can communicate with any STOMP message broker to provide easy and widespread messaging interoperability among languages and platforms (the STOMP web site has a .⽂档地址：3. SpringBoot WebSocket集成SpringBoot集成WebSocket⾮常⽅便，只需要简单的三个步骤：导包、配置、提供接⼝3.1 导⼊websocket包compile('org.springframework.boot:spring-boot-starter-websocket')3.2 配置WebSocket第⼀步：创建WebSocketConfig类，通过@EnableWebSocketMessageBroker 启⽤代理⽀持的消息传递。

第⼆步：重写registerStompEndpoints和configureMessageBroker⽅法。

第三步：注册对外可访问的stomp端点、访问⽅式和连接跨域设置。

第四步：配置消息代理。

springbootbootcdn使用示例详解

springbootbootcdn使⽤⽰例详解应⽤：直接使⽤bootcdn提供的静态资源，不需要本地存储常⽤静态资源# layui.jshttps:///ajax/libs/layui/2.6.8/layui.jshttps:///ajax/libs/layui/2.6.8/layui.min.js# layui.css///layui@2.6.8/dist/css/layui.csshttps:///layui-v2.6.8/css/layui.css# jqueryhttps:///ajax/libs/jquery/3.6.0/jquery.jshttps:///ajax/libs/jquery/3.6.0/jquery.min.js# bootstraphttps:///ajax/libs/twitter-bootstrap/5.0.2/css/bootstrap-grid.csshttps:///ajax/libs/twitter-bootstrap/5.0.2/css/bootstrap-grid.min.css# reacthttps:///ajax/libs/react-is/0.0.0-experimental-6f3fcbd6f-20210730/cjs/react-is.development.jshttps:///ajax/libs/react-is/0.0.0-experimental-6f3fcbd6f-20210730/cjs/react-is.development.min.js# vuehttps:///ajax/libs/vue/3.2.0-beta.7/vue.cjs.jshttps:///ajax/libs/vue/3.2.0-beta.7/vue.cjs.min.js*********************⽰例***************配置⽂件cdn.propertieslayui=https:///ajax/libs/layui/2.6.8/layui.min.jsjquery=https:///ajax/libs/jquery/3.6.0/jquery.min.js***************前端页⾯index.html<!DOCTYPE html><html lang="en" xmlns:th=""><head><meta charset="UTF-8"><title>Title</title><script th:src="${application.jquery}"></script><script th:src="${yuijs}"></script><link rel="stylesheet" th:href="${yuicss}"><script>e('layer',function (){var layer=yer;$("#btn").click(function (){$("#1").html("⽠⽥李下<br>");layer.msg('hello')})})</script></head><body><div th:align="center"><span id="1" style="background-color: purple;font-size: large"></span><br><button id="btn" class="layui-btn">点击⼀下</button></div></body></html>*********************到此这篇关于springboot bootcdn使⽤的⽂章就介绍到这了,更多相关springboot bootcdn内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。