使用Kotlin开发的随机密码生成器：设计与实现

OriginCoding

于 2024-12-11 21:06:38 发布

阅读量984

点赞数 27

文章标签： kotlin 开发语言后端

本文链接：https://blog.youkuaiyun.com/qq_47993287/article/details/144385489

版权

前言

在一个应用中，为用户重新设置密码是一个很常见的操作，可以保护用户免受密码泄露的风险。使用随机密码生成器能够生成高强度的密码，并且避免使用其他用户常用的密码，能够进一步降低被攻击的风险。所以我们这次将尝试写一个随机密码生成器。
Kotlin是一门现代的编程语言，结合了面向对象和函数式编程的特性，具有以下的优势：

简洁性：Kotlin的语法结构简洁明了，减少冗余代码，能够提高用户的开发效率。
安全性：Kotlin在语法设计层面考虑到了Null安全，能够有效避免空指针异常。
互操作性：Kotlin与Java高度兼容，开发人员可以在现有的Java项目中无缝集成Kotlin，也可以在使用Kotlin时同时享受Java丰富的生态。
现代特性：Kotlin支持扩展函数、Lambda表达式等现代编程概念，使得代码编写可以更加灵活。
在本篇博客中，我们将从一个最简单的密码生成器开始，对其逐步进行改进，在这个过程中同时学习Kotlin的相关特性。

一：最简单的密码生成器

1. 创建Kotlin项目

首先使用IntelliJ Idea新建一个Gradle项目，并带有示例代码，其中各项参数如下：

Group Id：com.origincoding。
Artifact Id：password-generator。
配置文件语法：Kotlin（.kts文件）。
此时的配置文件如下：

// settings.gradle.kts
plugins {  
    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"  
}  
rootProject.name = "password-generator"

// build.gradle.kts
plugins {  
    kotlin("jvm") version "2.0.21"  
}  
  
group = "com.origincoding"  
version = "1.0-SNAPSHOT"  

repositories { mavenCentral() }  

dependencies { testImplementation(kotlin("test")) }  

tasks.test { useJUnitPlatform() }
kotlin { jvmToolchain(21) }

在导入项目时，可能会因为无法下载Gradle和相关依赖而造成报错，这时可以使用国内的镜像，此时需要修改gradle/wrapper/gradle-wrapper.properties文件，其中distributionUrl一项，修改为腾讯云的仓库链接，我这里使用Gradle 8.10，并且一并下载源码包，修改后的代码如下：

// gradle-wrapper.properties，省略其他配置项
distributionUrl=https://mirrors.cloud.tencent.com/gradle/gradle-8.10-all.zip

同时为了下载依赖，我们需要为Gradle配置仓库地址，修改settings.gradle.kts文件，在后面添如下代码：

dependencyResolutionManagement {
    @Suppress("UnstableApiUsage")
    repositories {
        maven { url = uri("https://maven.aliyun.com/repository/public") }
        maven { url = uri("https://maven.aliyun.com/repository/gradle-plugin") }
        maven { url = uri("https://maven.aliyun.com/repository/apache-snapshots") }
        mavenCentral()
        mavenLocal()
    }
}

同时修改build.gradle.kts文件，修改它的repositories配置项，改为如下代码：

repositories {
    maven { url = uri("https://maven.aliyun.com/repository/public") }
    maven { url = uri("https://maven.aliyun.com/repository/gradle-plugin") }
    maven { url = uri("https://maven.aliyun.com/repository/apache-snapshots") }
    mavenCentral()
    mavenLocal()
}

此时能够正常加载项目，由于我们在创建项目时勾选了“带有示例代码”选项，因此此时Main.kt文件中带有一个main方法和一些示例代码，我们直接运行，会在命令行直接打印如下内容：

Hello, Kotlin!
i = 1
i = 2
i = 3
i = 4
i = 5

2. 使用函数直接生成密码

我们这里定义一个函数，名为generateRandomPassword，其实现如下：

fun generateRandomPassword(): String {  
    val chars = ('a'..'z') + ('A'..'Z') + ('0'..'9')  
    return (1..8)  
        .map { chars.random() }  
        .joinToString("")  
}

这段函数使用到的Kotlin特性如下：

范围语法

在Kotlin中，基本类型如Char、Int、Float等，以及实现了Comparable接口的可比较对象，可以通过a .. b的方法构造一个范围（包含a和b）。
而像Char、Int和Long这三种类型，可以算作算数级数（Arithmetic Progressions），Kotlin会自动生成一个包含其中所有元素的集合（类型分别是CharProgression、IntProgression和LongProgression）。这部分语法可以参考Kotlin Ranges相关文档。

扩展方法

Kotlin的扩展方法是提高代码灵活性的重要特性，它可以快速地为已有的对象添加新的行为。比如map方法可以用于将集合中的元素转换为新的元素，random方法用于快速从集合中随机获取元素，joinToString方法用于将集合中的元素连接成字符串。
值得注意的是，map方法和random方法的签名分别如下：

inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

inline fun <T> Collection<T>.random(): T

这里的inline关键字可以将方法进行内联，内联的方法将在编译时直接复制到调用处，而不是进行一次函数调用。这样做可以提高代码性能，也可以减少一层语句层级（在使用协程时会用到），同时也可以配合refied关键字进行泛型类型的推导，这部分的代码可以参考Kotlin扩展方法和扩展属性以及Kotlin内联函数。

操作符重载和中缀函数

在定义chars变量时，我们将三个CharProgression使用+连接成了一个List<Char>类型的列表，如果在Idea里按住Ctrl并单击这个加号，我们可以跳转到一个方法定义，其参数如下：

operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T>

这里同样是一个扩展方法，不过前面的operator关键字标明这是一个操作符重载，详细说明和可以重载的操作符可以参考Kotlin操作符重载。同时这个函数也是一个中缀函数，其顺序为（参数1-函数-参数2），一个中缀函数必须满足以下条件：

必须是成员方法或者是扩展方法。
只能有一个参数。
不能接受可变长度参数（使用vararg关键字定义的参数），并且不能有任何的默认值。
中缀函数、可变长关键字和默认参数都可以参考Kotlin函数。

3. 测试基础功能

我们修改main函数，新的函数体如下：

fun main() {  
    repeat(5) {  
        println(generateRandomPassword())  
    }  
}

其中repeat函数表示重复执行某个动作。执行main函数后，一个可能的输出如下：

errqi2C2
JrAgC9nb
KfAdhiOa
Izp8NWlJ
NOoau0P4

4. 使用RandomStringGenerator实现

Apache Commons Text提供了一些常用的组件，用于处理和生成随机文本，我们的随机密码生成器将基于其中的RandomStringGenerator实现。与我们之前写的密码生成函数相比，RandomStringGenerator可以控制生成随机字符串的细节，比如使用的字符集合、长度、随机数生成器等。从下一章开始，我们将基于RandomStringGenerator来讨论如何实现一个更加完备的密码生成器。

二：完善生成函数的功能

1. 可以配置的参数

对于一个密码生成器来说，可以配置的参数主要有以下几种：

密码的长度：需要可以指定密码的长度范围。
字符内容：包括可选的字符集，必选的字符等。
密码的数量：可能需要短时间快速生成多个密码。
在这篇文章中，对于条件1和条件3，没有过多需要配置的内容，可以快速实现；对于条件2，我们将字符集限制在字母（大写字母和小写字母）、数字、特殊字符，并且可以指定需要的最少字符集。为了安全起见，我们将限制生成器，必须最少指定这四类字符中的两种。

2. 实现参数校验

首先引入Apache Commons Text，修改build.gradle.kts文件，在dependencies配置项下添加如下内容：

dependencies {
    // 省略测试用到的依赖
    // Apache Commons Text for generating password.  
    implementation("org.apache.commons:commons-text:1.12.0")  
}

如果直接写的话可能会这样实现函数的签名：

fun generatePassword(  
    minLength: Int = 8,  
    maxLength: Int = 16,  
    uppercase: Boolean = true,  
    lowercase: Boolean = true,  
    digits: Boolean = true,  
    specialChars: Boolean = true
    count: Int = 1  
): String {  
    return ""  
}

然而，如果将所有参数都直接列出，可能会导致配置选项过于繁琐。此外，字符集的选项如果直接写在函数签名中，后续的参数校验将变得更加复杂。因此，我们决定将字符集部分的参数单独提取，采用对象的形式进行传递。新的函数签名如下：

// 字符集相关配置项
data class CharacterOptions(  
    val uppercase: Boolean = true,  
    val lowercase: Boolean = true,  
    val digits: Boolean = true,  
    val specialChars: Boolean = true  
)

// 新的函数签名
fun generatePassword(  
    minLength: Int = 8,  
    maxLength: Int = 16,  
    characterOptions: CharacterOptions = CharacterOptions(),  
    count: Int = 1  
): String {  
    return ""  
}

新的函数签名如下，我们将基于此实现参数校验功能，首先是密码长度和数量的校验，这部分比较简单：

fun generatePassword() {
    // 对密码长度进行校验  
    require(minLength > 3) { "最小长度不能小于4！" }  
    require(maxLength < 33) { "最大长度不能大于32！" }  
    require(minLength <= maxLength) { "最大长度不能小于最小长度！" }
    // 对生成的密码数量进行校验  
    require(count > 0) { "密码数量不能小于0！" }
}

限制密码的最小长度是为了确保其安全性，防止密码被快速破解。而限制最大长度是因为，虽然增加密码长度可能在一定程度上提高安全性，但超过一定长度后，其安全性提升并不显著，同时会显著增加生成时间。因此，出于性能考虑，我们对密码的最大长度进行了限制。
对于字符集数量的校验，我们可以将选择的字符集数量单独抽离出来，用字符集数量来表示，同时要求字符集数量不能小于等于1即可：

