我正在参加「掘金·启航计划」

本文从研发角度探讨下高质量软件应具备哪些特点，以及如何度量软件质量。

软件质量的分类

软件质量通常可以分为：内部质量和外部质量。

内部质量

内部质量是指软件的结构和代码质量，以及其是否适合维护、扩展和重构。它关注的是软件本身的特性和属性，包括：

• 可读性：代码易于阅读和理解；
• 易维护性：代码易于修改和维护；
• 可测试性：代码易于编写单元测试并进行自动化测试；
• 可靠性：代码稳定、不容易崩溃或出现错误；
• 可扩展性：代码能够方便地进行扩展；
• 可重用性：代码可被复用于其他项目中。

内部质量直接影响软件的可维护性和开发效率。如果软件的内部质量很差，那么开发人员可能需要花费更多的时间修复问题，而不是开发新功能。

外部质量

外部质量是指软件的用户体验和其符合用户需求的程度。它关注的是软件的功能和表现形式，包括：

• 功能性：软件是否具有所需的功能，并且这些功能是否能够正常工作；
• 易用性：软件是否易于使用，是否符合用户的期望；
• 性能：软件是否运行快速并响应迅速；
• 兼容性：软件是否能够在不同的操作系统和设备上正常工作。

外部质量如果很差，那么用户在使用软件过程中可能会遇到问题，而这些问题可能会影响用户体验，导致用户流失。

为什么内部质量更重要

内部质量高的核心降低了未来变更的成本。

可以参考下图的时间-功能累计关系图。

对于内部质量比较差的软件，虽然初期进展迅速，但是随着时间的流逝，添加新功能变得越来越困难。甚至一个小改动也需要程序员理解大量代码。当开发做代码变更时，还可能产生意想不到的缺陷，因此导致测试时间长，需要更高成本来做缺陷修复和验证。

对于内部质量高的软件，则与其相反，可以参考下图的比较。

内部质量高的软件更容易被实现。

内部质量高的软件特点之一就是易读性。 这样利于开发者更快弄清楚应用程序是如何运行的，这样就可以知道如何添加新功能。如果将软件很好地划分为不同的实现模块，则开发者没必要阅读所有代码，只需要快速找到涉及功能变动模块的代码就行。

如何衡量软件质量

Cyclomatic Complexity（圈复杂度）

Cyclomatic Complexity通过计算代码中不同路径的数量来衡量代码的复杂程度。圈复杂度越高，表示代码的控制流程越复杂，可能存在更多的错误和缺陷。

下面举例说明Cyclomatic Complexity如何计算。

public int calculate(x, y) {

    if (x >= 20) {

        if (y >= 20) {

            return y;

        }



        return x;

    }



    return x + y;

}

这段代码的流程图如下：

圈复杂度的公式如下：

E - N + 2

其中 E 表示图中的边数（上图中的所有形状），N 表示节点数（上图中的所有箭头）。因此，在我们的例子中，6 - 5 + 2 = 3，的确这段代码包含三条路径。

Maintainability Index（可维护性指数）

Maintainability Index（可维护性指数）是一种用于评估软件代码可维护性的指标。它通常考虑代码的复杂度、长度和注释等因素，并将这些因素整合成一个分数来衡量代码的可读性、可维护性和可重构性。

通常情况下，可维护性指数的分数范围是 [0,100]，分数越高表示代码的可维护性越好。可维护性指数可以帮助开发人员识别哪些代码需要改进，以提高代码的可维护性和可读性，从而减少维护成本、降低缺陷率，提高代码的质量。

Dependencies（依赖）

软件的开发过程势必会依赖外部框架和库，这些框架和库自身也会经常更新（维护者会添加和删除功能、修复错误、改进性能，并修补安全漏洞）。

旧版本库和框架通常会对依赖它的软件质量产生负面影响。例如安全漏洞是明显的风险（例如22年8月份的

Apachelog4j漏洞）。

SQALE评估法

SQALE评估法主要关注四个指标：

1. 技术债：即未来要花费的时间和资源去修复当前存在的问题
2. 可维护性：即代码的易读性、可理解性和可扩展性，从代码的模块化程度、命名规范、注释等因素，并对这些因素进行打分。
3. 可靠性：即软件的稳定性和可靠性，评估代码中存在的错误、漏洞和异常处理情况。如果存在较多的问题，他们就需要考虑重新设计代码或增加更多的测试用例。
4. 性能：即软件的响应速度和处理能力

能GET到的知识点

• 什么场景使用for和range

1. 从一个遍历开始

万能的range遍历

1. 遍历array/slice/strings

array

package main  

  

import "fmt"  

  

func main() {  

    var UserIDList = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  



    for i, v := range UserIDList {  

        fmt.Println(i, v)  

    }  

}



0 1

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

9 10

slice

package main  

  

import "fmt"  

  

func main() {  

    var UserIDList = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  

    var UerSlice = UserIDList[:]  



    for i, v := range UerSlice {  

        fmt.Println(i, v)  

    }  

}

0 1

1 2

2 3

3 4

4 5

5 6

6 7

7 8

8 9

9 10

字符串

func main(){

    var Username = "斑斑砖abc"  

    for i, v := range Username {  

        fmt.Println(i, v)  

    }

}





0 26001

3 26001

6 30742

9 97

10 98

11 99

range进行对array、slice类型遍历一切都正常，但是到了对字符串进行遍历时这里就出问题了,出问题主要在索引这一块。可以看出索引是每个字节的位置，在go语言中的字符串是UTF-8编码的字节序列。而不是单个的Unicode字符。遇到中文字符时需要使用多个字节表示，英文字符一个字节进行表示，索引0-3表示了一个字符及斑以此完后。

2. 遍历map

func ByMap() {  

    m := map[string]int{  

    "one": 1,  

    "two": 2,  

    "three": 3,  

    }  

    for k, v := range m {  

        delete(m, "two")  

        m["four"] = 4  

        fmt.Printf("%v: %v\n", k, v)  

    }  

}



one: 1

four: 4

three: 3

• 和切片不同的是，迭代过程中，删除还未迭代到的键值对，则该键值对不会被迭代。
• 在迭代过程中，如果创建新的键值对，那么新增键值对，可能被迭代，也可能不会被迭代。个人认为应该是hash的无序性问题
• 针对 nil 字典，迭代次数为 0

3. 遍历channel

func ByChannel() {  

    ch := make(chan string)  

    go func() {  

        ch <- "a"  

        ch <- "b"  

        ch <- "c"  

        ch <- "d"  

        close(ch)  

    }()  

    time.Sleep(time.Second)

    for n := range ch {  

        fmt.Println(n)  

    }  

}

• 针对于range对关闭channel的遍历，会直到把元素都读取完成。
• 但是在for遍历会造成阻塞，因为for变量读取一个关闭的管道并不会进行退出，而是一直进行等待，但是如果关闭了会返回一个状态值可以根据该状态值判断是否需要操作

2.for和range之间奇怪的问题

2.1 无限遍历现象

for

c := []int{1, 2, 3}  

for i := 0; i < len(c); i++ {  

    c = append(c, i)  

    fmt.Println(i)  

}



1

2

3

.

.

.

15096

15097

15098

15099

15100

15101

15102

15103

15104

range

c := []int{1, 2, 3}  

for _, v := range c {  

    c = append(c, v)  

    fmt.Println(v)  

}



1

2

3

可以看出for循环一直在永无止境的进行追加元素。 range循环正常。原因：for循环的i < len(c)-1都会进行重新计算一次，造成了永远都不成立。range循环遍历在开始前只会计算一次，如果在循环进行修改也不会影响正常变量。

2.2 在for和range进行修改操作

for

type UserInfo struct {  

    Name string  

    Age int  

}

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

    }  

for i := 0; i < len(UserInfoList); i++ {  

 

    UserInfoList[i].Age += i  

}  

fmt.Println(UserInfoList)



0

1

2

