Python Java Android Django Web -> sulang357159@gmail.com

Orderly

1

@FixMethodOrder(MethodSorters.DEFAULT)

was cached in the local repository, resolution will not be reattempted until the update interval of nexus has elapsed or updates are forced

Solution: 删除本地jar包，rebuild

1

mvn -U clean install

Error: Could not find or load main com.xxx.xxx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<build>
    <sourceDirectory>${basedir}/src/main/kotlin</sourceDirectory>
    <testSourceDirectory>${basedir}/src/test/kotlin</testSourceDirectory>
    <resources>
        <resource>
            <directory>${basedir}/src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
    <testResources>
        <testResource>
            <directory>${basedir}/src/test/resources</directory>
            <filtering>true</filtering>
        </testResource>
    </testResources>
</build>

What’s Cache

Cache Memory也被称为Cache，是存储器子系统的组成部分，存放着程序经常使用的指令和数据，这就是Cache的传统定义。

从广义的角度上看，Cache是快设备为了缓解访问慢设备延时的预留的Buffer，从而可以在掩盖访问延时的同时，尽可能地提高数据传输率。

快和慢是一个相对概念，与微架构(Microarchitecture)中的 L1/L2/L3 Cache相比， DDR内存是一个慢速设备；在磁盘I/O系统中，DDR却是快速设备，在磁盘I/O系统中，仍在使用DDR内存作为磁介质的Cache。在一个微架构中，除了有L1/L2/L3 Cache之外，用于虚实地址转换的各级TLB，MOB( Memory Ordering Buffers)、在指令流水线中的ROB，Register File和BTB等等也是一种Cache。我们这里的Cache，是狭义 Cache，是CPU流水线和主存储器的 L1/L2/L3 Cache。

L2: MLC(Middle Level Cache)
L3: LLC(Last Level Cache)

缓存的组织形式

Reference

https://zhuanlan.zhihu.com/p/31422201
https://decodezp.github.io/2018/11/20/cachesize/

Reference

https://whoisnnamdi.com/the-growth-share-matrix-of-software-development/
https://zhuanlan.zhihu.com/p/53358012

认知资源

你是否有想认真掌握一门新技能，但一拿起各类技术书籍、文档，很快就放弃的经历？你又是否在做一些让别人“选择蛋糕”的事情？比如让别人阅读你自己编写的项目文档。

当你想要快速掌握一项技能的时候，你需要学会管理自己的认知资源。

学习方法

将你现在的技能分为三类：

• A - 还没有掌握，但需要掌握的
• B - 经过一定努力可以掌握的
• C - 已经掌握的

我们的目标其实是如何将AB的技能快速移动到C。在这个过程中我们会遇到两类典型问题：

• 没有进步
• 耗时太久

解决”没有进步”

第一类问题的根本原因在于你的认知资源不足以支撑技能的学习需求。我们不能要求自己有无限的认知资源，在资源极度有限的情况下，仍有两种解决策略：

第一种，将更多的需要掌握的技能放在A，将精力集中于少量的B类技能。但在日常工作中，需要掌握哪些技能，解决哪些问题，都不是自己可以安排的。对此，我们还有第二种策略。

第二种策略，就是将B中的技能分解为更小的粒度。这种策略，在有限的认知资源的情况下效果等同于一个需要处理多任务并发的CPU，上面运行的程序都采用了更加细粒度的锁机制，带来了程序性能的提升。

那么如何界定分解之后的技能足够“细”？Kathy给出了一个她的评判标准：从完全不会到十分熟练，最多经过3次练习，每次45-90分钟。

能满足上面的标准就可以认为分解到了合理的粒度。

解决”耗时太久”

程序员不但要学习很多技能，还需要快速学习。所以从A开始，我们最好能够绕过B直接到C。

关键点：高质量的例子

通过高质量的例子进行学习和模仿，有点类似机器学习一样，不断的进化。

当要学习某样特殊技术的时候，你是找官方的、正式的、长而无味的文档，还是去找一个精悍的例子？

当你能找到一个精确的示例来演示如何使用这样技术的时候，你几乎可以“瞬间”掌握这项技术。