data class CharacterOptions(  
    val uppercase: Boolean = true,  
    val lowercase: Boolean = true,  
    val digits: Boolean = true,  
    val specialChars: Boolean = true  
) {  
    fun characterTypes(): Int {  
        return arrayOf(specialChars, uppercase, lowercase, digits).count { it }  
    }  
}

fun generatePassword() {
    // 对字符集类型进行校验  
    require(characterOptions.characterTypes() > 1) { "至少选择两种类型的字符！" }
}

上面的characterTypes表示我们实现的字符集。将各个配置项合并为一个数组，其中为true的元素对应着有效的字符集数量。Kotlin中的许多类型都有名为count的扩展函数，它接收一个Predicate类型的参数，用于统计校验结果为true的元素数量。需要注意的是，如果仅仅是统计元素数量，直接使用size属性会更简洁高效。使用count函数来返回为true的元素数量显得多余。
接下来，我们将根据这段函数的定义，逐步实现密码生成器的功能。

3. 实现函数功能

Apache Commons Text的RandomStringGenerator使用了建造者模式，所有的设置都通过他的builder()方法返回的Builder实现。在旧版本中，使用build()方法获取到设置好的RandomStringGenerator，但是这个方法现在被废弃了，改为使用get()方法。因此我们的大概实现如下（只考虑生成一次密码）：

fun generatePassword(): String {
    val generator = RandomStringGenerator.builder().get();
    return generator.generate(minLength, maxLength)
}

RandomStringGenerator.Builder提供了以下设置选项（部分设置未被列出）：

selectFrom(vararg chars: Char)：一次性设置所有的可选字符。
withinRange(vararg pairs: CharArray)：设置可选字符，其中每个元素都是一个CharArray，要求只能有两个元素，分别是可选字符的开始和结束范围（包含两端）。
filterBy(vararg predicates: CharPredicate)：对于设置的随机字符进行筛选，如果不传参，则表示允许所有设置的字符。
usingRandom(random: TextRandomProvider)：自定义随机数的实现。如果不指定，则默认使用ThreadLocalRandom生成随机数。
因为这次的字符集已经确定，而且数量比较多，所以我们使用withinRange方法实现字符集的选择过程。对于生成多个随机密码，我们可以使用列表实现，最终代码如下：

fun generatePassword(  
    minLength: Int = 8,  
    maxLength: Int = 16,  
    characterOptions: CharacterOptions = CharacterOptions(),  
    count: Int = 1  
): List<String> {  
    // 对密码长度进行校验  
    require(minLength > 3) { "最小长度不能小于4！" }  
    require(maxLength < 33) { "最大长度不能大于32！" }  
    require(minLength <= maxLength) { "最大长度不能小于最小长度！" }  
  
    // 对字符集类型进行校验  
    require(characterOptions.characterTypes() > 1) { "至少选择两种类型的字符！" }  
  
    // 对生成的密码数量进行校验  
    require(count > 0) { "密码数量不能小于0！" }  
  
    val charArrays = mutableListOf<CharArray>()  
    if (characterOptions.uppercase) {  
        charArrays.add(charArrayOf('A', 'Z'))  
    }  
    if (characterOptions.lowercase) {  
        charArrays.add(charArrayOf('a', 'z'))  
    }  
    if (characterOptions.digits) {  
        charArrays.add(charArrayOf('0', '9'))  
    }  
    if (characterOptions.specialChars) {  
        charArrays.add(charArrayOf('!', '!'))  
        charArrays.add(charArrayOf('#', '&'))  
        charArrays.add(charArrayOf('*', '/'))  
        charArrays.add(charArrayOf(':', '@'))  
        charArrays.add(charArrayOf('^', '^'))  
        charArrays.add(charArrayOf('|', '|'))  
        charArrays.add(charArrayOf('~', '~'))  
    }  
  
    val generator = RandomStringGenerator.builder().withinRange(*charArrays.toTypedArray()).get()  
  
    val list = mutableListOf<String>()  
    for (i in 1..count) {  
        val password = generator.generate(minLength, maxLength)  
        list.add(password)  
    }  
  
    return list  
}

4. 测试功能

我们修改Main.kt文件，将main方法修改如下：

fun main() {  
    generatePassword(count = 5).forEach {  
        println(it)  
    }  
}

执行之后，一个可能的输出如下：

tcuP+E^>r3GUEqU
elBbw@aZ?PQ
$?#5ed38K-K
Y,p4sSjg-0Ne
U;cVXGvl&>s!v0

可以看到，密码生成器能够正常工作。

三：优化代码，为发布做准备

在本章中，我们将对之前编写的代码进行优化，使其更加高效，并为发布做准备。我们将利用Kotlin的特性来改进代码，同时补充一些工程实现上的细节，以便将其作为一个公共基础库发布。

