Spring boot配置属性[server]

server配置

  • server.address
    指定server绑定的地址
  • server.compression.enabled
    是否开启压缩,默认为false.
  • server.compression.excluded-user-agents
    指定不压缩的user-agent,多个以逗号分隔,默认值为:text/html,text/xml,text/plain,text/css
  • server.compression.mime-types
    指定要压缩的MIME type,多个以逗号分隔.
  • server.compression.min-response-size
    执行压缩的阈值,默认为2048
  • server.context-parameters.[param name]
    设置servlet context 参数
  • server.context-path
    设定应用的context-path.
  • server.display-name
    设定应用的展示名称,默认: application
  • server.jsp-servlet.class-name
    设定编译JSP用的servlet,默认: org.apache.jasper

.servlet.JspServlet)

  • server.jsp-servlet.init-parameters.[param name]
    设置JSP servlet 初始化参数.
  • server.jsp-servlet.registered
    设定JSP servlet是否注册到内嵌的servlet容器,默认true
  • server.port
    设定http监听端口
  • server.servlet-path
    设定dispatcher servlet的监听路径,默认为: /

cookie、session配置

  • server.session.cookie.comment
    指定session cookie的comment
  • server.session.cookie.domain
    指定session cookie的domain
  • server.session.cookie.http-only
    是否开启HttpOnly.
  • server.session.cookie.max-age
    设定session cookie的最大age.
  • server.session.cookie.name
    设定Session cookie 的名称.
  • server.session.cookie.path
    设定session cookie的路径.
  • server.session.cookie.secure
    设定session cookie的“Secure” flag.
  • server.session.persistent
    重启时是否持久化session,默认false
  • server.session.timeout
    session的超时时间
  • server.session.tracking-modes
    设定Session的追踪模式(cookie, url, ssl).

ssl配置

  • server.ssl.ciphers
    是否支持SSL ciphers.
  • server.ssl.client-auth
    设定client authentication是wanted 还是 needed.
  • server.ssl.enabled
    是否开启ssl,默认: true
  • server.ssl.key-alias
    设定key store中key的别名.
  • server.ssl.key-password
    访问key store中key的密码.
  • server.ssl.key-store
    设定持有SSL certificate的key store的路径,通常是一个.jks文件.
  • server.ssl.key-store-password
    设定访问key store的密码.
  • server.ssl.key-store-provider
    设定key store的提供者.
  • server.ssl.key-store-type
    设定key store的类型.
  • server.ssl.protocol
    使用的SSL协议,默认: TLS
  • server.ssl.trust-store
    持有SSL certificates的Trust store.
  • server.ssl.trust-store-password
    访问trust store的密码.
  • server.ssl.trust-store-provider
    设定trust store的提供者.
  • server.ssl.trust-store-type
    指定trust store的类型.

tomcat

  • server.tomcat.access-log-enabled
    是否开启access log ,默认: false)
  • server.tomcat.access-log-pattern
    设定access logs的格式,默认: common
  • server.tomcat.accesslog.directory
    设定log的目录,默认: logs
  • server.tomcat.accesslog.enabled
    是否开启access log,默认: false
  • server.tomcat.accesslog.pattern
    设定access logs的格式,默认: common
  • server.tomcat.accesslog.prefix
    设定Log 文件的前缀,默认: access_log
  • server.tomcat.accesslog.suffix
    设定Log 文件的后缀,默认: .log
  • server.tomcat.background-processor-delay
    后台线程方法的Delay大小: 30
  • server.tomcat.basedir
    设定Tomcat的base 目录,如果没有指定则使用临时目录.
  • server.tomcat.internal-proxies
    设定信任的正则表达式,默认:“10\.\d{1,3}\.\d{1,3}\.\d{1,3}| 192\.168\.\d{1,3}\.\d{1,3}| 169\.254\.\d{1,3}\.\d{1,3}| 127\.\d{1,3}\.\d{1,3}\.\d{1,3}| 172\.1[6-9]{1}\.\d{1,3}\.\d{1,3}| 172\.2[0-9]{1}\.\d{1,3}\.\d{1,3}|172\.3[0-1]{1}\.\d{1,3}\.\d{1,3}”
  • server.tomcat.max-http-header-size
    设定http header的最小值,默认: 0
  • server.tomcat.max-threads
    设定tomcat的最大工作线程数,默认为: 0
  • server.tomcat.port-header
    设定http header使用的,用来覆盖原来port的value.
  • server.tomcat.protocol-header
    设定Header包含的协议,通常是 X-Forwarded-Proto,如果remoteIpHeader有值,则将设置为RemoteIpValve.
  • server.tomcat.protocol-header-https-value
    设定使用SSL的header的值,默认https.
  • server.tomcat.remote-ip-header
    设定remote IP的header,如果remoteIpHeader有值,则设置为RemoteIpValve
  • server.tomcat.uri-encoding
    设定URI的解码字符集.