[{John 25} {Jane 31} {Mike 30}]

range

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

    }  



  

for i, info := range UserInfoList {  

    info.Age += i  

}  

fmt.Println(UserInfoList)



[{John 25} {Jane 30} {Mike 28}]

可以看出for循环进行修改了成功，但是在range循环修改失效，为什么呢？因为range循环返回的是对该值的拷贝，所以修改失效。for循环修相当于进行原地修改了。但如果在for循环里面进行赋值修改操作，那么修改也会进行失效 具体如下

var UserInfoList = [3]UserInfo{  

    {Name: "John", Age: 25},  

    {Name: "Jane", Age: 30},  

    {Name: "Mike", Age: 28},  

}  

for i := 0; i < len(UserInfoList); i++ {  

    fmt.Println(i)  

    item := UserInfoList[i]  

    item.Age += i  

  

}  

  



fmt.Println(UserInfoList)

> [{John 25} {Jane 30} {Mike 28}]

3. Benchmark大比拼

主要是针对大类型结构体

type Item struct {  

    id int  

    val [4096]byte  

}

for_test.go

func BenchmarkForStruct(b *testing.B) {  

    var items [1024]Item  

    for i := 0; i < b.N; i++ {  

        length := len(items)  

        var tmp int  

        for k := 0; k < length; k++ {  

            tmp = items[k].id  

        }  

        _ = tmp  

    }  

}

func BenchmarkRangeStruct(b *testing.B) {  

    var items [1024]Item  

    for i := 0; i < b.N; i++ {  

        var tmp int  

        for _, item := range items {  

            tmp = item.id  

        }  

        _ = tmp  

    }  

}

goos: windows

goarch: amd64

pkg: article/02fortest

cpu: AMD Ryzen 5 5600G with Radeon Graphics

BenchmarkForStruct-12            2503378               474.8 ns/op             0 B/op          0 allocs/op

BenchmarkRangeStruct-12             4983            232744 ns/op               0 B/op          0 allocs/op

PASS

ok      article/02fortest       3.268s

可以看出 for 的性能大约是 range 的 600 倍。

为什么会产生这么大呢？

上述也说过，range遍历会对迭代的值创建一个拷贝。在占据占用较大的结构时每次都需要进行做一次拷贝，取申请大约4kb的内存，显然是大可不必的。所以在对于占据较大的结构时，应该使用for进行变量操作。

总结

如何选择合适的遍历，在针对与测试场景的情况下，图便捷可以使用range，毕竟for循环需要写一堆的条件，初始值等。但是如果遍历的元素是个占用大个内存的结构的话，避免使用range进行遍历。且如果需要进行修改操作的话只能用for遍历来修改，其实range也可以进行索引遍历的，在本文为写，读者可以去尝试一下。

前言

  Java 编程语言的每一次重要更新，都引入了许多新功能和改进。 并且在String 类中引入了一些新的方法，能够更好地满足开发的需求，提高编程效率。

1. repeat(int count)：返回一个新的字符串，该字符串是由原字符串重复指定次数形成的。
2. isBlank()：检查字符串是否为空白字符序列，即长度为 0 或仅包含空格字符的字符串。
3. lines()：返回一个流，该流由字符串按行分隔而成。
4. strip()：返回一个新的字符串，该字符串是原字符串去除前导空格和尾随空格后形成的。
5. stripLeading()：返回一个新的字符串，该字符串是原字符串去除前导空格后形成的。
6. stripTrailing()：返回一个新的字符串，该字符串是原字符串去除尾随空格后形成的。
7. formatted(Object... args)：使用指定的参数格式化字符串，并返回格式化后的字符串。
8. translateEscapes()：将 Java 转义序列转换为相应的字符，并返回转换后的字符串。
9. transform() 方法：该方法可以将一个函数应用于字符串，并返回函数的结果。

示例

1. repeat(int count)

public class StringRepeatExample {

    public static void main(String[] args) {

        String str = "abc";

        String repeatedStr = str.repeat(3);

        System.out.println(repeatedStr);

    }

}

输出结果：

abcabcabc

2. isBlank()

public class StringIsBlankExample {

    public static void main(String[] args) {

        String str1 = "";

        String str2 = " ";

        String str3 = "  \t  ";



        System.out.println(str1.isBlank());

        System.out.println(str2.isBlank());

        System.out.println(str3.isBlank());

    }

}

输出结果：

true

true

true

3. lines()

import java.util.stream.Stream;



public class StringLinesExample {

    public static void main(String[] args) {

        String str = "Hello\nWorld\nJava";

        Stream<String> lines = str.lines();

        lines.forEach(System.out::println);

    }

}

输出结果：

Hello

World

Java

4. strip()

public class StringStripExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.strip());

        System.out.println(str2.strip());

    }

}

输出结果：

abc

def

5. stripLeading()

public class StringStripLeadingExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.stripLeading());

        System.out.println(str2.stripLeading());

    }

}

输出结果：

abc

def

6. stripTrailing()

public class StringStripTrailingExample {

    public static void main(String[] args) {

        String str1 = "  abc   ";

        String str2 = "\t def \n";

        System.out.println(str1.stripTrailing());

        System.out.println(str2.stripTrailing());

    }

}

输出结果：

abc

def

7. formatted(Object... args)

public class StringFormattedExample {

    public static void main(String[] args) {

        String str = "My name is %s, I'm %d years old.";

        String formattedStr = str.formatted( "John", 25);

        System.out.println(formattedStr);

    }

}

输出结果：

My name is John, I'm 25 years old.

8. translateEscapes()

public class StringTranslateEscapesExample {

    public static void main(String[] args) {

        String str = "Hello\\nWorld\\tJava";

        String translatedStr = str.translateEscapes();

        System.out.println(translatedStr);

    }

}

输出结果：

Hello

World   Java

9. transform()

public class StringTransformExample {

    public static void main(String[] args) {  

        String str = "hello world";  

        String result = str.transform(i -> i + "！");  

        System.out.println(result);  

    }

}

输出结果：

hello world！

结尾

  如果觉得对你有帮助，可以多多评论，多多点赞哦，也可以到我的主页看看，说不定有你喜欢的文章，也可以随手点个关注哦，谢谢。

  我是不一样的科技宅，每天进步一点点，体验不一样的生活。我们下

人比山高

大家好，我是寒草，一只工作两年的程序猿。农历七月初五，阳历八月七日是我的生日，小时候总是期盼生日的到来，而且总有一种我过生日的那天我就是山大王的错觉，毕竟可以吃香的，喝辣的。但是我也早就度过了无忧无虑的年纪，而生日这一天的意义也早就有所不同。

长大后，每当生日临近，总是思绪万千，或是思考过去，或是展望未来，年少时的悠哉不再，而思绪确是一年比一年多，有一位著名工程师曾经说过：

思绪和发量是负相关的。

虽然上面这个定律在我身上还没有印证，但是我不妨借生日这个难得的机会整理一下，收拾行囊，以便整装待发。

脚比路长

写文的当下，我正在思考，去年写文章的时候是什么样的心理：

• 持续亢奋？
• 充满希望？
• 活力四射？

反正在我印象里，去年的我心中是充满希望和活力的，但是现在的我肯定和去年大不相同，可能是因为这一年出现了很多的变化：

• 停不下来的裁员潮
• 一座座楼（公司）塌了

听了很多悲伤的事，也经历了很多令人消沉的事，使得我并不会如去年那般纯粹的充满活力，也以更加理性和辩证的去看待问题，世界也不再非黑即白，这大概就是“成长”吧，在此推荐：《少有人走的路》

在夜晚一个人走在回家的小路，我会思考很多很多事，但多数像泡沫一样飞散了，但是有一件事是我不会放弃的，也算是我长久以来的梦。

见下文

白山旭日

前一段时间，我开了一个新坑：程序猿之梦！星辰大海的前端建站之路「第一周」，没错，现在的我有一个理想，想创造一个自己的产品，我对她寄托了很多很多情感：