1. 使用Kotlin特性优化代码

使用属性替代成员函数

对于CharacterOptions这个数据类型，我们之前将其定义为不可变的，而且里面所有字段都是只读的，因此其中为true的选项数量已经确定。这时，我们可以考虑使用Kotlin的属性，将它的characterTypes定义为只读属性。这样做的好处如下：

意图明确：属性表示某种状态或特征，而函数表示某种行为，将characterTypes定义为属性，更为清晰地传达它是对于CharacterOptions的状态描述。
性能优化：使用lazy将属性定义为惰性属性，可以在第一次计算之后缓存结果，从而提高性能。
提高可读性：作为属性，可以像访问变量一样直接访问characterTypes的值，进一步增强代码的可读性。
我们将characterTypes函数更改为属性，其代码如下：

data class CharacterOptions(  
    val uppercase: Boolean = true,  
    val lowercase: Boolean = true,  
    val digits: Boolean = true,  
    val specialChars: Boolean = true  
) {  
    val characterTypes: Int by lazy {  
        arrayOf(specialChars, uppercase, lowercase, digits).count { it }  
    }
}

与之前的成员函数相比，获取字符类型的逻辑并未改变。不过，使用by关键字，表明这是一个委托属性，它的数据获取交给lazy函数返回的Lazy实现，从而将计算结果缓存，提高了代码的性能。
修改后的generatePassword函数如下所示：

// 省略参数和其他操作
fun generatePassword(): List<String> {
    require(characterOptions.characterTypes > 1) { "至少选择两种类型的字符！" }
}

使用扩展方法插入CharArray

判断条件成立后，向charArrays中添加字符数组的操作，可以使用扩展函数实现，将其封装为名为addAllIf的扩展函数。这样做的好处如下：

代码复用：将操作封装之后，可以在其他地方复用这个方法，避免重复编写相同的逻辑。
提高可读性：使用扩展方法后，代码的意图更加明确。对于addAllIf函数，我们见名知意，了解这是一个在满足条件后添加所有元素的操作。
同时，为了减少一次调用的堆栈操作，我们将其定义为内联函数，封装后的代码如下：

inline fun <T> MutableList<T>.addAllIf(vararg element: T, 
                                       condition: () -> Boolean) {  
    if (condition()) {  
        this.addAll(element)  
    }  
}

同时更新generatePassword函数代码如下：

// 省略参数和其他操作
fun generatePassword(): List<String> {
    val charArrays = mutableListOf<CharArray>()  
    charArrays.addAllIf(charArrayOf('a', 'z')) { characterOptions.lowercase }  
    charArrays.addAllIf(charArrayOf('A', 'Z')) { characterOptions.uppercase }  
    charArrays.addAllIf(charArrayOf('0', '9')) { characterOptions.digits }  
    charArrays.addAllIf(  
        charArrayOf('!', '!'),  
        charArrayOf('#', '&'),  
        charArrayOf('*', '/'),  
        charArrayOf(':', '@'),  
        charArrayOf('^', '^'),  
        charArrayOf('|', '|'),  
        charArrayOf('~', '~'),  
    ) {  
        characterOptions.specialChars  
    }
}

使用Sequence替代列表

之前我们使用列表进行操作，并且只进行了count次生成，并未对生成结果进行校验。可能在传参的时候允许某些字符出现，但是并没有在生成的密码中，因此我们需要对生成的密码进行校验。因为不确定是否有足够的密码生成，我们可以使用while来无限生成密码，并在数量满足要求时结束循环。如果要实现这样的功能，我们可以使用Sequence实现，其惰性求值的特性也能够进一步提高代码的性能。
为了无限生成密码，我们使用generateSequence函数，它接收一个生成其中元素的函数，并在函数的返回值为null时停止调用函数。其签名如下：

fun <T : Any> generateSequence(nextFunction: () -> T?): Sequence<T>
// 下面这个重载用于指定第一个元素的值
fun <T : Any> generateSequence(seed: T?, nextFunction: (T) -> T?): Sequence<T>

需要注意的是，如果nextFunction永不返回null，那么这个Sequence就是无限的，它的一些操作比如count等会不可用，调用时会报错。
对于生成的Sequence，它的各项操作与Iterable的区别不大，我们同样可以使用filter函数对其生成的密码进行校验，不再返回不通过校验的密码。
最后使用take函数获取指定数量的元素，然后使用toList函数将所有元素汇集成一个列表。
最终我们的生成函数如下：