undertow

    • server.undertow.access-log-dir
      设定Undertow access log 的目录,默认: logs
    • server.undertow.access-log-enabled
      是否开启access log,默认: false
    • server.undertow.access-log-pattern
      设定access logs的格式,默认: common
    • server.undertow.accesslog.dir
      设定access log 的目录.
    • server.undertow.buffer-size
      设定buffer的大小.
    • server.undertow.buffers-per-region
      设定每个region的buffer数
    • server.undertow.direct-buffers
      设定堆外内存
    • server.undertow.io-threads
      设定I/O线程数.
    • server.undertow.worker-threads
      设定工作线程数

HTTP状态码(记录)

HTTP状态码总的分为五类:

1开头:信息状态码

2开头:成功状态码

3开头:重定向状态码

4开头:客户端错误状态码

5开头:服务端错误状态码

 1XX:信息状态码

状态码 含义 描述
100 继续 初始的请求已经接受,请客户端继续发送剩余部分
101 切换协议 请求这要求服务器切换协议,服务器已确定切换

 2XX:成功状态码

状态码 含义 描述
200 成功 服务器已成功处理了请求
201 已创建 请求成功并且服务器创建了新的资源
202 已接受 服务器已接受请求,但尚未处理
203 非授权信息 服务器已成功处理请求,但返回的信息可能来自另一个来源
204 无内容 服务器成功处理了请求,但没有返回任何内容
205 重置内容 服务器处理成功,用户终端应重置文档视图
206 部分内容 服务器成功处理了部分GET请求

3XX:重定向状态码

状态码 含义 描述
300 多种选择 针对请求,服务器可执行多种操作
301 永久移动 请求的页面已永久跳转到新的url
302 临时移动 服务器目前从不同位置的网页响应请求,但请求仍继续使用原有位置来进行以后的请求
303 查看其他位置 请求者应当对不同的位置使用单独的GET请求来检索响应时,服务器返回此代码
304 未修改 自从上次请求后,请求的网页未修改过
305 使用代理 请求者只能使用代理访问请求的网页
307 临时重定向 服务器目前从不同位置的网页响应请求,但请求者应继续使用原有位置来进行以后的请求

4XX:客户端错误状态码

状态码 含义 描述
400 错误请求 服务器不理解请求的语法
401 未授权 请求要求用户的身份演验证
403 禁止 服务器拒绝请求
404 未找到 服务器找不到请求的页面
405 方法禁用 禁用请求中指定的方法
406 不接受 无法使用请求的内容特性响应请求的页面
407 需要代理授权 请求需要代理的身份认证
408 请求超时 服务器等候请求时发生超时
409 冲突 服务器在完成请求时发生冲突
410 已删除 客户端请求的资源已经不存在
411 需要有效长度 服务器不接受不含有效长度表头字段的请求
412 未满足前提条件 服务器未满足请求者在请求中设置的其中一个前提条件
413 请求实体过大 由于请求实体过大,服务器无法处理,因此拒绝请求
414 请求url过长 请求的url过长,服务器无法处理
415 不支持格式 服务器无法处理请求中附带媒体格式
416 范围无效 客户端请求的范围无效
417 未满足期望 服务器无法满足请求表头字段要求

 

5XX:服务端错误状态码

状态码 含义 描述
500 服务器错误 服务器内部错误,无法完成请求
501 尚未实施 服务器不具备完成请求的功能
502 错误网关 服务器作为网关或代理出现错误
503 服务不可用 服务器目前无法使用
504 网关超时 网关或代理服务器,未及时获取请求
505 不支持版本 服务器不支持请求中使用的HTTP协议版本

spring-cloud搭建ribbon(负载均衡)

Spring cloud配置Ribbon用于负载君和,如果要在细节上配置更多,那么需要阅读一下官方文档。