• 我希望她可以承载更多的美好
• 我希望她可以创造一股清流在网络社会流淌
• 我希望她可以为社会提供向上的价值
• ...

但是这个事情已经停摆了一个月了，毕竟我上个月大概上了 250 个小时的班，工作饱和度也基本来到了 150% ，整个人特别特别疲惫，掘金技术圈的群也是会经常 cue 到我的加班。

不要说我卷，我是很期望刘慈欣摸鱼写《三体》的那种生活的，但是生活所迫。

即使工作比较辛苦让我疲惫至极，我也会想把我的产品搞下去，我总是做不切实际的梦，我总是有一堆幻想，我总希望我从事的事业可以让世界更加美好，我总是焦虑，我总是烦躁，我总是有一种奇奇怪怪的理想主义，还有那么一丝丝的浪漫情怀。

所以，无论如何，我欣赏我，我会是我。

黑水金光

前几天农历生日的时候，同事们陪我过了一个生日：

我作为一个东北人，也是第一次吃到铁锅炖大鹅（我怕不是个假东北人），还是很开心的，我从小到大还是第一次这么“正式”的过生日，近几天也陆陆续续的收到一些礼物：

• 一把工学椅：这样我在家就可以更舒适的创作了
• 一个木制密码箱：最关键还需要我自己拼（其实我没有什么特别值得放在密码箱里的东西）
• 特利迦奥特曼：这肯定是很了解我的人才会送的礼物～
• ...

羁绊越来越多了呢🌟还是要充满阳光的好好生活呀～

旅程

如果大家有耐心读到这里，一定有这样的一个疑问：“你这前四个标题是什么意思？”，其实只是我摘取了我母校校歌中的几句词，同时我也想到很多关于母校的指引我前进的故事：

• 黄大年教授：振兴中华，乃我辈之责

已故，纪念文：「振兴中华，乃我辈之责」于75周年校庆使用 canvas 纪念黄大年老师

• 张希校长：群居不倚,独立不惧
• ...

最后，祝我自己 25 岁生日快乐 🎂

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

江山如此多娇，引无数英雄竞折腰。
惜秦皇汉武，略输文采；唐宗宋祖，稍逊风骚。
一代天骄，成吉思汗，只识弯弓射大雕。
俱往矣，数风流人物，还看今朝。

— 《沁园春.雪》

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

各位，感谢阅读，一起加油！也欢迎各位加我微信：hancao97 和我交流。

-寒草写于2022.08.06 🔥 To Be Continued-

在Android开发中，数据与界面的分离一直是一项重要的挑战。为了解决这个问题，Google推出了Android Jetpack组件之一的ViewModel。ViewModel是一种用于管理UI相关数据的架构组件，它能够帮助开发者实现优雅的数据驱动和生命周期管理。本文将深入浅出地介绍ViewModel的使用和原理，带你一步步掌握这个强大的组件。

什么是ViewModel

ViewModel是Android Jetpack组件之一，它的主要目的是将UI控制器（如Activity和Fragment）与数据相关的业务逻辑分开，使得UI控制器能够专注于展示数据和响应用户交互，而数据的获取和处理则交由ViewModel来管理。这种分离能够使代码更加清晰、易于测试和维护。

ViewModel的原理

ViewModel的原理其实并不复杂。在设备配置发生变化（如屏幕旋转）导致Activity或Fragment重建时，ViewModel不会被销毁，而是保留在内存中。这样，UI控制器可以在重建后重新获取之前的ViewModel实例，并继续使用其中的数据，从而避免数据丢失和重复加载。

ViewModelStore和ViewModelStoreOwner

ViewModel的原理涉及两个核心概念：ViewModelStore和ViewModelStoreOwner。

ViewModelStore是一个存储ViewModel实例的容器，它的生命周期与UI控制器的生命周期关联。在UI控制器（Activity或Fragment）被销毁时，ViewModelStore会清理其中的ViewModel实例，避免内存泄漏。

ViewModelStoreOwner是拥有ViewModelStore的对象，通常是Activity或Fragment。ViewModelProvider通过ViewModelStoreOwner来获取ViewModelStore，并通过ViewModelStore来管理ViewModel的生命周期。

ViewModelProvider

ViewModelProvider是用于创建和获取ViewModel实例的工具类。它负责将ViewModel与ViewModelStoreOwner关联，并确保ViewModel在合适的时机被销毁。

在Activity中获取ViewModel实例：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

在Fragment中获取ViewModel实例：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

使用ViewModel

添加ViewModel依赖

首先，确保你的项目已经使用了AndroidX，并在build.gradle中添加ViewModel依赖：

dependencies {

    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1"

}

创建ViewModel

创建ViewModel非常简单，只需继承ViewModel类并在其中定义数据和相关操作。

public class MyViewModel extends ViewModel {

    private MutableLiveData<String> data = new MutableLiveData<>();



    public LiveData<String> getData() {

        return data;

    }



    public void fetchData() {

        // 模拟异步数据获取

        new Handler().postDelayed(() -> {

            data.setValue("Hello, ViewModel!");

        }, 2000);

    }

}

在UI控制器中使用ViewModel

在Activity或Fragment中获取ViewModel的实例，并观察数据变化：

viewModel = new ViewModelProvider(this).get(MyViewModel.class);

viewModel.getData().observe(this, data -> {

    // 更新UI

    textView.setText(data);

});



viewModel.fetchData(); // 触发数据获取操作

ViewModel与跨组件通信

ViewModel不仅仅用于在单个UI控制器内部共享数据，它还可以用于在不同UI控制器之间共享数据，实现跨组件通信。例如，一个Fragment中的数据可以通过ViewModel传递给Activity。

在Activity中共享数据：

sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

sharedViewModel.getData().observe(this, data -> {

    // 更新UI

    textView.setText(data);

});

在Fragment中共享数据：

sharedViewModel = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);

注意：在跨组件通信时，需要使用同一个ViewModelProvider获取相同类型的ViewModel实例。在Activity中，使用this作为ViewModelProvider的参数，在Fragment中，使用requireActivity()作为参数。

ViewModel与SavedState

有时，我们可能希望在ViewModel中保存一些与UI控制器生命周期无关的数据，以便在重建时恢复状态。ViewModel提供了SavedState功能，它可以让我们在ViewModel中持久化保存数据。

示例代码：

public class MyViewModel extends ViewModel {

    private SavedStateHandle savedStateHandle;



    public MyViewModel(SavedStateHandle savedStateHandle) {

        this.savedStateHandle = savedStateHandle;

    }



    public LiveData<String> getData() {

        return savedStateHandle.getLiveData("data");

    }



    public void setData(String data) {

        savedStateHandle.set("data", data);

    }

}

使用SavedStateViewModelFactory创建带有SavedState功能的ViewModel：

public class MyActivity extends AppCompatActivity {

    private MyViewModel viewModel;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        ViewModelProvider.Factory factory = new SavedStateViewModelFactory(getApplication(), this);

        viewModel = new ViewModelProvider(this, factory).get(MyViewModel.class);



        viewModel.getData().observe(this, data -> {

            // 更新UI

            textView.setText(data);

        });



        if (savedInstanceState == null) {

            // 第一次创建时，触发数据获取操作

            viewModel.fetchData();

        }

    }

}

ViewModel使用过程中的注意点

• 不要在ViewModel中持有Context的引用，避免引发内存泄漏。
• ViewModel应该只关注数据和业务逻辑，不应处理UI相关的操作。
• 不要在ViewModel中保存大量数据，避免占用过多内存。
• 当数据量较大或需要跨进程共享数据时，应该考虑使用其他解决方案，如Room数据库或SharedPreferences。

结论

通过本文的介绍，你已经了解了Android Jetpack ViewModel的使用与原理。ViewModel的出现极大地简化了Android开发中的数据管理和生命周期处理，使得应用更加健壮和高效。在实际开发中，合理使用ViewModel能够帮助你构建优雅、易维护的Android应用。

