发表更新Java / Utils1 分钟读完 (大约155个字)

Utils-Linux环境下获取 IP v4 地址

获取 Linux 环境下当前的 IP v4 的 IP 地址。在不修改 Linux 系统的 host 映射的情况下，InetAddress.getLocalHost().getHostAddress()获取的 IP 地址很可能是 127.0.0.1，而真正想要的是对外 IP 地址。

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

Spring Boot 2系列(五十四)：分布式文件服务 FastDFS 安装与集成

项目需要用到文件服务，外网使用阿里云的 OSS 对象存储，内网优先考虑 FastDFS，备选 go-fastdfs 。

FastDFS 是一款开源的轻量级的分布式文件系统，功能主要包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了文件大容量存储和高性能访问的问题。FastDFS特别适合以文件为载体的在线服务，如图片、视频、文档等等。–摘自官方说明。

FastDFS 的官方文档极少，不便于快速学习用使用，需要个人整理总结。在源码的根目录下有个 INSTALL 的文件，里面记录的是安装 FastDFS 服务的安装步骤。

Github > FastDFS，Gitee > FastDFS，go-fastdfs ，fastdfs-client-java。另可参考 tobato/FastDFS_Client 文档。

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

Spring Boot 2系列(五十三)：Spring Boot 配置外部化

Spring Boot 允许将配置外部化，以便可以在不同的环境中使用相同的应用程序代码。可以使用 properties 文件、YAML文件、环境变量和命令行参数将配置外部化。

属性值可以通过@Value注解直接注入到 Bean 的属性，通过 Spring 的 Environment 抽象访问，或者通过@ConfigurationProperties 绑定到结构化对象。

之前写过 Spring Boot 配置的相关文件，但不完整。本篇基于官方文档（Externalized Configuration）行详细描述。

阅读更多
发表更新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
}
关注我

分类

最新文章

链接

归档

×