* RoundRobinRule:轮询
* RandomRule:随机
* AvailabilityFilteringRule: 会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,以及并发的连接数量
*      超过阈值的服务,然后对剩余的服务列表按照轮询策略进行访问;
* WeightedResponseTimeRule: 根据平均响应时间计算所有服务的权重,响应时间越快,服务权重越大,被选中的机率越高;
*      刚启动时,如果统计信息不足,则使用RoundRobinRule策略,等统计信息足够时,会切换到WeightedResponseTimeRule
* RetryRule: 先按照RoundRobinRule的策略获取服务,如果获取服务失败,则在指定时间内会进行重试,获取可用的服务;
* BestAvailableRule: 会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务;
* ZoneAvoidanceRule: 默认规则,复合判断server所在区域的性能和server的可用性选择服务器;

首先maven文件:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.test</groupId>
    <artifactId>router</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>router</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.M3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

配置文件:

server:
  address: 127.0.0.1
  port: 7001
  undertow:
    io-threads: 19 # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    worker-threads: 24 # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    buffer-size: 1024 # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    direct-buffers: true # 是否分配的直接内存
    always-set-keep-alive: true #socket-binding="http",保持长连接

spring:
  application:
    name: router-server
  profiles:
    active: test
  cloud:
    loadbalancer:
      retry:
        enabled: true #重试机制开启为true,关闭为false

eureka:
  instance:
    appname: router-server
    virtual-host-name: router-server
    secure-virtual-host-name: router-server
    instance-id: ${server.address}:router-server-peer:${server.port}
    hostname: localhost
#    non-secure-port: 6001 #非安全通信端口
#    non-secure-port-enabled: true #是否启用非安全端口接受请求
#    secure-port: 6444 #安全通信端口
#    secure-port-enabled: true #是否启用安全端口接受请求
    prefer-ip-address: false #是否优先使用IP地址作为主机名的标识,默认false
    lease-renewal-interval-in-seconds: 30 #eureka节点定时续约时间,默认30
    lease-expiration-duration-in-seconds: 90 #eureka节点剔除时间,默认90
  client:
    register-with-eureka: true #将自己注册到eureka注册中心,单节点关闭
    fetch-registry: true #从注册中心获取注册信息,单节点关闭
    registry-fetch-interval-seconds: 30 #从注册中心获取注册信息的时间间隔
    eureka-server-connect-timeout-seconds: 15
    eureka-server-read-timeout-seconds: 10
    service-url:
      defaultZone: http://${eureka.instance.hostname}:7000/eureka/ #注册到另外两个节点,实现集群

ribbon:
  eureka:
    enabled: true

注解开启服务:

@EnableEurekaClient
@SpringBootApplication
public class RouterApplication {

    public static void main(String[] args) {
        SpringApplication.run(RouterApplication.class, args);
    }

}

写一个RestTemplate服务层,用于公共接口转发:

package com.test.router.system.service;

import com.test.router.system.core.BaseService;
import com.test.router.system.core.ResultResp;
import com.test.router.system.service.resources.IAPIDispatcherService;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.Map;

@Service
public class APIDispatcherServiceImpl extends BaseService implements IAPIDispatcherService {

    @Resource
    private RestTemplate restTemplate;


    @Override
    public ResultResp<Map<String, Object>> getForObject(String name, Object... uriVariables) {
        return restTemplate.getForObject("http://api-server/" + name, ResultResp.class);
    }

    @Override
    public ResultResp<Map<String, Object>> postForObject(String name, Map<String, Object> body) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<Map<String, Object>> data = new HttpEntity<>(body,headers);

        ResponseEntity<ResultResp> resp = restTemplate.postForEntity("http://api-server/" + name , data, ResultResp.class);
        return resp.getBody();
    }

    @Override
    public ResultResp<Map<String, Object>> putForObject(String name, Integer id, Map<String, Object> body) {
        HttpEntity<Map<String, Object>> data = new HttpEntity<>(body);
        ResponseEntity<ResultResp> resp = restTemplate.exchange("http://api-server/" + name + "/{1}", HttpMethod.PUT, data, ResultResp.class, id);
        return resp.getBody();
    }

    @Override
    public ResultResp<Map<String, Object>> deleteForObject(String name, Integer id) {
        ResponseEntity<ResultResp> resp = restTemplate.exchange("http://api-server/" + name + "/{1}", HttpMethod.PUT, null, ResultResp.class, id);
        return resp.getBody();
    }
}

最后需要一个控制器,用于转发使用:

package com.test.router.app.v1;

import com.test.router.app.base.BaseV1Controller;
import com.test.router.constant.Constant;
import com.test.router.system.base.IDefaultRestController;
import com.test.router.system.core.ResultResp;
import com.test.router.system.model.http.Request;
import com.test.router.system.service.resources.IAPIDispatcherService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