你需要这些示例来让大脑自动地，潜意识地识别其中的模式。但现在的问题是，所有技术里又臭又长的文档很多，但短小精悍的示例很少。

所以是否可以利用社区的力量，将这些文档转换成一系列高质量的示例库呢？

Reference

https://www.youtube.com/watch?v=FKTxC9pl-WM
https://decodezp.github.io/2018/12/12/eng-talk1-fast-learn/#%E5%85%B3%E9%94%AE%E7%9A%84%E7%BC%BA%E5%A4%B1%E2%80%94%E2%80%94%E9%AB%98%E8%B4%A8%E9%87%8F%E7%9A%84%E4%BE%8B%E5%AD%90

CDC(Consumer Driven Contract)

Application Scenarios

Contract DSL(Domain-Specific Language)

• Groovy
• YAML
• Json

参考示例:
https://github.com/pact-foundation/pact-specification/tree/version-3

Producer

吧

定义测试Controller

1
2
3
4
5
6
7
8
9
10
11
12

@RestController
class OrderController {
    private val logger = LogManager.getLogger(OrderController::class.java)

    @GetMapping("/hello")
    fun hello(): ResponseEntity<Any> {
        logger.info("hello()")
        val user = User()
        user.name = "hello"
        return ResponseEntity(user, HttpStatus.OK)
    }
}

定义测试Controller的Contracts

在test的Resources下，新建contracts目录，定义一个contract文件，以json格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

{
  "provider": {
    "name": "Provider"
  },
  "consumer": {
    "name": "Consumer"
  },
  "interactions": [
    {
      "description": "",
      "request": {
        "method": "GET",
        "path": "/hello",
        "body": {
          "name": "hello"
        }
      },
      "response": {
        "status": 200,
        "body": {
          "name": "hello"
        }
      }
    }
  ],
  "metadata": {
    "pact-specification": {
      "version": "3.0.0"
    },
    "pact-jvm": {
      "version": "3.5.13"
    }
  }
}

定义测试基类ContractVerifierBase

通过配置build的插件spring-cloud-contract-maven-plugin使测试用例继承该类进行初始化操作

在test的com.example.base下，新建ContractVerifierBase.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import io.restassured.module.mockmvc.RestAssuredMockMvc;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.test.web.servlet.setup.StandaloneMockMvcBuilder;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
public class ContractVerifierBase {
    @Before
    public void setup() {
        StandaloneMockMvcBuilder standaloneMockMvcBuilder = MockMvcBuilders.standaloneSetup(
            new TestController(),
            new TestHelloController()
        );
        RestAssuredMockMvc.standaloneSetup(standaloneMockMvcBuilder);
    }
}

需要特别注意的是，这个ContractVerifierBase只能是.java文件，目前不支持Kotlin

pom.xml

Attention: SpringBoot version must be <= 2.0.7.RELEASE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-contract-verifier</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
     <plugins>
        <plugin>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-contract-maven-plugin</artifactId>
            <version>${spring-cloud-contract.version}</version>
            <extensions>true</extensions>
            <configuration>
                 <!--   配置用例的基类   -->
                <baseClassForTests>com.example.base</baseClassForTests>
                <!--<packageWithBaseClasses>com.example.contracts</packageWithBaseClasses>-->
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-contract-pact</artifactId>
                    <version>${spring-cloud-contract.version}</version>
                </dependency>
            </dependencies>
        </plugin>
     </plugins>
</build>

<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>

Maven spring-cloud-contract-pact Plugin

• packageWithBaseClasses: Defines a package where all the base classes reside. This setting takes precedence over baseClassForTests. The convention is such that, if you have a contract under (for example) src/test/resources/contract/foo/bar/baz/ and set the value of the packageWithBaseClasses property to com.example.base, then Spring Cloud Contract Verifier assumes that there is a BarBazBase class under the com.example.base package. In other words, the system takes the last two parts of the package, if they exist, and forms a class with a Base suffix.

Example

测试基类目录：/test/com/example/contacts，此时com.example.contracts

Contract路径：/test/resouces/controller/controller_craete_order.json

生成的Contract测试类 -> ControllerTest

默认继承的基类 -> ControllerBase

Contracs Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