介绍

TextView 是 Android 开发中最常用的小部件之一。它用于在屏幕上显示文本。但是，TextView 有几个较少为人知的功能，对开发人员非常有用。在本博客文章中，我们将探讨其中的一些功能。

自定义字体

默认情况下，TextView 使用系统字体显示文本。但其实我们也可以导入我们自己的字体文件在 TextView 中使用自定义字体。这可以通过将字体文件添加到资源文件夹（res/font 或者 assets）并在 TextView 上以编程方式设置来实现。

要使用自定义字体，我们需要下载字体文件（或者自己生成）并将其添加到资源文件夹中。然后，我们可以使用setTypeface（）方法在TextView上以编程方式设置字体。我们还可以在XML中使用android：fontFamily属性设置字体。需要注意的是，fontFamily方式只能使用系统预设的字体并且仅对英文字符有效，如果TextView的文本内容是中文的话这个属性设置后将不会有任何效果。

以下是 Android TextView 自定义字体的代码示例：

1. 将字体文件添加到 assets 或 res/font 文件夹中。
2. 通过以下代码设置字体：

// 字体文件放到 assets 文件夹的情况

Typeface tf = Typeface.createFromAsset(getAssets(), "fonts/myfont.ttf");

TextView tv = findViewById(R.id.tv);

tv.setTypeface(tf);

// 字体文件放到 res/font 文件夹的情况, 需注意的是此方式在部分低于 Android 8.0 的设备上可能会存在兼容性问题

val tv = findViewById<TextView>(R.id.tv)

val typeface = ResourcesCompat.getFont(this, R.font.myfont)

tv.typeface = typeface

在上面的示例中，我们首先从 assets 文件夹中创建了一个新的 Typeface 对象。然后，我们使用 setTypeface() 方法将该对象设置为 TextView 的字体。

在上面的示例中，我们将字体文件命名为 “myfont.ttf”。我们可以将其替换为要使用的任何字体文件的名称。

自定义字体是 TextView 的强大功能之一，它可以帮助我们创建具有独特外观和感觉的应用程序。另外，我们也可以通过这种方法实现自定义图标的绘制。

AutoLink

AutoLink 可以自动检测文本中的模式并将其转换为可点击的链接。例如，如果 TextView 包含电子邮件地址或 URL，则 AutoLink 将识别它并使其可点击。此功能使开发人员无需手动创建文本中的可点击链接。

要在 TextView 上启用 AutoLink，您需要将autoLink属性设置为email，phone，web或all。您还可以使用Linkify类设置自定义链接模式。

以下是一个Android TextView AutoLink代码使用示例：

<TextView

    android:id="@+id/tv3"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:autoLink="web"

    android:textColorLink="@android:color/holo_red_dark"

    android:text="这是我的个人博客地址: http://www.geektang.cn" />

在上面的示例中，我们将 autoLink 属性设置为 web ，这意味着 TextView 将自动检测文本中的 URL 并将其转换为可点击的链接。我们还将 text 属性将文本设置为 这是我的个人博客地址: http://www.geektang.cn 。当用户单击链接时，它们将被带到 http://www.geektang.cn 网站。另外，我们也可以通过 textColorLink 属性将 Link 颜色为我们喜欢的颜色。

AutoLink是一个非常有用的功能，它可以帮助您更轻松地创建可交互的文本。

对齐模式

对齐模式允许您通过在单词之间添加空格将文本对齐到左右边距，这使得文本更易读且视觉上更具吸引力。您可以将对齐模式属性设置为 inter_word 或 inter_character。

要使用对齐模式功能，您需要在 TextView 上设置 justificationMode 属性。但是，此功能仅适用于运行 Android 8.0（API 级别 26）或更高版本的设备。

以下是对齐模式功能的代码示例：

<TextView

    android:id="@+id/text_view"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:text="This is some sample text that will be justified."

    android:justificationMode="inter_word"/>

在上面的示例中，我们将 justificationMode 属性设置为 inter_word 。这意味着 TextView 将在单词之间添加空格，以便将文本对齐到左右边距。

以下是对齐模式功能的显示效果示例：

同样一段文本，上面的设置 justificationMode 为 inter_word ，是不是看起来会比下面的好看一些呢？这个属性一般用于多行英文文本，如果只有一行文本或者文本内容是纯中文字符的话，不会有任何效果。

排序算法

数组任意两值交换

创建临时变量进行交换

private void swap(int[] nums, int idx1, int idx2) {

    int temp = nums[idx1];

    nums[idx1] = nums[idx2];

    nums[idx2] = temp;

}

冒泡排序

思路：每次对 [0, j] 进行排序，把该区间中最大的值放到这个区间的最右边；

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 冒泡排序

 *

 * @param nums 数组

 */

public void bubbleSort(int[] nums) {

    for (int i = 0; i < nums.length - 1; i++) {

        for (int j = 0; j < nums.length - 1 - i; j++) {

            if (nums[j] > nums[j + 1]) {

                swap(nums, j, j + 1);

            }

        }

    }

}

选择排序

思路：对于区间 [j, nums.length] （i <= j <= nums.length），每次在这个区间中选择最小的值，插入到 nums[i] 中，即每次选择一个最小的值插入到 nums[i] 中；

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 插入排序

 *

 * @param nums 数组

 */

public void insertSort(int[] nums) {

    for (int i = 0; i < nums.length; i++) {

        int idx = 0;

        int min = Integer.MAX_VALUE;

        for (int j = i; j < nums.length; j++) {

            if (nums[j] < min) {

                min = nums[j];

                idx = j;

            }

        }

        swap(nums, i, idx);

    }

}

插入排序

思路：对于区间 [0, j] ，在 [i, length-1] 的区间中每次使用下标的 i 的数（ j <= i ），插入到区间 [0, j] 中，保证 [0, j] 是有序的

时间复杂度：O(n2)

空间复杂度：O(1)

/**

 * 插入排序

 *

 * @param nums 数组

 */

public void insertSort(int[] nums) {

    for (int i = 1; i < nums.length; i++) {

        int temp = nums[i];

        int j = i;

        for (; j > 0; j--) {

            if (temp < nums[j - 1]) {

                nums[j] = nums[j - 1];

            } else {

                break;

            }

        }

        nums[j] = temp;

    }

}

快速排序

思路：

1. 对于单次的排序 partition() ，定义一个标志 part ，凡是小于该值的都放左边，大于该值的都放右边，最后把该值放到中间，并返回中间的下标 partition ，这里实现的关键是：存在一个指针 j 始终指向左边区间的最靠右的值，若 j + 1，则去到了右区间；
2. 将数组以 partition 为中点，将数组分成两份，每一份继续进行 partition()；

时间复杂度：O(nlogn)

空间复杂度：O(logn)

/**

 * 递归函数

 *

 * @param nums  数组

 * @param left  左

 * @param right 右

 */

public void quickSort(int[] nums, int left, int right) {



    if (left >= right) {

        return;

    }



    int partition = partition(nums, left, right);



    quickSort(nums, left, partition - 1);

    quickSort(nums, partition + 1, right);

}



/**

 * 将小于某个元素的值放到左边，大于某个元素的值放到右边

 *

 * @param nums  数组

 * @param left  左

 * @param right 右

 * @return 结果

 */

public int partition(int[] nums, int left, int right) {

    // 以数组的左边的值作为标记

    int part = nums[left];

    int i = left + 1;

    // j 始终指向左边区间小于或等于 part 的最靠右的值

    int j = left;



    for (; i < nums.length; i++) {

        if (nums[i] < part) {

            j++;

            swap(nums, i, j);

        }

    }



    swap(nums, j, left);

    return j;

}

三向切分快速排序

适用于有重复内容的排序

思路：