fun generatePassword(  
    minLength: Int = 8, maxLength: Int = 16, characterOptions: CharacterOptions = CharacterOptions(), count: Int = 1  
): List<String> {  
    // 对密码长度进行校验  
    require(minLength > 3) { "最小长度不能小于4！" }  
    require(maxLength < 33) { "最大长度不能大于32！" }  
    require(minLength <= maxLength) { "最大长度不能小于最小长度！" }  
  
    // 对字符集类型进行校验  
    require(characterOptions.characterTypes > 1) { "至少选择两种类型的字符！" }  
  
    // 对生成的密码数量进行校验  
    require(count > 0) { "密码数量不能小于0！" }  
  
    val charArrays = mutableListOf<CharArray>()  
    charArrays.addAllIf(charArrayOf('a', 'z')) { characterOptions.lowercase }  
    charArrays.addAllIf(charArrayOf('A', 'Z')) { characterOptions.uppercase }  
    charArrays.addAllIf(charArrayOf('0', '9')) { characterOptions.digits }  
    charArrays.addAllIf(  
        charArrayOf('!', '!'),  
        charArrayOf('#', '&'),  
        charArrayOf('*', '/'),  
        charArrayOf(':', '@'),  
        charArrayOf('^', '^'),  
        charArrayOf('|', '|'),  
        charArrayOf('~', '~'),  
    ) {  
        characterOptions.specialChars  
    }  
  
    val generator = RandomStringGenerator.builder().withinRange(*charArrays.toTypedArray()).get()  
    return generateSequence {  
        generator.generate(minLength, maxLength)  
    }.filter {  
        (it.any { char -> char.isUpperCase() } || !characterOptions.uppercase) &&  
                (it.any { char -> char.isLowerCase() } || !characterOptions.lowercase) &&  
                (it.any { char -> char.isDigit() } || !characterOptions.digits) && 
                (it.any { char -> !char.isLetterOrDigit() } || !characterOptions.specialChars)  
    }.take(count).toList()  
}

2. 提高代码的工程性

在前面的博客中，我们实现了一个随机密码生成器。虽然该生成器目前不支持自定义生成细节，例如字符集和生成规则，但它依然能够满足大多数用户的需求。现在，我们可以考虑将这段代码打包成一个库，以便其他人使用。当然，在正式发布之前，我们还有一些地方需要进行修改和完善。接下来，让我们逐步对代码进行改进。

生成单个密码

我们之前的代码更适用于需要批量生成密码的场景，但是同样有很多情况下，我们只需要临时生成一个新的密码即可。我们可以考虑为generatePassword提供一个重载，只生成一个密码，然后直接返回。
新的重载的具体实现如下：

fun generatePassword(  
    minLength: Int = 8, maxLength: Int = 16, characterOptions: CharacterOptions = CharacterOptions()
): String {  
    // 对密码长度进行校验  
    require(minLength > 3) { "最小长度不能小于4！" }  
    require(maxLength < 33) { "最大长度不能大于32！" }  
    require(minLength <= maxLength) { "最大长度不能小于最小长度！" }  
  
    // 对字符集类型进行校验  
    require(characterOptions.characterTypes > 1) { "至少选择两种类型的字符！" }  
  
    val charArrays = mutableListOf<CharArray>()  
    charArrays.addAllIf(charArrayOf('a', 'z')) { characterOptions.lowercase }  
    charArrays.addAllIf(charArrayOf('A', 'Z')) { characterOptions.uppercase }  
    charArrays.addAllIf(charArrayOf('0', '9')) { characterOptions.digits }  
    charArrays.addAllIf(  
        charArrayOf('!', '!'),  
        charArrayOf('#', '&'),  
        charArrayOf('*', '/'),  
        charArrayOf(':', '@'),  
        charArrayOf('^', '^'),  
        charArrayOf('|', '|'),  
        charArrayOf('~', '~'),  
    ) {  
        characterOptions.specialChars  
    }  
  
    val generator = RandomStringGenerator.builder().withinRange(*charArrays.toTypedArray()).get()  
    return generateSequence {  
        generator.generate(minLength, maxLength)  
    }.filter {  
        (it.any { char -> char.isUpperCase() } || !characterOptions.uppercase) &&  
                (it.any { char -> char.isLowerCase() } || !characterOptions.lowercase) &&  
                (it.any { char -> char.isDigit() } || !characterOptions.digits) && 
                (it.any { char -> !char.isLetterOrDigit() } || !characterOptions.specialChars)  
    }.first()
}

修改的地方有以下几点：

修改函数的签名，删除count参数，并将返回值类型改为String。
删除对于count参数的校验操作。
生成密码时，过滤掉不符合要求的密码之后，使用first函数获取第一个元素。

抽象公共代码，隐藏私有API

上面的代码和原来生成多个密码的重载有很多重复的地方，因此需要将重复部分单独提取出来。经过分析，我们不难看出，generatePassword函数生成密码的流程由以下步骤组成：

进行参数校验。
构造RandomStringGenerator。
使用生成密码，对密码进行过滤，筛选出符合条件的密码。
返回最终结果。
其中第一、二步，和第三步的过滤密码操作都有很多重复的逻辑，我们可以将这部分单独抽出来。对于第一、二步，我们可以抽象成buildGenerator函数，对于过滤密码的操作，我们可以抽象成passwordIsValidate函数，他们两个的代码分别如下：