{
  "provider": {
    "name": "Provider"
  },
  "consumer": {
    "name": "Consumer"
  },
  "interactions": [
    {
      "description": "",
      "request": {
        "method": "PUT",
        "path": "/fraudcheck",
        "queryParameters": "nonce=1",
        "headers": {
          "Content-Type": "application/vnd.fraud.v1+json"
        },
        "body": {
          "clientId": "1234567890",
          "loanAmount": 99999
        },
        "generators": {
          "body": {
            "$.clientId": {
              "type": "Regex",
              "regex": "[0-9]{10}"
            }
          }
        },
        "matchingRules": {
          "header": {
            "Content-Type": {
              "matchers": [
                {
                  "match": "regex",
                  "regex": "application/vnd\\.fraud\\.v1\\+json.*"
                }
              ],
              "combine": "AND"
            }
          },
          "body": {
            "$.clientId": {
              "matchers": [
                {
                  "match": "regex",
                  "regex": "[0-9]{10}"
                }
              ],
              "combine": "AND"
            }
          }
        }
      },
      "response": {
        "status": 200,
        "headers": {
          "Content-Type": "application/vnd.fraud.v1+json;charset=UTF-8"
        },
        "body": {
          "fraudCheckStatus": "FRAUD",
          "rejectionReason": "Amount too high"
        },
        "matchingRules": {
          "header": {
            "Content-Type": {
              "matchers": [
                {
                  "match": "regex",
                  "regex": "application/vnd\\.fraud\\.v1\\+json.*"
                }
              ],
              "combine": "AND"
            }
          },
          "body": {
            "$.fraudCheckStatus": {
              "matchers": [
                {
                  "match": "regex",
                  "regex": "FRAUD"
                }
              ],
              "combine": "AND"
            }
          }
        }
      }
    }
  ],
  "metadata": {
    "pact-specification": {
      "version": "3.0.0"
    },
    "pact-jvm": {
      "version": "3.5.13"
    }
  }
}

Reference

https://springframework.guru/using-spring-cloud-contract-for-consumer-driven-contracts/
https://martinfowler.com/articles/consumerDrivenContracts.html

Usage

Case: Hello

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@ControllerAdvice
class SystemErrorController {
    private val logger = LogManager.getLogger(SystemErrorController::class)

    @ExceptionHandler(Exception::class)
    fun handleError(ex: Exception): ResponseEntity<Any> {
        logger.error("handleError(): $ex")
        val error = Error(500, HttpStatus.INTERNAL_SERVER_ERROR.name)
        return ResponseEntity(error, HttpStatus.INTERNAL_SERVER_ERROR)
    }


    @ExceptionHandler(MethodArgumentNotValidException::class, MissingServletRequestParameterException::class)
    fun handleArgumentError(ex: Exception): ResponseEntity<Any> {
        logger.error("handleArgumentError(): $ex")
        val error = Error(ErrorCode.BODY_ARGUMENT_IS_INVALID.value, ex.message ?: "")
        return ResponseEntity(error, HttpStatus.BAD_REQUEST)
    }
}


//  Unit Testing
StandaloneMockMvcBuilder mockMvc = MockMvcBuilders.standaloneSetup(new OrderController()).setControllerAdvice(adviceController);
RestAssuredMockMvc.standaloneSetup(mockMvc);

What’ CORS - Cross-Origin Resource Sharing

Cross-Origin Resource Sharing (CORS) is a mechanism that uses additional HTTP headers to tell a browser to let a web application running at one origin (domain) have permission to access selected resources from a server at a different origin. A web application makes a cross-origin HTTP request when it requests a resource that has a different origin (domain, protocol, and port) than its own origin.

支持CORS请求的浏览器一旦发现ajax请求跨域，会对请求做一些特殊处理，对于已经实现CORS接口的服务端，接受请求，并做出回应。

有一种情况比较特殊，如果我们发送的跨域请求为“非简单请求”，浏览器会在发出此请求之前首先发送一个请求类型为OPTIONS的“预检请求”，验证请求源是否为服务端允许源，这些对于开发这来说是感觉不到的，由浏览器代理。

总而言之，客户端不需要对跨域请求做任何特殊处理。