1. 分成三个区间，小于 pivot（左区间），等于 pivot（中区间），大于 pivot（右区间）；
2. 左区间的 lt 指针永远指向该区间的最右的位置，右区间的指针永远指向该区间的最左的位置；
3. 对于中区间，不断移动游标 i 的位置即可；

时间复杂度：O(nlogn)

空间复杂度：O(logn)

public void threeQuickSort(int[] nums, int left, int right) {

    if (left >= right) {

        return;

    }

    int pivot = nums[left];



    // [left + 1, lt] 小于 pivot

    // [lt + 1, i) 等于 pivot

    // [gt, right] 大于 pivot

    int lt = left;  // 左区间的指针

    int gt = right + 1;  // 右区间的指针

    int i = left + 1;



    while (i < gt) {

        if (nums[i] < pivot) {

            lt++;

            swap(nums, i, lt);

            i++;

        } else if (nums[i] == pivot) {

            i++;

        } else {

            gt++;

            swap(nums, gt, i);

        }

    }

    swap(nums, left, lt);

    threeQuickSort(nums, left, lt - 1);

    threeQuickSort(nums, gt, right);

}

归并排序

思路：

1. 分隔：先将数组不断分割，直到分割到区间 [left, right] 内只有一个值
2. 合并：将分隔后的数组不断向上合并，利用临时数组 temp[] 存储 原来 nums 数组 [left，right] 区间的值，然后分别从 temp 数组中 [left, mid] 和 [mid + 1, right] 区间分别取出最小的值，放入 nums 数组对应的位置即可；
3. 代码的主要难点是 nums 数组 和 temp 数组的下标对应关系

1. 1. i 对应 left，即 [left, mid] 的起点，i 在 temp 数组起始值为 0
   2. j 对应 mid + 1，即 [mid + 1, right] 的起点，j 在 temp 数组起始值为 mid - left + 1

时间复杂度：O(nlogn)

空间复杂度：O(n + logn) => O(n)：临时的数组和递归时压入栈的数据占用的空间

public void mergeSort(int[] nums, int left, int right) {



    if (left >= right) {

        return;

    }

    int mid = left + (right - left) / 2;



    mergeSort(nums, left, mid);

    mergeSort(nums, mid + 1, right);



    merge(nums, left, mid, right);

}



/**

 * 合并数组

 *

 * @param nums  数组

 * @param left  左端点

 * @param mid   中点

 * @param right 右端点

 */

private void merge(int[] nums, int left, int mid, int right) {

    int length = right - left + 1;

    int[] temp = new int[length];



    for (int i = 0; i < length; i++) {

        temp[i] = nums[left + i];

    }



    // i j 为 temp 数组的下标

    // 关键是找到 i j 与 原数组 nums 下标的对应关系

    int i = 0;

    int j = mid - left + 1;

    for (int k = 0; k < length; k++) {

        if (i == mid - left + 1) {

            nums[k + left] = temp[j];

            j++;

        } else if (j == right - left + 1) {

            nums[k + left] = temp[i];

            i++;

        } else if (temp[i] <= temp[j]) {

            nums[k + left] = temp[i];

            i++;

        } else {

            nums[k + left] = temp[j];

            j++;

        }

    }

}

堆排序

思路：

1. 读者首先搞懂什么是 堆 ，代码示例中介绍的 大顶堆，这里不作过多介绍；
2. 首先初始化一个大顶堆，每个大顶堆的根节点是最大值；
3. 不断把根节点的值与数组最后一个值交换，然后长度减 1 再次进行大顶堆的整理操作；

时间复杂度：O(nlogn)，每次整理的时间复杂度是 logn，要进行 n 次

空间复杂度：O(1)

/**

     * 堆排序

     *

     * @param nums 数组

     */

    public void heapSort(int[] nums) {

        initMaxHeap(nums);

        int len = nums.length - 1;

        while (len > 0) {

            swap(nums, 0, len);

            len--;

            siftDown(nums, 0, len);

        }

    }



    /**

     * 初始化为大顶堆

     *

     * @param nums 数组

     */

    public void initMaxHeap(int[] nums) {

        int len = nums.length;

        for (int i = (len - 1) / 2; i >= 0; i--) {

            siftDown(nums, i, len - 1);

        }

    }



    /**

     * 向下整理

     * @param nums 数组

     * @param k 某个节点

     * @param len 数组长度

     */

    public void siftDown(int[] nums, int k, int len) {



        while (k * 2 + 1 <= len) {

            int j = k * 2 + 1;

            if (j + 1 <= len && nums[j] < nums[j + 1]) {

                j++;

            }

            if (nums[k] > nums[j]) {

                break;

            }

            swap(nums, k, j);

            k = j;

        }

    }

过滤器

数据准备

• DAO 层 UserDao、AccountDao、BookDao、EquipmentDao

  public interface UserDao {
  
  	public void save();
  
  }

  @Component("userDao")
  
  public class UserDaoImpl implements UserDao {
  
      public void save() {
  
          System.out.println("user dao running...");
  
      }
  
  
  
  }
  
  

• Service 业务层

  public interface UserService {
  
      public void save();
  
  }

  @Service("userService")
  
  public class UserServiceImpl implements UserService {
  
      @Autowired
  
      private UserDao userDao;//...........BookDao等
  
  
  
      public void save() {
  
          System.out.println("user service running...");
  
          userDao.save();
  
      }
  
  }
  
  

过滤器

名称：TypeFilter

类型：接口

作用：自定义类型过滤器

示例：

• config / filter / MyTypeFilter

  public class MyTypeFilter implements TypeFilter {
  
      @Override
  
      /**
  
      * metadataReader:读取到的当前正在扫描的类的信息
  
      * metadataReaderFactory:可以获取到任何其他类的信息
  
      */
  
      //加载的类满足要求，匹配成功
  
      public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  
          //获取当前类注解的信息
  
  		AnnotationMetadata am = metadataReader.getAnnotationMetadata();
  
  		//获取当前正在扫描的类的类信息
  
  		ClassMetadata classMetadata = metadataReader.getClassMetadata();
  
  		//获取当前类资源（类的路径）
  
  		Resource resource = metadataReader.getResource();
  
          
  
          
  
          //通过类的元数据获取类的名称
  
          String className = classMetadata.getClassName();
  
          //如果加载的类名满足过滤器要求，返回匹配成功
  
          if(className.equals("service.impl.UserServiceImpl")){
  
         	//返回true表示匹配成功，返回false表示匹配失败。此处仅确认匹配结果，不会确认是排除还是加入，排除/加入由配置项决定，与此处无关
  
              return true;
  
          }
  
          return false;
  
      }
  
  }
  
  

• SpringConfig

  @Configuration
  
  //设置排除bean，排除的规则是自定义规则（FilterType.CUSTOM），具体的规则定义为MyTypeFilter
  
  @ComponentScan(
  
          value = {"dao","service"},
  
          excludeFilters = @ComponentScan.Filter(
  
                  type= FilterType.CUSTOM,
  
                  classes = MyTypeFilter.class
  
          )
  
  )
  
  public class SpringConfig {
  
  }
  
  

导入器

bean 只有通过配置才可以进入 Spring 容器，被 Spring 加载并控制

• 配置 bean 的方式如下：

  • XML 文件中使用 标签配置
  • 使用 @Component 及衍生注解配置

导入器可以快速高效导入大量 bean，替代 @Import({a.class,b.class})，无需在每个类上添加 @Bean

名称： ImportSelector

类型：接口

作用：自定义bean导入器

• selector / MyImportSelector

  public class MyImportSelector implements ImportSelector{
  
      @Override
  
      public String[] selectImports(AnnotationMetadata importingClassMetadata) {
  
  //      1.编程形式加载一个类
  
  //      return new String[]{"dao.impl.BookDaoImpl"};
  
  
  
  //      2.加载import.properties文件中的单个类名
  
  //      ResourceBundle bundle = ResourceBundle.getBundle("import");
  
  //      String className = bundle.getString("className");
  
  
  
  //      3.加载import.properties文件中的多个类名
  
          ResourceBundle bundle = ResourceBundle.getBundle("import");
  
          String className = bundle.getString("className");
  
          return className.split(",");
  
      }
  
  }
  
  