internal fun buildGenerator(  
    minLength: Int, maxLength: Int, characterOptions: CharacterOptions, count: Int  
): RandomStringGenerator {  
    // 对密码长度进行校验  
    require(minLength > 3) { "最小长度不能小于4！" }  
    require(maxLength < 33) { "最大长度不能大于32！" }  
    require(minLength <= maxLength) { "最大长度不能小于最小长度！" }  
  
    // 对字符集类型进行校验  
    require(characterOptions.characterTypes > 1) { "至少选择两种类型的字符！" }  
  
    // 对生成的密码数量进行校验  
    require(count > 0) { "密码数量不能小于0！" }  
  
    // 确定使用的字符集  
    val charArrays = mutableListOf<CharArray>()  
    charArrays.addAllIf(charArrayOf('a', 'z')) { characterOptions.lowercase }  
    charArrays.addAllIf(charArrayOf('A', 'Z')) { characterOptions.uppercase }  
    charArrays.addAllIf(charArrayOf('0', '9')) { characterOptions.digits }  
    charArrays.addAllIf(  
        charArrayOf('!', '!'),  
        charArrayOf('#', '&'),  
        charArrayOf('*', '/'),  
        charArrayOf(':', '@'),  
        charArrayOf('^', '^'),  
        charArrayOf('|', '|'),  
        charArrayOf('~', '~'),  
    ) {  
        characterOptions.specialChars  
    }  
  
    // 构造Generator，生成密码  
    return RandomStringGenerator.builder()
        .withinRange(*charArrays.toTypedArray<CharArray>())
        .get()  
}

internal fun passwordIsValid(
    password: String, characterOptions: CharacterOptions
): Boolean {  
    return password.let {  
        (it.any { char -> char.isUpperCase() } || !characterOptions.uppercase) &&  
                (it.any { char -> char.isLowerCase() } || !characterOptions.lowercase) &&  
                (it.any { char -> char.isDigit() } || !characterOptions.digits) &&  
                (it.any { char -> !char.isLetterOrDigit() } || !characterOptions.specialChars)  
    }  
}

这里使用internal关键字修饰函数签名，表明这两个函数只在模块内可以共享，无法在外部直接调用。我们只暴露generatePassword作为外部API，而不暴露内部实现细节，这样可以更好地封装代码。修改后的generatePassword函数的两个重载如下：

fun generatePassword(  
    minLength: Int = 8, maxLength: Int = 16, characterOptions: CharacterOptions = CharacterOptions(), count: Int = 1  
): List<String> {  
    val generator = buildGenerator(minLength, maxLength, characterOptions, count)  
  
    return generateSequence {  
        generator.generate(minLength, maxLength)  
    }.filter {  
        passwordIsValid(it, characterOptions)  
    }.take(count).toList()  
}  

fun generatePassword(  
    minLength: Int = 8, maxLength: Int = 16, characterOptions: CharacterOptions = CharacterOptions()  
): String {  
    val generator = buildGenerator(minLength, maxLength, characterOptions, 1)  
    return generateSequence {  
        generator.generate(minLength, maxLength)  
    }.filter {  
        passwordIsValid(it, characterOptions)  
    }.first()  
}

这两个函数的重载都只考虑到了密码长度在一个范围内浮动的情况，有时候也需要生成定长的密码，我们也可以添加下面两个重载：

fun generatePassword(  
    length: Int = 16, characterOptions: CharacterOptions = CharacterOptions(), count: Int = 1  
): List<String> = generatePassword(length, length, characterOptions, count)  
  
  
fun generatePassword(  
    length: Int = 16, characterOptions: CharacterOptions = CharacterOptions()  
): String = generatePassword(length, length, characterOptions)

添加文档和注释

考察一段代码的工程性，不能只看代码的组织度，代码的注释和文档也至关重要。在这里我们将使用KDoc为代码添加注释，并为项目编写Readme文档。Kotlin的文档注释语法和Java相同，都是使用/**开头，以*/结束，它的一些标签如下：

@param：函数或方法的参数。
@return：函数或方法的返回值。
@property：一个类的属性，可以在CharacterOptions数据类中用到。
除了文档和注释以外，测试也是保证代码质量的重要手段。下一章我们将详细讨论测试的部分，包括功能测试和基准测试。在测试之后，我们将讨论如何发布代码，以便其他用户使用。

四：测试和发布代码

在编写这个随机密码生成器时，编写功能测试和基准测试同样至关重要。功能测试可以验证密码生成器的每个功能是否按预期工作，确保生成的密码符合安全要求，并及时发现代码中的错误。而基准测试则用于评估密码生成器的性能，确保在不同负载下能够快速生成密码，并识别潜在的性能瓶颈。下面我们将继续实现测试部分，并在测试通过之后发布代码。

1. 实现功能测试