CORS存在的意义

为了保证用户信息的安全，所有的浏览器都遵循同源策略。

凡是发送请求url的协议、域名、端口三者之间任意一与当前页面地址不同，即为跨域(不同源)

• 域名(domain)
• 协议(protocol)
• 端口(porot)

同源策略的限制：

• 无法获取非同源的Cookie、LocalStorage、SessionStorage等
• 无法获取非同源的dom
• 无法向非同源的服务器发送ajax请求

CORS的请求Header

• origin：表明预检请求或实际请求的源站URL，总是会带上
• Access-Control-Request-Method：实际请求所使用的HTTP方法告诉服务器
• Access-Control-Request-Headers：将实际请求所携带的首部字段告诉服务器

CORS的响应Header

• Access-Control-Allow-Origin：这个请求头一般会被服务器端返回，它的值代表了哪些域名你有权可以访问(注：对于携带身份凭证的请求不可使用通配符*)
• Access-Control-Expose-Headers：指定XMLRequest的getResourceHeader可以访问的响应头
• Access-Control-Max-Age：指定preflight请求的结果能够被缓存多久
• Access-Control-Allow-Credentials：是否允许浏览器读取response的内容；
• Access-Control-Allow-Methods：指明实际请求允许所使用的HTTP方法
• Access-Control-Allow-Headers：指明实际请求中允许携带的首部字段

什么是简单请求？

请求方法属于以下类型：

• HEAD
• GET
• POST

Headers不超出以下字段：

• Accept
• Accept-Language
• Content-Language
• Content-Type: application/x-www-form-urlencoded、 multipart/form-data、text/plain
• DPR
• Downlink
• Save-Data
• Viewport-Width
• Width

不满足上述要求的在发送正式请求前都要先发送一个预检请求，预检请求以OPTIONS方法发送，浏览器通过请求方法和请求头能够判断是否发送预检请求。

服务器端在处理OPTIONS请求的时候需要注意：需要预检请求时，浏览器会发出两次请求，一次OPTIONS，一次POST。两次都返回了数据。如果服务端逻辑复杂一些，比如去数据库查找数据，从web层、service到数据库这段逻辑就会走两遍，浏览器会两次拿到相同的数据。如果是OPTIONS请求，在设置完跨域请求响应头后就不走后面的逻辑直接返回。

Reference

重点阅读：https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
https://zhuanlan.zhihu.com/p/29980092
https://juejin.im/post/5a7359876fb9a0634a38e389

Introduction

Spring WebFlux is supported on Tomcat, Jetty, Servlet 3.1+ containers, as well as on non-Servlet runtimes such as Netty and Undertow.

Spring Boot defaults to Netty, because it is more widely used in the asynchronous, non-blocking space and lets a client and a server share resources.

What’s Undertow

Undertow is a flexible performant web server written in java, providing both blocking and non-blocking API’s based on NIO.

Undertow has a composition based architecture that allows you to build a web server by combining small single purpose handlers. The gives you the flexibility to choose between a full Java EE servlet 4.0 container, or a low level non-blocking handler, to anything in between.

Undertow is designed to be fully embeddable, with easy to use fluent builder APIs. Undertow’s lifecycle is completely controlled by the embedding application.

Undertow is sponsored by JBoss and is the default web server in the Wildfly Application Server.

http://undertow.io/

Usage

Paramter

• server.undertow.io-threads=16

  设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
  不要设置过大，如果过大，启动项目会报错：打开文件数过多

• server.undertow.worker-threads=256

  阻塞任务线程池, 当执行类似servlet请求阻塞IO操作, undertow会从这个线程池中取得线程
  它的值设置取决于系统线程执行任务的阻塞系数，默认值是IO线程数*8

• server.undertow.buffer-size=1024

  以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
  每块buffer的空间大小,越小的空间被利用越充分，不要设置太大，以免影响其他应用，合适即可

• server.undertow.buffers-per-region=1024

  每个区分配的buffer数量 , 所以pool的大小是buffer-size * buffers-per-region

• server.undertow.direct-buffers=true

  是否分配的直接内存(NIO直接分配的堆外内存)

Error

UT000128: Remote peer closed connection before all data could be read