• import.properties

  #2.加载import.properties文件中的单个类名
  
  #className=dao.impl.BookDaoImpl
  
  
  
  #3.加载import.properties文件中的多个类名
  
  #className=dao.impl.BookDaoImpl,dao.impl.AccountDaoImpl
  
  
  
  #4.导入包中的所有类
  
  path=dao.impl.*
  
  

• SpringConfig

  @Configuration
  
  @ComponentScan({"dao","service"})
  
  @Import(MyImportSelector.class)
  
  public class SpringConfig {
  
  }
  
  

注册器

可以取代 ComponentScan 扫描器

名称：ImportBeanDefinitionRegistrar

类型：接口

作用：自定义 bean 定义注册器

• registrar / MyImportBeanDefinitionRegistrar

  public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  
  /**
  
   * AnnotationMetadata:当前类的注解信息
  
   * BeanDefinitionRegistry:BeanDefinition注册类，把所有需要添加到容器中的bean调用registerBeanDefinition手工注册进来
  
   */
  
      @Override
  
      public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  
          //自定义注册器
  
          //1.开启类路径bean定义扫描器，需要参数bean定义注册器BeanDefinitionRegistry，需要制定是否使用默认类型过滤器
  
          ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry,false);
  
          //2.添加包含性加载类型过滤器（可选，也可以设置为排除性加载类型过滤器）
  
          scanner.addIncludeFilter(new TypeFilter() {
  
              @Override
  
              public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
  
                  //所有匹配全部成功，此处应该添加实际的业务判定条件
  
                  return true;
  
              }
  
          });
  
          //设置扫描路径
  
          scanner.addExcludeFilter(tf);//排除
  
          scanner.scan("dao","service");
  
      }
  
  }
  
  

• SpringConfig

  @Configuration
  
  @Import(MyImportBeanDefinitionRegistrar.class)
  
  public class SpringConfig {
  
  }
  
  

处理器

通过创建类继承相应的处理器的接口，重写后置处理的方法，来实现拦截 Bean 的生命周期来实现自己自定义的逻辑

BeanPostProcessor：bean 后置处理器，bean 创建对象初始化前后进行拦截工作的

BeanFactoryPostProcessor：beanFactory 的后置处理器

•  加载时机：在 BeanFactory 初始化之后调用，来定制和修改 BeanFactory 的内容；所有的 bean 定义已经保存加载到 beanFactory，但是 bean 的实例还未创建

•   执行流程：
  
  

  • ioc 容器创建对象

  • invokeBeanFactoryPostProcessors(beanFactory)：执行 BeanFactoryPostProcessor

    • 在 BeanFactory 中找到所有类型是 BeanFactoryPostProcessor 的组件，并执行它们的方法
    • 在初始化创建其他组件前面执行

BeanDefinitionRegistryPostProcessor：

• 加载时机：在所有 bean 定义信息将要被加载，但是 bean 实例还未创建，优先于 BeanFactoryPostProcessor 执行；利用 BeanDefinitionRegistryPostProcessor 给容器中再额外添加一些组件

• 执行流程：

  • ioc 容器创建对象

  • refresh() → invokeBeanFactoryPostProcessors(beanFactory)

  • 从容器中获取到所有的 BeanDefinitionRegistryPostProcessor 组件

    • 依次触发所有的 postProcessBeanDefinitionRegistry() 方法
    • 再来触发 postProcessBeanFactory() 方法

监听器

基本概述

ApplicationListener：监听容器中发布的事件，完成事件驱动模型开发

public interface ApplicationListener<E extends ApplicationEvent>

所以监听 ApplicationEvent 及其下面的子事件

应用监听器步骤：

• 写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）

• 把监听器加入到容器 @Component

• 只要容器中有相关事件的发布，就能监听到这个事件；

  •  ContextRefreshedEvent：容器刷新完成（所有 bean 都完全创建）会发布这个事件

  •  ContextClosedEvent：关闭容器会发布这个事件
    
    

• 发布一个事件：applicationContext.publishEvent()

@Component

public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

	//当容器中发布此事件以后，方法触发

	@Override

	public void onApplicationEvent(ApplicationEvent event) {

		System.out.println("收到事件：" + event);

	}

}

实现原理

ContextRefreshedEvent 事件：

• 容器初始化过程中执行 initApplicationEventMulticaster()：初始化事件多播器

  • 先去容器中查询 id = applicationEventMulticaster 的组件，有直接返回
  • 没有就执行 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory) 并且加入到容器中
  • 以后在其他组件要派发事件，自动注入这个 applicationEventMulticaster

• 容器初始化过程执行 registerListeners() 注册监听器

  • 从容器中获取所有监听器：getBeanNamesForType(ApplicationListener.class, true, false)
  • 将 listener 注册到 ApplicationEventMulticaster

• 容器刷新完成：finishRefresh() → publishEvent(new ContextRefreshedEvent(this))

  发布 ContextRefreshedEvent 事件：

  • 获取事件的多播器（派发器）：getApplicationEventMulticaster()

  • multicastEvent 派发事件

    • 获取到所有的 ApplicationListener

    • 遍历 ApplicationListener

      • 如果有 Executor，可以使用 Executor 异步派发 Executor executor = getTaskExecutor()
      • 没有就同步执行 listener 方法 invokeListener(listener, event)，拿到 listener 回调 onApplicationEvent

容器关闭会发布 ContextClosedEvent

Frp是什么

简单地说，frp就是一个反向代理软件，它体积轻量但功能很强大，可以使处于内网或防火墙后的设备对外界提供服务，它支持HTTP、TCP、UDP等众多协议。

服务端配置

SSH连接到VPS之后运行如下命令查看处理器架构，根据架构下载不同版本的frp
运行如下命令，根据架构不同，选择相应版本并进行下载

wget https://github.com/fatedier/frp/releases/download/v0.22.0/frp_0.22.0_linux_amd64.tar.gz

然后解压缩

tar -zxvf frp_0.22.0_linux_amd64.tar.gz

服务端的配置我们只需要关注如下几个文件

• frps
• frps.ini

这两个文件（s结尾代表server）分别是服务端程序和服务端配置文件
然后修改frps.ini文件

[common]

bind_port = 49273

vhost_http_port = 9001

token = Er3@SGTwHtPl+jMRD0/f3QH/A

• “bind_port”表示用于客户端和服务端连接的端口，这个端口号我们之后在配置客户端的时候要用到。
• “vhost_http_port”和“vhost_https_port”用于反向代理HTTP主机时使用。
• “token”是用于客户端和服务端连接的口令，请自行设置并记录，稍后会用到。

编辑完成后保存（vim保存如果不会请自行搜索)

客户端配置

frp的客户端就是我们想要真正进行访问的那台设备。
同样地，根据客户端设备的情况选择相应的frp程序进行下载，将“frp_0.22.0_windows_amd64.zip”解压
客户端的配置我们只需要关注如下几个文件

• frpc

• frpc.ini

  这两个文件（c结尾代表client）分别是客户端程序和客户端配置文件。
  然后修改frpc.ini文件

[common]

server_addr = 52.80.184.170

server_port = 49273

token = Er3@SGTwHtPl+jMRD0/f3QH/A



[sentry]

type = http

local_ip = 10.10.75.137

local_port = 9001

custom_domains = 172.31.20.248

其中common字段下的三项即为服务端的设置。

• “server_addr”为服务端IP地址，填入即可。
• “server_port”为服务器端口，填入你设置的端口号即可。
• “token”是你在服务器上设置的连接口令，原样填入即可。

自定义规则

上面frpc.ini的sentry字段是自己定义的规则，自定义端口对应时格式如下。