我们这里使用Kotest实现功能测试。Kotest是一个针对Kotlin语言的跨平台测试框架，支持多种风格的测试代码，同时多样的断言和扩展也能进一步提高开发效率。

引入Kotest

首先引入Kotest，修改build.gradle.kts，添加如下内容：

tasks.withType<Test>().configureEach {
   useJUnitPlatform()
}

tasks.test {  
    useJUnitPlatform()  
}

上面两段代码二选一即可，下面的是创建项目时自动生成的代码。然后添加Kotest的依赖：

dependencies {
    // 省略其他依赖
    testImplementation("io.kotest:kotest-runner-junit5:5.9.1")  
}

编写测试代码

Kotest有多种测试代码风格，我们这里选择第一种FunSpec，如果读者有使用JUnit的经验，可以考虑使用AnnotationSpec，下面我们将为以下场景编写示例代码：

测试生成单个固定长度密码时，其密码长度符合要求。
测试生成多个密码时，列表大小符合要求。
测试生成密码参数不正确时，能够及时触发异常。
首先是密码长度的测试，我们给出如下的测试用例：

@file:Suppress("Unused")  
  
package functional  
  
import com.origincoding.generatePassword  
import io.kotest.assertions.throwables.shouldThrow  
import io.kotest.core.spec.style.FunSpec  
import io.kotest.inspectors.forAll  
import io.kotest.matchers.string.shouldHaveLength  
import io.kotest.matchers.string.shouldHaveMaxLength  
import io.kotest.matchers.string.shouldHaveMinLength  
  
