发表更新Spring / Spring Cloud21 分钟读完 (大约3175个字)

Spring Cloud(二十一)：Gateway 元数据,超时,跨域,HTTPS,监控,问题定位

Spring Cloud Gateway 网关除了核心的路由判断表达式（predicate ：有的译为谓词）和过滤器外，还有一些其它的设置，以便于可以更好的配置和应用 Gateway。

例如，元数据配置，超时处理，跨域处理，HTTPS 安全配置，监控/指标 收集，问题定位等。可以添加一些全局配置，可以收集健康数据，便于快速定位问题等等。

阅读更多
发表更新Spring / Spring Cloud1 小时读完 (大约12383个字)

Spring Cloud(二十)：Gateway 路由匹配表达式工厂,过滤器工厂,全局过滤器,HTTP头过滤器

Spring Cloud Gateway 项目提供了一个基于 Spring 生态体系构建的 API 网关，包括：Spring 5，Spring Boot 2。

Spring Cloud Gateway 旨在提供一种简单而有效的方试将前端请求 URI 路由到后端服务的接口，它还提供了其它的附加实用的功能，例如：安全性，监控/指标，可伸缩性等。

阅读更多
发表更新Spring / Spring Cloud29 分钟读完 (大约4347个字)

Spring Cloud(十九)：Gateway 特性,述语,自动配置与简单应用

即将开发的新平台在网关组件上选择了 Gateway，Spring 官方主推 Gateway。Zuul 1 虽然很成熟，但不再维护，Zuul 2 已闭源。

网关组件，不管是 Zuul 还是 Gateway，其核心技术脱离不了 代理请求 和 过滤器。本篇根据 Spring Cloud Gateway 官方文档对其功能，配置，应用进行详细描述。

阅读更多
发表更新Go 基础1 分钟读完 (大约186个字)

Go 基础：数组（array）数据类型

数组

Go 数组

示例

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

import "fmt"

// 数组定义
var arr []int

func main() {

	// 指定长度，并赋初始值
	array1 := [3]int{1, 2, 3}
	fmt.Println(array1)

	// 不指定长度，赋初始值
	array2 := [...]float64{1.2, 2.1, 3.2, 4.3}
	fmt.Println(array2)
	fmt.Println(len(array2))

	// 指定长度，按索引赋初始值，没有指明索引的元素值为类型的默认值
	array3 := [3]int{1: 1, 2: 3}
	fmt.Println(array3)

	// 不指定长茺，按索引赋初始值，没有指明索引的元素值为类型的默认值
	array4 := [...]int{1: 1, 2: 2, 4: 6}
	fmt.Println(array4, len(array4))

	array5 := [...]int{1, 2, 3}
	// 取值
	b := array5[0]
	fmt.Println(b)
	// 遍历
	for i, v := range array5 {
		fmt.Println("i = ", i, "v = ", v)
	}

	array6 := [...]int{1, 2, 3}
	// 长度
	arlen := len(array6)
	fmt.Println(arlen)
	// 遍历
	for i := 0; i < len(array6); i++ {
		fmt.Println("i=", i, "v=", array6[i])
	}
}
发表更新Go 基础12 分钟读完 (大约1837个字)

Go 基础：字符与字符串（string）数据类型

字符与字符串

Go 内置两种字符类型：

  • 一种是 byte 的字节类类型（byte 是 uint 的别名）
  • 另一种是表示 Unicode 编码的字符 rune。rune 在 Go 内部是 int32类型的别名，占用 4 个字节。

Go 语言默认的字符编码是 UTF-8 类型，如果需要特殊的编码转换，则使用 Unicode/UTF-8 标准包。

Go 语言将字符串作为一种原生的基本数据类型，字符串初始化可以使用 字符串字面量。

  • 字面量：用于表达源代码中一个固定值的符号，源于 C 语言中的称呼，其它语言有称为常量。

  • 字符串字面量（stringliteral）是指双引号引住的一系列字符，双引号中可以没有字符，可以只有一个字符，也可以有很多个字符。

字符串是不可变值类型，内部用指针指向 UTF-8 字节数组

  • 默认值是空字符串 ""。
  • 可以用索引号访问字符串的字节，如 str[i]。
  • 不能用序号获取字节元素指针，如 &str[i] 是非法的。
  • 不可变类型，无法修改字节数组的值。
  • 字节数组尾部不包含 NULL。

字符串类型底层是一个二维的数据结构，一个是指针指向字节数组的起点，另一个是长度。例如：

1
2
3
4
type stringStruct struct {
    str unsafe.Pointer
    len int
}

字符串声明

所有类型声明都是一样的。

  1. 显示完整声明

    1
    var a = "hello, word"

  2. 短类型声明：:= 只能出现在函数内（包括方法内），只是 Go 编译器自动进行数据类型推断。

    Go 支持多个类型变量同时声明并赋值，但不建议这么使用，不易阅读

    1
    2
    a := "hello"
    a, b := "hello", "world"