• “[xxx]”表示一个规则名称，自己定义，便于查询即可。
• “type”表示转发的协议类型，有TCP和UDP等选项可以选择，如有需要请自行查询frp手册。
• “local_ip”是本地应用的IP地址，按照实际应用工作在本机的IP地址填写即可。
• “local_port”是本地应用的端口号，按照实际应用工作在本机的端口号填写即可。
• “custom_domains”服务端IP地址或域名，可以直接使用服务端ip或者生成一个内网ip。

后台运行脚本

运行服务端

./frpc -c frps.ini

运行客户端

./frpc -c frpc.ini

至此，我们的frp仅运行在前台，如果Ctrl+C停止或者关闭SSH窗口后，frp均会停止运行，因而我们使用 nohup命令将其运行在后台。
服务端创建start.sh脚本文件以及frps.log日志文件 编辑start.sh

nohup ./frps -c frps.ini &> frps.log &

客户端创建start.sh脚本文件以及frpc.log日志文件 编辑start.sh

nohup ./frpc -c frpc.ini &> frpc.log &

客户端和服务端执行start.sh脚本

./stash

查看log日志

tail -f frps.log

tail -f frpc.log

一篇文章学会正则表达式(Kotlin举例)

正则表达式是一种用来匹配字符串的工具，它可以在文本中查找特定的模式，从而实现对文本的处理和分析。在很多编程语言中，正则表达式都是非常重要的一部分。

了解正则表达式

在学习正则表达式之前，我们需要先了解一些基本概念。正则表达式由一系列字符和特殊字符组成，用来匹配字符串中的模式。例如，我们可以使用正则表达式来匹配一个电话号码、一个电子邮件地址或者一个网址。正则表达式中的一些常用特殊字符包括：

• .：匹配任意一个字符。
• *：匹配前面的字符零次或多次。
• +：匹配前面的字符一次或多次。
• ?：匹配前面的字符零次或一次。
• |：表示或的关系，匹配两边任意一边的内容。
• ()：表示分组，可以将多个字符组合成一个整体。
• ^：匹配字符串的开头。
• $：匹配字符串的结尾。
• {n}：匹配前面的字符恰好出现 n 次。
• {n,}：匹配前面的字符

正则表达式的基本语法

正则表达式的基本语法包括两个部分：模式和修饰符。模式是用来匹配字符串的规则，而修饰符则用来控制匹配的方式。

在 Kotlin 中，我们可以使用 Regex 类来表示一个正则表达式。例如，下面的代码定义了一个简单的正则表达式，用来匹配一个由数字组成的字符串：

val pattern = Regex("\\d+")

在这个正则表达式中，\d 表示匹配一个数字，+ 表示匹配前面的字符一次或多次。注意，在 Kotlin 中，我们需要使用 \\ 来表示 \ 字符，因为 \ 在字符串中有特殊的含义。

接下来，我们可以使用 matchEntire 函数来检查一个字符串是否符合这个正则表达式：

val input = "12345"

if (pattern.matchEntire(input) != null) {

    println("Match!")

} else {

    println("No match.")

}

这个代码会输出 Match!，因为输入的字符串符合正则表达式的规则。

常见的正则表达式的高级用法

除了基本的语法之外，正则表达式还有很多高级用法，可以实现更加复杂的匹配和替换操作。下面是一些常用的高级用法：

1. 捕获组

捕获组是指用 () 包围起来的一部分正则表达式，可以将匹配到的内容单独提取出来。例如，下面的代码定义了一个正则表达式，用来匹配一个由姓和名组成的字符串：

val pattern = Regex("(\\w+)\\s+(\\w+)")

val input = "John Smith"

val matchResult = pattern.matchEntire(input)

if (matchResult != null) {

    val firstName = matchResult.groupValues[1]

    val lastName = matchResult.groupValues[2]

    println("First name: $firstName")

    println("Last name: $lastName")

}

在这个代码中，\\w+ 表示匹配一个或多个字母、数字或下划线，\\s+ 表示匹配一个或多个空格。groupValues属性可以返回一个列表，其中包含了所有捕获组的内容。在这个例子中，groupValues[1] 表示第一个捕获组的内容，即姓，groupValues[2] 表示第二个捕获组的内容，即名。

2. 非捕获组

非捕获组是指用 (?:) 包围起来的一部分正则表达式，它和普通的捕获组的区别在于，非捕获组匹配到的内容不会单独提取出来。例如，下面的代码定义了一个正则表达式，用来匹配一个由单词和空格组成的字符串：

val pattern = Regex("(?:\\w+\\s+)+\\w+")

val input = "one two three four"

val matchResult = pattern.matchEntire(input)

if (matchResult != null) {

    println("Match!")

} else {

    println("No match.")

}

在这个代码中，(?:\\w+\\s+)+ 表示匹配一个或多个单词和空格组成的片段，\\w+ 表示匹配一个或多个字母、数字或下划线，\\s+ 表示匹配一个或多个空格。注意，这个正则表达式并没有使用捕获组，因此 matchResult.groupValues 的结果是一个空列表。

3. 零宽断言

零宽断言是指用 (?=) 或 (?!) 包围起来的一部分正则表达式，它可以在匹配的时候不消耗任何字符。例如，下面的代码定义了一个正则表达式，用来匹配一个以 http 或 https 开头的 URL：

val pattern = Regex("(?=http|https)\\w+")

val input = "https://www.google.com"

val matchResult = pattern.find(input)

if (matchResult != null) {

    println("Match: ${matchResult.value}")

} else {

    println("No match.")

}

在这个代码中，(?=http|https) 表示匹配一个以 http 或 https 开头的字符串，但是不消耗任何字符。find 函数可以在输入字符串中查找第一个匹配的子串，返回一个 MatchResult? 类型的结果。

总结

本文介绍了正则表达式的基本概念和语法，以及一些常用的高级用法。在实际的编程中，正则表达式是一种非常有用的工具，可以帮助我们快速地处理和分析文本数据。在 Kotlin 中，我们可以使用 Regex 类来表示和操作正则表达式，同时还可以使用一些高级用法来实现更加复杂的匹配和替换操作。

前言

本文将讲述ThreadLocal的实现原理，还有## ThreadLocal为什么使用弱引用。

ThreadLocal

ThreadLocal 是 Java 中的一个类，用于在多线程环境下为每个线程提供独立的变量副本。它通常用于解决多线程并发访问共享变量时的线程安全性问题。

ThreadLocal 的工作原理是每个线程内部维护一个 ThreadLocalMap 对象，该对象用于存储每个线程的变量副本。当通过 ThreadLocal 对象获取变量时，它会首先检查当前线程是否已经创建了该变量的副本，如果有，则直接返回副本；如果没有，则通过初始化方法创建一个新的副本，并将其保存在当前线程的 ThreadLocalMap 中。

使用 ThreadLocal 时，每个线程都可以独立地访问和修改自己的变量副本，而不会影响其他线程的副本。这使得在多线程环境中共享变量变得更加安全和可靠。

需要注意的是，使用 ThreadLocal 时要注意及时清理不再使用的变量副本，以避免内存泄漏问题。可以通过调用 remove() 方法来清除当前线程的变量副本。

源码解释

set方法源码

// ThreadLocal的set方法，value是要保存的值

public void set(T value) {

    // 得到当前线程对象

    Thread t = Thread.currentThread();

    // 得到当前线程对象关联的ThreadLocalMap对象

    ThreadLocalMap map = getMap(t);

    // 得到map对象就保存值，键为当前ThreadLocal对象

    // 如果没有map对象就创建一个map对象，保存值

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

}

// 得到当前线程关联的ThreadLocalMap对象

ThreadLocalMap getMap(Thread t) {

       return t.threadLocals;

}

// 创建一个ThreadLocalMap对象，赋给当前线程的threadLocals属性，并且存入值

void createMap(Thread t, T firstValue) {

       t.threadLocals = new ThreadLocalMap(this, firstValue);

}