class PasswordGeneratorTest : FunSpec({  
    test("生成单个密码，固定长度下的长度需要符合要求") {  
        generatePassword(length = 8) shouldHaveLength 8  
    }

    test("生成一定范围长度的固定数量密码，数量需要符合要求") {  
        generatePassword(minLength = 8, maxLength = 32, count = 10) shouldHaveSize 10
    }

    test("只有一种字符集时，将会报错") {  
        shouldThrow<IllegalArgumentException> {  
            generatePassword(  
                characterOptions = CharacterOptions(  
                    uppercase = false,  
                    lowercase = false,  
                    digits = false,  
                    specialChars = true  
                )  
            )  
        }  
    }
}

上述代码的说明如下：

测试类继承FunSpec类，并在构造方法中传入body参数作为测试内容。
使用test函数定义测试用例，这里的用例名称不能为空。
使用shouldHaveLength断言验证字符串的长度。Kotest的断言一般会返回需要检验的对象，这使我们对同一个值进行多次断言。
使用shouldHaveSize对集合大小进行断言。
使用shouldThrow断言验证抛出的异常，泛型参数为预期发生的异常。同时这个函数会返回抛出的异常本身，可以用来对异常内容进行断言。

测试代码功能

执行Gradle的test命令，可以看到测试的执行结果，也可以在/build/report/tests/index.html文件中查看测试报告。
我们这里为了演示，只编写了三个测试用例。实际情况，下我们需要编写更多的测试，以覆盖开发过程中可能遇到的边界情况。这部分代码可以参考GitHub仓库的代码。
Kotest提供了用于生成测试报告的扩展，用以覆盖Gradle本身的测试报告，具体细节参见文档。

2. 实现基准测试

我们使用Kotlinx Benchmark实现基准测试，这是Kotlin官方提供的基准测试库。

引入Kotlinx Benchmark

因为这段代码基于JVM，所以我们只需要引入JVM平台的测试运行时即可。
首先调整repository的顺序，在有些情况下，可能无法在镜像中找到Kotlinx Benchmark，因此我们将Maven Central仓库放在最前面：

repositories {  
    // Kotlinx Benchmark's runtime cannot be found in Aliyun's Maven repository.  
    mavenCentral()  
    maven { url = uri("https://maven.aliyun.com/repository/public") }  
    maven { url = uri("https://maven.aliyun.com/repository/gradle-plugin") }  
    maven { url = uri("https://maven.aliyun.com/repository/apache-snapshots") }  
    mavenLocal()  
}

然后引入Kotlinx Benchmark的运行时，以及需要的All Open插件和Kotlinx Benchmark插件：

plugins {  
    // Kotlin的插件省略
    kotlin("plugin.allopen") version "2.0.21"  
    id("org.jetbrains.kotlinx.benchmark") version "0.4.12"  
}

dependencies {  
    // 省略其他依赖
    // Kotlinx Benchmark's runtime dependency.  
    implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.12")  
}

最后配置Kotlinx Benchmark：

kotlin {  
    jvmToolchain(21)  
    sourceSets {  
        dependencies {  implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.4.12") }
    }
} 
  
sourceSets.configureEach {  
    java.setSrcDirs(listOf("$name/src"))  
    resources.setSrcDirs(listOf("$name/resources"))  
}  
  
configure<AllOpenExtension> { annotation("org.openjdk.jmh.annotations.State") }
  
benchmark {  
    configurations {  
        named("main") {  
            iterationTime = 5  
            iterationTimeUnit = "sec"  
        }  
    }    
    targets {  
        register("main") {  
            this as JvmBenchmarkTarget  
            jmhVersion = "1.21"  
        }  
    }
}

编写测试代码

对于generatePassword函数，我们主要有两个测试的方向：一个是生成单个密码的速度，这能保证在单次调用时能够快速响应；另一个是大批量生成密码时的执行时间，避免大量生成密码延长执行时间，降低性能。对于后者，我们将考察它连续生成20万个密码的执行效率。这两个用例对应的测试代码如下：

@file:Suppress("Unused")  
  
package com.origincoding.benchmark  
  
import com.origincoding.CharacterOptions  
import com.origincoding.generatePassword  
import kotlinx.benchmark.Benchmark  
import kotlinx.benchmark.BenchmarkMode  
import kotlinx.benchmark.Mode  
import kotlinx.benchmark.State  
import org.openjdk.jmh.annotations.Scope  
  
@BenchmarkMode(Mode.Throughput, Mode.AverageTime)  
@State(Scope.Benchmark)  
internal class PasswordBenchmark {  
    companion object {  
        val characterOptions = CharacterOptions()  
    }  
  
    @Benchmark  
    fun generateMultiplePassword(): List<String> =  
        generatePassword(characterOptions = characterOptions, count = 20_0000)

    @Benchmark  
    fun generateSinglePassword(): String = 
        generatePassword(characterOptions = characterOptions)
}

上述代码说明如下：

使用BenchmarkMode注解设置基准测试采用的标准。其中Throughput表示一秒内执行的次数，AverageTime表示单词执行的时间。
使用@State(Scope.Benchmark)表明这是一个基准测试类。
使用Benchmark注解标注基准测试的测试用例，函数本身就是要进行基准测试的操作。

测试代码功能

执行Gradle的benchmark命令，可以查看测试报告。测试在作者的笔记本电脑上进行，配置如下：

CPU：Intel® Core™ i5-1135G7。
内存：16GB，由于打开IDE等其他操作，实际可用内存在5GB左右。
语言运行时：Java 21、Kotlin 2.0.21。
最终执行的基准测试结果如下：

测试功能	测试模式	执行结果
生成单个密码	Throughput	每秒约11万次
生成多个密码	Throughput	每秒约12次
生成单个密码	AverageTime	约10e-6秒
生成多个密码	AverageTime	约0.08秒
可以看到，单次执行时间大概在1微妙左右，连续生成20万个密码也只需要0.08秒即可完成，这证明我们编写的`generatePassword`函数能够满足大多数场景下的性能需求。

3. 发布代码

实现了测试之后，我们需要将它发布出去，以便其他用户使用。我们使用Gradle的Maven Publish插件实现发布功能。
首先修改版本号，改为1.0.0：

version = "1.0.0"

然后引入Maven Publish插件，并进行配置：

plugins {
    `maven-publish`
}

// 附带源码Jar包，如果需要发布Java Doc Jar包，在代码块里添加：withJavadocJar()  
java { withSourcesJar() }    
  
publishing {  
    publications {  
        create<MavenPublication>("bootJava") { from(components["java"]) }  
    }
}

作者因为没有Maven Repository的账号，因此只能发布到本地仓库。执行Gradle的publishToMavenLocal命令，即可将代码发布到本地仓库中。
后续其他的项目可以使用如下配置引入：

dependencies {
    implementation("com.origincoding:password-generator:1.0.0")
}

五：总结

在前面的文章中，我们使用Kotlin和Apache Commons Text库，实现了一个功能完备的代码生成函数。它支持选择字符集、指定密码长度和数量这三个功能。之后我们使用Kotest和Kotlinx Benchmark库对它的功能和性能进行了测试。测试结果表明我们编写的密码生成函数，能够满足实际开发需求中的使用场景，也能具有足够的性能。
下面是读者后续可以进行的扩展方向：

自定义字符集合：我们现在编写的生成函数只能使用少数几个字符集，读者可以考虑修改代码，让用户能够传入自定义的字符集合。需要注意的是，RandomStringGenerator接受的CharArray数组，其中的每个元素，也就是每个CharArray，都只能有两个元素，表示范围的开始和结束区间。如果数量不满足需求，那么会在运行时报错。
自定义随机数生成器：现在我们使用的是RandomStringGenerator的默认随机数实现，即ThreadLocalRandom。这个实现能够满足并发场景下的需求，但是如果读者有额外的需求，可以考虑自定义随机数实现方法。
实现Property Testing：因为接收参数时进行了校验，因此我们只需要少数几个测试用例即可完全覆盖场景。如果改为自定义字符集或者随机数实现，那么可能需要考虑大量的边界条件。这时可以考虑使用Kotest的Property Testing，它提供了一种进行模糊测试的方法。