@RestController
public class TestController extends BaseV1Controller implements IDefaultRestController {


    @Resource
    private IAPIDispatcherService dispatcherService;

    /**
     * http://127.0.0.1:7001/v1/router?name=v2/test&namespace=api&user=avc
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/router", method = RequestMethod.GET)
    @Override
    public ResultResp<Map<String, Object>> doGet(HttpServletRequest request, HttpServletResponse response) {
        String namespace = request.getParameter("namespace");
        String name = request.getParameter("name");

        if (Constant.NAMESPACE_API.equals(namespace)) {
            Map<String, String> args = this.initUriVariables(name, request);
            StringBuffer sb = new StringBuffer();
            if (name.lastIndexOf("?") == -1) {
                name += "?";
            }
            sb.append(name);
            args.forEach((k, v) -> {
                sb.append(k).append("=").append(v).append("&");
            });
            return dispatcherService.getForObject(sb.toString(), null);
        }

        return new ResultResp<>();
    }

    /**
     * http://127.0.0.1:7001/v1/router?user=avc
     *
     *
     * {
     *     "header":{
     *         "namespace":"api",
     *         "name":"v2/test"
     *     },
     *     "payload":{
     *         "username":"张三",
     *         "age":15
     *     }
     * }
     * @param body
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/router", method = RequestMethod.POST)
    @Override
    public ResultResp<Map<String, Object>> doPost(@RequestBody Request<Map<String, Object>> body, HttpServletRequest request, HttpServletResponse response) {
        String namespace = body.getHeader().getNamespace();
        String name = body.getHeader().getName();

        if (Constant.NAMESPACE_API.equals(namespace)) {
            Map<String, String> args = this.initUriVariables(name, request);
            StringBuffer sb = new StringBuffer();
            if (name.lastIndexOf("?") == -1) {
                name += "?";
            }
            sb.append(name);
            args.forEach((k, v) -> {
                sb.append(k).append("=").append(v).append("&");
            });
            return dispatcherService.postForObject(sb.toString(), body.getPayload());
        }

        return new ResultResp<>();
    }

    @Override
    public ResultResp<Map<String, Object>> doPut(@PathVariable Integer id, @RequestBody Request<Map<String, Object>> obj, HttpServletRequest request, HttpServletResponse response) {
        return null;
    }

    @Override
    public ResultResp<Map<String, Object>> doDelete(@PathVariable Integer id, HttpServletRequest request, HttpServletResponse response) {
        return null;
    }
}

这样子基本上完成,主要使用浏览器打开http://127.0.0.1:7001/v1/router?name=v2/test&namespace=api&user=avc,就会根据name对应的值去获取api-service的对应的接口。

更多请参阅:

https://cloud.spring.io/spring-cloud-static/spring-cloud-netflix/2.2.0.RC1/reference/html/#spring-cloud-ribbon

spring-cloud搭建EurekaServer

Spring cloud配置EurekaServer很简单,如果要在细节上配置更多,那么需要阅读一下官方文档。

首先是maven:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.test</groupId>
    <artifactId>server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>server</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.M3</spring-cloud.version>
    </properties>

    <dependencies>
        <!--        <dependency>-->
        <!--            <groupId>org.springframework.cloud</groupId>-->
        <!--            <artifactId>spring-cloud-bus</artifactId>-->
        <!--        </dependency>-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

其次就是配置:

server:
  address: 127.0.0.1
  port: 7000
  undertow:
    io-threads: 19
    worker-threads: 24
    buffer-size: 1024
    direct-buffers: true
    always-set-keep-alive: true

spring:
  application:
    name: eureka-server
  profiles:
    active: test


eureka:
  instance:
    appname: eureka-server
    virtual-host-name: eureka-server
    secure-virtual-host-name: eureka-server
#    non-secure-port: 6000
#    non-secure-port-enabled: true
#    secure-port: 6443
#    secure-port-enabled: true
    lease-renewal-interval-in-seconds: 15
    lease-expiration-duration-in-seconds: 45
    instance-id: ${server.address}:eureka-server-peer:${server.port}
    hostname: localhost
  client:
    register-with-eureka: true
    fetch-registry: true
    registry-fetch-interval-seconds: 30
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 1000

最后就是注解开启:

package com.test.server;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;


@EnableEurekaServer
@SpringBootApplication
public class ServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
    }

}

使用浏览器打开http://127.0.0.1:7000就可以看到效果了。

 

1111213141532
 
Copyright © 2008-2021 lanxinbase.com Rights Reserved. | 粤ICP备14086738号-3 |