private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;

    int len = tab.length;

    // 通过key计算在tab数组中的槽位i

    int i = key.threadLocalHashCode & (len-1);

    // 拿到槽位上的Entry对象，如果不为null，则进入循环，如果为null则表示可以直接加入该槽位

    // e = tab[i = nextIndex(i, len)])取出下一个槽位的Entry实体，如果为null，则表示可以直接添加进该槽位

    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {

        // 拿到与当前Entry有关联的ThreadLocal对象

        ThreadLocal<?> k = e.get();

        // 如果k与当前要保存值的key相等，则替换掉value，相当于修改key的值

        if (k == key) {

            e.value = value;

            return;

        }

        // 检查当前节点的ThreadLocal如果为null，表示ThreadLocal已经被gc回收，则调用 replaceStaleEntry() 方法来替换陈旧的 Entry，将新的 ThreadLocal 和值插入到数组中的索引位置 i 处，并返回。

        if (k == null) {

            replaceStaleEntry(key, value, i);

            return;

        }

    }

    // 创建一个Entry对象，加入i槽位

    tab[i] = new Entry(key, value);

    // 记录Entry对象个数

    int sz = ++size;

    // cleanSomeSlots清理陈旧的Entry，清理完后如果大于阈值，则调用rehash扩容数组

    if (!cleanSomeSlots(i, sz) && sz >= threshold)

        rehash();

}

get方法源码

public T get() {

    // 获取当前线程对象

    Thread t = Thread.currentThread();

    // 得到当前线程关联的ThreadLocalMap对象

    ThreadLocalMap map = getMap(t);

    if (map != null) {

        // 通过key获取到Entry对象

        ThreadLocalMap.Entry e = map.getEntry(this);

        // Entry不为空，则直接获取值返回结果

        if (e != null) {

            @SuppressWarnings("unchecked")

            T result = (T)e.value;

            return result;

        }

    }

    // 如果map为null，或者Entry为null，则返回一个初始化值

    return setInitialValue();

}

private T setInitialValue() {

        // 如果是在调用构造器初始化的ThreadLocal对象，该方法直接返回null

        // 如果是调用的静态方法withInitial，则返回你指定的一个初始化则

        // 并且还会把该初始化的值保存进ThreadLocalMap

        T value = initialValue();

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null)

            map.set(this, value);

        else

            createMap(t, value);

        return value;

}

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {

        // SuppliedThreadLocal是ThreadLocal的子类，重写了initialValue方法，通过传入一个Supplier，指定初始化值

        return new SuppliedThreadLocal<>(supplier);

}

private Entry getEntry(ThreadLocal<?> key) {

    // 计算当前key的落脚点

    int i = key.threadLocalHashCode & (table.length - 1);

    // 取出落脚点的Entry对象

    Entry e = table[i];

    // 如果e不为空，并且跟e关联的ThreadLocal对象等于当前的key，则返回当前e对象

    if (e != null && e.get() == key)

        return e;

    // 否则进入getEntryAfterMiss

    else

        return getEntryAfterMiss(key, i, e);

}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {

    Entry[] tab = table;

    int len = tab.length;

    // 如果e为null，则直接返回null，表示当前key并没有数据

    while (e != null) {

        // 取出与e关联的ThreadLocal对象

        ThreadLocal<?> k = e.get();

        // 判断k是否等于当前的ThreadLocal对象

        if (k == key)

            return e;

        // 当前k是否等于null，为null表示被gc垃圾回收，就清理旧的Entry对象

        if (k == null)

            expungeStaleEntry(i);

        else

            // 否则k不为null，取出下一个槽位，接着循环

            i = nextIndex(i, len);

        e = tab[i];

    }

    return null;

}

总结

可以看出实际保存线程局部变量的是ThreadLocalMap对象，每个线程都有一个这样的对象，保存的是键值对，键为当前的ThreadLocal对象，ThreadLocal对象一般设置为静态，非静态只会造成对象的冗余，因为ThreadLocalMap的键只能是当前ThreadLocal对象，所以只能保存一个键值对，如果要保存多个键值对，可以定义多个ThreadLocal对象作为不同的键，这样获取到的还是与线程有关联的ThreadLocalMap对象，而ThreadLocalMap的键是当前的ThreadLocal对象，多少个该对象，那就可以保存多少个值。

强软弱虚四大引用

在Java中，引用是用于引用对象的一个机制，它允许我们通过引用变量来操作和访问对象。在Java中，主要有以下几种引用类型：

0. 强引用（Strong Reference）：这是最常见的引用类型。当我们使用 new 关键字创建对象时，默认就是使用强引用。如果一个对象具有强引用，即存在一个强引用变量引用它，那么垃圾回收器就不会回收该对象。只有当对象没有任何强引用时，才会被认为是不再需要的，可以被垃圾回收。
1. 软引用（Soft Reference）：软引用用于描述还有用但非必需的对象。在内存不足时，垃圾回收器可能会选择回收软引用对象。使用软引用可以实现一些缓存功能，在内存不足时释放缓存中的对象，从而避免 OutOfMemoryError。可以使用 SoftReference 类来创建软引用。
2. 弱引用（Weak Reference）：弱引用的生命周期更短暂，只要垃圾回收器发现一个对象只有弱引用与之关联，就会立即回收该对象。弱引用通常用于实现一些特定的缓存或关联数据结构，当对象的强引用被释放后，关联的弱引用对象也会被自动清除。可以使用 WeakReference 类来创建弱引用。
3. 虚引用（Phantom Reference）：虚引用是最弱的引用类型，几乎没有实际的使用场景。虚引用的主要作用是跟踪对象被垃圾回收的状态。当垃圾回收器决定回收一个对象时，如果该对象有虚引用，将会在对象被回收之前，将虚引用加入到与之关联的引用队列中，供应用程序获取对象回收的状态信息。

在内存管理方面，软引用和弱引用都可以用于解决一些特定的内存问题，例如缓存管理或对象关联。它们对于临时性或可替代性对象的管理非常有用，可以在内存紧张时进行垃圾回收，从而提高系统的性能和可用性。然而，需要注意的是，对于软引用和弱引用对象，程序应该在使用时进行必要的判空和恢复处理，以避免 NullPointerException 和其他相关问题。

ThreadLocal为什么使用弱引用

ThreadLocal 使用弱引用的主要原因是为了避免内存泄漏问题。

当使用强引用持有 ThreadLocal 对象时，只有线程销毁或显式地调用 remove() 方法时，Entry 才会被释放。这可能导致在多线程环境下使用线程池时，即使线程已经使用结束处于空闲状态，对应的 Entry 仍然会存在于 ThreadLocalMap 中，导致无法回收相关资源，从而造成内存泄漏。

使用弱引用作为 ThreadLocal 的键（key），可以解决这个问题。弱引用在垃圾回收时只要发现只有弱引用指向，则会被直接回收。因此，当线程结束且对应的 ThreadLocal 对象只有弱引用存在时，垃圾回收器会自动清理该弱引用，进而清理 ThreadLocalMap 中对应的 Entry。这样可以避免内存泄漏问题。

需要注意的是，尽管 ThreadLocalMap 使用了弱引用来避免内存泄漏问题，但仍然需要在使用 ThreadLocal 后调用 remove() 方法，以确保及时清理 ThreadLocal 对象和对应的值。这是因为弱引用的回收时机不确定，不能完全依赖垃圾回收器的工作。

当我们应该请求进来分配一个线程处理请求，此时ThreadLocal对象就会被创建，并且是一个强引用，当第一次把值存入时ThreadLocal时，就会通过Thread拿到或者创建一个ThreadLocalMap对象，并且存入我们的数据，此时ThreadLocal作为键就会被放入弱引用中，此时就算发送垃圾回收也不会回收ThreadLocal因为有一个强引用指向，但是一旦我们的请求执行完毕返回，线程处于空闲状态时，这个强引用就没了，此时就剩下一个弱引用，这个时候发生垃圾回收就ThreadLocal就会被收回。