字符串处理

使用索引访问字节

字符串是常量，可以通过类似数组的索引访问其字节单元，但是不能修改某个字节的
值。例

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

import "fmt"

var a = "hello,world"

var b = "hello,世界!"

func main() {

	// 访问字符串的字节单元
	b := a[0]
	fmt.Println(b)            // 104
	fmt.Println(a[1])         // 101
	fmt.Println(string(a[2])) // l

	c := "abc"
	fmt.Println(c[0] == '\x61', c[1] == 'b') //true true
}

不做转义处理

使用 ` 定义不做转义处理的原始字符串，支持跨行

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
	str2 := `ab\r\n\x00c`
	fmt.Println(str2)
}
// 输出结果：ab\r\n\x00c

连符串跨行连接

连符串使用 + 符号来连接，跨行连接的 + 必须在上一行的结尾，否则会报错。

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

import "fmt"

func main() {
	str3 := "hello, " +	"world"
	fmt.Println(str3)

	str4 := "hello, " +	
		"world"
	fmt.Println(str4)
}
// 输出结果：
// hello, world
// hello, world

获取字符串子串

因字符串底层是个二维的数据结构，所以可以使用索引 和 长度（单位：字节） 来获取字符串的子串。

**注意：**中文是 三个字节 表示一个汉字，如果长度不是 3 的整数倍就会显示乱码。

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

import "fmt"

func main() {
	str5 := "hello, world"
	fmt.Println(str5[0:4]) // 指定从索引0开始, 4个字节
	fmt.Println(str5[1:]) // 索引1开始, 到结尾
	fmt.Println(str5[:4]) // 默认人0开始, 4个字节
    
    str6 := "中国人民共和国"
	fmt.Println(str6[0:3])
	fmt.Println(str6[3:])
	fmt.Println(str6[:6])
}
// 输出结果：
// hell
// ello, world
// hell
// 中
// 国人民共和国
// 中国

单引号表示Unicode

Go 源码采用的是 UTF-8 的编码方式，UTF-8 的字符占用的字节数可以有 1~4 个字节，Rune 字符常量使用 ''将其括住。

支持 \uFFFF、\U7FFFFFFF、\xFF 格式， 对应 rune 类型，UCS-4。

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

import "fmt"

func main() {
	fmt.Printf("%T\n", 'a')
	var str7, str8 rune = '\u6211', '们' // 定义为 run 类型
	fmt.Println(str7 == '我', string(str8) == "\xe4\xbb\xac")
}
// 输出结果：
// int32  (rune 是 int32 的别名)
// true true

修改字符串

要修改字符串，可先将其转换成 []rune 或 []byte

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

import "fmt"

func main() {
	str9 := "hello"
	str10 := []byte(str9) // 转换成 []byte
	str10[1] = 'H'
	fmt.Println(string(str10))

	str11 := "电脑"
	str12 := []rune(str11) // 转换成 []rune
	str12[1] = '话'
	fmt.Println(string(str12))
}
// 输出结果：
// hHllo
// 电话

循环遍历字符串

有两种方式，但都是基于 for 循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
	str13 := "hello,word"
	for i, v := range str13 {  // i 是索引，v 是值
		fmt.Println(i, string(v))
	}
	fmt.Println(".................................")
	for i := 0; i < len(str13); i++ {
		fmt.Println(i, string(str13[i]))
	}
}

strings处理

strings 是 Go 自带的字符串工具类。

判断开始字符串

strings.HasPrefix(src, dest)，返回 bool 值

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

import (
	"fmt"
	"strings"
)

func main() {
	str := "hello,world"

	res0 := strings.HasPrefix(str, "http")
	res01 := strings.HasPrefix(str, "hello")

	fmt.Println(res0) // false
	fmt.Println(res01) // true
}

判断结尾字符串

strings.HasPrefix(src, dest)，返回 bool值

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

import (
	"fmt"
	"strings"
)

func main() {
	str := "hello,world"

    res2 := strings.HasSuffix(str, "world")
	res3 := strings.HasSuffix(str, "word")

	fmt.Println("res2 =", res2)
	fmt.Println("res3 =", res3)
}

判断字符首次出现的索引位

strings.Index(src, dest)，返回 int值

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

import (
	"fmt"
	"strings"
)

func main() {
	str := "hello,world"

	num1 := strings.Index(str, "l")
	num2 := strings.Index(str, "o")
	num3 := strings.Index(str, "i")
	fmt.Println("num1 =", num1) // 2
	fmt.Println("num2 =", num2)  // 4
	fmt.Println("num3 =", num3)  // -1
}

判断字符最后出现的索引位

strings.LastIndex(src, dest)，返回 int值

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

import (
	"fmt"
	"strings"
)

func main() {
	str := "hello,world"

	num4 := strings.LastIndex(str, "l")
	num5 := strings.LastIndex(str, "o")
	num6 := strings.LastIndex(str, "i")
	fmt.Println("num4 =", num4) // 9
	fmt.Println("num5 =", num5) // 7
	fmt.Println("num6 =", num6) // -1
}

字符串替换

  • Replace(s, old, new string, n int) string：指定替换次数
  • ReplaceAll(s, old, new string) string：替换所有，实际调上面的方法，n 传的是 -1，表示不限制次数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
	"fmt"
	"strings"
)

func main() {
	str1 := "hello,world, world"
	res5 := strings.Replace(str1, "h", "H", 1)
	res6 := strings.Replace(str1, "o", "O", 2)
	res7 := strings.ReplaceAll(str1, "l", "L")
	fmt.Println("res5 =", res5)
	fmt.Println("res6 =", res6)
	fmt.Println("res7 =", res7)
}

// 输出结果：
// Hello,world, world
// hellO,wOrld, world
// heLLo,worLd, worLd

求重复出现的次数

Count(s, substr string) int：返回整数

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

import (
	"fmt"
	"strings"
)

func main() {
	str1 := "hello,world, world"
	fmt.Println(strings.Count(str1, "l")) // 4
	fmt.Println(strings.Count(str1, "o")) // 3
	fmt.Println(strings.Count(str1, "z")) // 0
}

重复n次返回

Repeat(s string, count int) string，返回 copy n 次的新字符串

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

import (
	"fmt"
	"strings"
)

func main() {
	str2 := "hello,world"
	fmt.Println(strings.Repeat(str2, 1)) // hello,world
	fmt.Println(strings.Repeat(str2, 2)) // hello,worldhello,world
}

大小写转换

  • ToLower(s string) string：转小写
  • ToUpper(s string) string：转大写
1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
	"fmt"
	"strings"
)

func main() {
	str2 := "Hello,World"
	fmt.Println(strings.ToLower(str2)) // hello,world
	fmt.Println(strings.ToUpper(str2)) // HELLO,WORLD
}

移除指定内容

  • Trim(s, cutset string) string：去掉首尾指定的字符
  • TrimSpace(s string) string：去掉首尾空格
  • TrimPrefix(s, prefix string) string：去掉前缀指定的字符
  • TrimSuffix(s, suffix string) string：去掉后缀指定的字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Trim("Hello,WorldH", "H")) // ello,World
	fmt.Println(strings.TrimSpace(" Hello,WorldH ")) //【Hello,WorldH】
	fmt.Println(strings.TrimPrefix("Hello", "H")) // ello
	fmt.Println(strings.TrimSuffix("Hello", "o")) // Hell
	fmt.Println(strings.TrimLeft("Hello", "H")) // ello
	fmt.Println(strings.TrimRight("Hello", "o")) //Hell
}

字符串切割

  • Fields(s string) []string：返回空格分隔的子串
  • Split(s, sep string) []string：指定分隔符，返回分隔的子串
1
2
3
4
5
6
7
8
9
10
11
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Fields("Hello World")) // [Hello World]
	fmt.Println(strings.Split("Hello Word, Word", ",")) // [Hello Word  Word]
}

字符数组拼接

  • Join(elems []string, sep string) string：传入字符串数组和连接符，返回字符串
1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
	"fmt"
	"strings"
)

func main() {
	str3 := []string{"hello", "world", "best"}
	rest := strings.Join(str3, "_")
	fmt.Println(rest) // hello_world_best
}
发表更新Java / JVM31 分钟读完 (大约4708个字)

JVM虚拟机(2)：JVM 内存泄漏与内存溢出及问题排查

Java 的一个很重要的优点就是提供了垃圾回收器（Garbage Collection，GC）来自动管理内存，不用向 C 语言样需要开发人员手动来释放内存。但也不等于完全不管内存的使用，系统在线上长期运行后，可能出现内存泄漏耗尽内存，系统卡死或崩溃。

若剩余内存满足不了申请的需要，或申请不到连续内存，就会存在内存溢出问题（OOM），系统就会抛出 Error，导致业务逻辑无法正常执行。

对开发人员来说应该能分析 内存泄漏 和 内存溢出 问题的根源，彻底解决问题，而不仅仅是重启应用或扩大内存。

阅读更多
发表更新MQ系列 / RabbitMQ1 小时读完 (大约11220个字)

MQ系列(九)：RabbitMQ发布者确认,消费者(确认,预取,优先级,退出通知)

发布者确认解决了消息发送传输过程中因网络故章导致丢失消息的问题，RabbitMQ 为消息者确认提供了 自动确认 和 手动确认 两种方式。

消费者预取可以限制在回传确认消息之前接收的消息数量，消费者优先级允许高优先级的消息者优先接收消息，当高优先级消费者阻塞时，消息只会传递给低优先级消费者。

阅读更多
关注我

分类

最新文章

链接

归档

×