vlambda博客
学习文章列表

Kotlin 语言旨在维护与 Java 代码的互操作性。这意味着我们可以开始在 Kotlin 文件中使用 Java 惯用语进行编码。

该语言是静态类型的，它是一个极好的属性，因为它可以帮助我们在编译时发现一些问题。此外，静态类型语言比动态语言快得多。 IDE 也可以比动态语言更好地帮助开发人员。

var bookName: String

val book = "Spring 5.0 by Example"

val book = "Spring 5.0 by Example"
var bookName: String
println("Hello, world!")

在 Kotlin 中，有 classes 和函数。然而，已经没有办法了。 fun 关键字应该用于声明一个函数。

Kotlin 获得了 Scala 语言的一些概念，并带来了一些特殊的类，例如 Data 类和 Object 类（我们将很快学习这些类） ）。在此之前，我们将了解如何在 Kotlin 中声明一个函数。让我们这样做！

fun greetings(name:String,greeting:String):String{
  return greeting + name
}

public String greetings(String name,String greeting){
  return greeting + name;
}

fun printGreetings(name:String,greeting:String):Unit{
  println(greeting + name)
}

fungreetings(name:String,greeting:String) = greeting + name

open class Greetings {
open fun greeting() {}
}

class SuperGreeting() : Greetings() {
  override fun greeting() {
  // my super greeting
  }
}

Data classes

当我们想要在系统层之间保存和传输 数据时，数据类是正确的解决方案。与 Scala 一样，这些类提供了一些内置功能，例如 getters/setters、equals 和 hashCode、toString 方法和 copy 函数。

 

让我们为此创建一个示例：

data class Book(valauthor:String,valname:String,valdescription:String,valnew:Boolean = false)

Copy

我们在代码中有一些有趣的东西。我们注意到的第一件事是所有属性都是不可变的。这意味着所有这些都没有二传手。第二个是在类声明中，我们可以看到一个属性列表。在这种情况下，Kotlin 将创建一个包含该类中存在的所有属性的构造函数，因为它们是 val，所以它意味着最终属性。

在这种情况下，不再有默认构造函数。

Kotlin 中另一个有趣的特性是它使开发人员能够在构造函数上使用默认值，在我们的例子中，new 属性，如果省略，将假定 假 值。我们也可以在函数的参数列表中获得相同的行为。

最后，还有一种复制对象的绝妙方法。 copy 方法允许开发人员复制带有命名参数的对象。这意味着我们只能根据需要更改属性。让我们看一个例子：

funmain(args : Array<String>) {
  val springFiveOld = Book("Claudio E. de Oliveira","Spring 5.0 by Example","Amazing example of Spring Boot Apps",false)
val springFiveNew = springFiveOld.copy(new = true)
println(springFiveOld)
println(springFiveNew)
}

Copy

在第一个对象中，我们为 new 属性创建了一个带有 false new 属性的书籍实例，然后我们复制了一个新的true 为 new 属性的对象，其他属性不变。告别复杂的克隆逻辑，迎接新的对象复制方式。

此代码的输出应如下所示：

正如我们所看到的，只有 new 属性发生了变化，并且 toString 函数也以良好的形式生成。

Data 类有一些限制。它们不能是抽象的、开放的、密封的或内在的。

 

object BookNameFormatter{
  funformat(book: Book):String = "The book name is" + book.name
}

val springFiveOld = Book("Claudio E. de Oliveira","Spring 5.0 by Example","Amazing example of Spring Boot Apps",false)
BookNameFormatter.format(springFiveOld)

data class Book(valauthor:String,valname:String,val description:String,valnew:Boolean = false{

companion object {
    funcreate(name:String,description: String,author: String):Book{
      return Book(author,name,description)
    }
  }

}

val myBookWithFactory = Book.create("Claudio E. de Oliveira","Spring 5.0 by Example","Amazing example of Spring Boot Apps")

Koltin 习语是 Java 程序员的一种语法糖。它是一组代码，可帮助开发人员用 Kotlin 语言创建简洁的代码。我们来看看常见的 Kotlin 习语。

val bookName = "Spring 5.0"
val phrase = "The name of the book is$bookName"

val springFiveOld = Book("Claudio E. de Oliveira","Spring 5.0 by Example","Amazing example of Spring Boot Apps",false)
val phrase = "The name of the book is${springFiveOld.name}"

funreturnValue(instance: Any): String {
if (instance is String) {
return instance
}
throw IllegalArgumentException("Instance is not String")
} 

public String returnValue(Object instance) {
  if (instance instanceof String) {
String value = (String) instance;
return value;
}
    throw IllegalArgumentException("Instance is not String");
}

for ( i in1..5){
  println(i)
}

for (i in1until5) {
  println(i)
}

for (i in5downTo1) {
  println(i)
}

for (i in1..6step2) {
  print(i)
}

var myNonNullString:String = "my non null string"

var allowNull:String? = "permits null references"

val hash:TrackedHashTag? = TrackedHashTag(hashTag="java",queue="java")
val queueString = hash?.queue

val hash:TrackedHashTag? = TrackedHashTag(hashTag="java",queue="java")
val queueString = hash?.queue ?: "unrecognized-queue"

在我们开始编码之前，我们需要跟踪应用程序的需求。该应用程序是消息驱动的，我们将使用代理来提供消息传递基础设施。我们选择 RabbitMQ 代理是因为它提供了可靠性、高可用性和集群选项。此外，RabbitMQ 是现代消息驱动应用程序的流行选择。

该软件由 Pivotal 公司提供支持，该公司也是维护 Spring Framework 的 company。有一个庞大的社区支持该项目。 

我们将有三个项目。这三个项目将收集 Twitter 流并将其发送给接收者，以便以格式化的方式向最终用户显示 Tweets。

第一个将在本章中创建，负责将跟踪的主题标签保存在 Redis 缓存中。

注册新的主题标签后，它将向第二个项目发送一条消息，该项目将开始使用 Twitter 流并将其重定向到所需的队列。该队列将被另一个项目使用，该项目将格式化推文，最后将它们显示给最终用户。

我们将拥有三个微服务。让我们创造这些东西。

我们已经学习了如何使用 Spring Initializr 页面。我们将进入页面，然后选择以下模块：

页面内容应如下所示：

我们可以选择组和神器。使用不同的名称没有问题。然后，我们可以点击Generate Project 等到下载结束。

<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-kotlin</artifactId>
<version>${jackson.version}</version>
</dependency>

该项目是使用 Kotlin configured 成功创建的。现在，我们来看看 pom.xml 中的 Maven 插件。该配置对于指导 Maven 如何编译 Kotlin 源代码和添加工件是必要的。

我们将在插件部分添加以下插件：

<plugin>
  <artifactId>kotlin-maven-plugin</artifactId>
  <groupId>org.jetbrains.kotlin</groupId>
  <version>${kotlin.version}</version>
  <configuration>
    <jvmTarget>1.8</jvmTarget>
  </configuration>
  <executions>
    <execution>
      <id>compile</id>
      <phase>process-sources</phase>
      <goals>
        <goal>compile</goal>
      </goals>
    </execution>
    <execution>
      <id>test-compile</id>
      <phase>process-test-sources</phase>
      <goals>
        <goal>test-compile</goal>
      </goals>
    </execution>
  </executions>
</plugin>

还有一件事要做。看看 Maven 如何为我们的 Kotlin 代码配置路径。这很容易。请看以下内容：

    <build>

<sourceDirectory>${project.basedir}/src/main/kotlin<
    /sourceDirectory<testSourceDirectory>${project.basedir}/src/
    test/kotlin</testSourceDirectory>

    .....

    </build>

我们在源路径中添加了 Kotlin 文件夹。

太棒了，项目结构已经准备好了，我们可以开始编码了！

为了为我们的应用程序创建隔离，我们将创建一个 custom Docker 网络。该网络是使用网桥驱动程序创建的。让我们使用以下命令来做到这一点：

docker network create twitter

好的，现在我们可以通过输入以下命令来检查网络列表：

docker network list

Twitter 网络应该在列表中，如下所示：

最后一个是我们的 Twitter 网络。让我们从 Docker Hub 中拉取 Redis 映像。请看下一节。

我们需要做的第一件事是从 Docker下载 Redis 映像"id326223510" class="indexterm"> 集线器。为此，需要执行以下命令：

docker pull redis:4.0.6-alpine

我们使用了 Redis 的 alpine 版本，因为它比其他版本更小，并且具有合理的安全性。下载图像时，我们可以看到下载状态进度。

我们可以使用以下命令检查结果：

docker images

结果应如下所示：

看看下载的图像。 Redis 必须在列表中。 

太棒了，现在我们将启动 Redis 实例。

有一个很好的工具可以 connect 与 Redis 实例，称为 redis-cli< /代码>。有一些 Docker 镜像，但我们将把它安装在我们的 Linux 机器上。

要安装它，我们可以执行以下命令：

sudo apt-get install redis-tools -y

太好了，现在我们可以与我们的 Redis 容器连接和交互了。该工具可以执行读写指令，那么我们需要小心避免无意中的指令。

让我们连接起来。默认配置对我们来说已经足够了，因为我们已经在 run 指令上导出了端口 6379。在终端中键入以下命令：

redis-cli

然后我们将连接我们正在运行的实例。命令行应显示 Redis 主机和端口，如下图所示：

太好了，客户端已配置和测试。

现在，我们将在我们的容器上执行一些 Redis 命令。

Redis有很多支持的数据类型。最常见的 是字符串、散列、列表和排序集。我们将稍微了解其中的每一个，因为帮助我们为用例选择正确的数据类型很重要。

       SET "user:id:10" "joe"

         GET "user:id:10"

        SET "users" "0"
        INCR "users"
        GET "users"

        GET "users"
        DECR "users"
        GET "users"

         GET "users"
         INCRBY "users" 2
         GET "users"

    LPUSH "categories" "sports"
    LPUSH "categories" "movies"
    LRANGE "categories" 0 -1

    RPUSH "categories" "kitchen"
    RPUSH "categories" "room"
    LRANGE "categories" 0 -1

    LSET "categories" 0 "series""
    LRANGE "categories" 0 -1

      LRANGE "categories" 0 2
      LRANGE "categories" 0 -1

        SADD "unique-visitors" "joe"
        SADD "unique-visitors" "mary"

       SMEMBERS "unique-visitors"

        SCARD "unique-visitors"

要配置 ReactiveRedisConnectionFactory，我们可以使用application.yaml文件，因为它更容易维护和集中我们的配置。

原理和其他 Spring Data 项目一样，我们应该在application.yaml 文件，如下：

spring:
redis:
host: localhost
port:6379

在前面的配置文件中，我们将Redis配置指向了 localhost， 我们可以看到。配置非常简单，也很容易理解。

完毕。连接工厂已配置。下一步是提供一个 RedisTemplate 来与我们的 Redis 实例交互。请看下一节。

Spring Data Redis 的主类是 ReactiveRedisTemplate，那么我们需要为 Spring 容器配置并提供一个实例。

我们需要提供一个实例并为所需的 ReactiveRedisTemplate 配置正确的序列化程序。 Serializers 是 Spring Data Redis 用来从存储在 Redis 中的 Key 中的原始字节序列化和反序列化对象的方式值 字段。

我们将只使用 StringRedisSerializer，因为我们的 Key 和 Value 很简单字符串和 Spring Data Redis 已经为我们准备好了这个序列化程序。

让我们生成我们的 ReactiveRedisTemplate。 实现 应该如下所示：

package springfive.twittertracked.infra.redis

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory
import org.springframework.data.redis.core.ReactiveRedisTemplate
import org.springframework.data.redis.serializer.RedisSerializationContext

@Configuration
open class RedisConfiguration {

  @Bean
open funreactiveRedisTemplate(connectionFactory:ReactiveRedisConnectionFactory):  
                                 ReactiveRedisTemplate<String, String> {
return ReactiveRedisTemplate(connectionFactory, RedisSerializationContext.string())
  }

}

惊人的。这是我们在 Spring Framework 中使用 Kotlin 的第一个代码。关键字 open 与 Java 的 final 关键字相反。这意味着这个函数可以从这个类继承。默认情况下，Kotlin 中的所有类都是 final 的。 Spring Framework 需要 @Bean 上的非 final 函数在 @Configuration 类上，然后我们需要插入 打开。

我们收到了 ReactiveRedisConnectionFactory 作为参数。 Spring 知道我们使用 Redis 的配置在 application.yaml 文件中生成了什么。然后容器可以注入工厂。

最后，我们声明 ReactiveRedisTemplate<String, String> 作为我们函数的返回值。

有趣的工作，我们已经准备好使用我们的 Redis 模板了。现在，我们将实现我们的第一个 Redis 存储库。下一节见。

我们已经创建了 ReactiveRedisTemplate，然后我们可以在我们的存储库实现中使用这个对象。我们将创建一个简单的存储库来interact 与 Redis，记住存储库应该是响应式的，这是我们应用程序的一个重要特征.然后我们需要返回 Mono 或 Flux 以使存储库 Reactive。让我们看看我们的存储库实现：

package springfive.twittertracked.domain.repository

import org.springframework.data.redis.core.ReactiveRedisTemplate
import org.springframework.stereotype.Service
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import springfive.twitterconsumer.domain.TrackedHashTag

@Service
class TrackedHashTagRepository(private val redisTemplate: ReactiveRedisTemplate<String, String>){

  fun save(trackedHashTag: TrackedHashTag): Mono<TrackedHashTag>? {
return this.redisTemplate
             .opsForSet().add("hash-tags","${trackedHashTag.hashTag}:${trackedHashTag.queue}")
             .flatMap { Mono.just(trackedHashTag) }
  }

fun findAll(): Flux<TrackedHashTag> {
return this.redisTemplate.opsForSet().members("hash-tags").flatMap { el ->
val data = el.split(":")
      Flux.just(TrackedHashTag(hashTag = data[0],queue = data[1]))
}
  }
}

我们收到了 ReactiveRedisTemplate<String, String> 作为我们类的注入，Spring Framework 可以检测构造函数并注入正确的实现。

现在，我们需要这两个函数。第一个负责在 Redis 的集合结构上插入我们的实体TrackedHashTag。我们在 Redis 上添加 hash-tags key 的值。此函数返回一个 Mono 和 TrackedHashTag 值。注意 save 功能。我们为我们的价值创建了一个模式，该模式遵循 hashtag、queue，其中 hashtag 是收集推文和我们将在下一节中使用的队列发送到 RabbitMQ 队列。

第二个函数返回hash-tags 键的所有值，表示所有被跟踪来自我们系统的标签。此外，我们还需要执行一些逻辑来创建我们的模型， TrackedHashTag。

存储库已经完成，现在我们可以创建我们的服务层来封装存储库。让我们在下一节中这样做。

package springfive.twittertracked.domain.service

import org.springframework.stereotype.Service
import springfive.twitterconsumer.domain.TrackedHashTag
import springfive.twitterconsumer.domain.repository.TrackedHashTagRepository

@Service
class TrackedHashTagService(private val repository: TrackedHashTagRepository) {

funsave(hashTag:TrackedHashTag) = this.repository.save(hashTag)

funall() = this.repository.findAll()

}

现在，我们已经创建了 repository 和服务层，我们准备通过 HTTP 端点公开我们的服务：

package springfive.twittertracked.domain.resource

import org.springframework.web.bind.annotation.*
import springfive.twitterconsumer.domain.TrackedHashTag
import springfive.twitterconsumer.domain.service.TrackedHashTagService


@RestController
@RequestMapping("/api/tracked-hash-tag")
class TrackedHashTagResource(private val service:TrackedHashTagService) {

  @GetMapping
  funall() = this.service.all()

  @PostMapping
  funsave(@RequestBody hashTag:TrackedHashTag) = this.service.save(hashTag)

}

代码非常简洁明了。看看这段代码有多简洁。 前面的代码是 Kotlin 如何帮助开发人员创建可读代码的示例。谢谢，科特林。

现在，我们将配置我们的 pom.xml 使其能够generate我们的 Docker 镜像。我们需要更改的第一件事是我们的最终名称工件，因为 Docker 映像不允许 - 字符，那么我们需要正确配置。

配置非常简单，将 <finalName> 标签放在 <build> 节点上。让我们这样做：

<build>

  <finalName>tracked_hashtag</finalName>

  ....

</build>

好的。我们已正确配置最终名称以正确生成 Docker 映像。现在，我们将配置 Maven Docker 插件以通过 Maven 目标生成 Docker 映像。

在构建节点内的插件部分，我们应该放入以下插件配置：

<plugin>
  <groupId>io.fabric8</groupId>
  <artifactId>docker-maven-plugin</artifactId>
  <version>0.21.0</version>
  <configuration>
    <images>
      <image>
        <name>springfivebyexample/${project.build.finalName}</name>
        <build>
          <from>openjdk:latest</from>
          <entryPoint>java -Dspring.profiles.active=container -jar 
       /application/${project.build.finalName}.jar</entryPoint>
          <assembly>
            <basedir>/application</basedir>
            <descriptorRef>artifact</descriptorRef>
            <inline>
              <id>assembly</id>
              <files>
                <file>
               <source>target/${project.build.finalName}.jar</source>
                </file>
              </files>
            </inline>
          </assembly>
          <tags>
            <tag>latest</tag>
          </tags>
          <ports>
            <port>9090</port>
          </ports>
        </build>
        <run>
          <namingStrategy>alias</namingStrategy>
        </run>
        <alias>${project.build.finalName}</alias>
      </image>
    </images>
  </configuration>
</plugin>

配置非常简单。我们以前这样做过。在配置部分，我们从镜像进行配置，在我们的例子中是 openjdk:latest、Docker 入口点和公开的端口。

让我们在下一节中创建我们的 Docker 映像。

我们的项目之前配置了 Maven Docker 插件。我们可以使用 Maven Docker 插件使用 docker:build 目标生成 Docker 镜像。然后，是时候生成我们的Docker镜像了。

要生成 Docker 映像，请键入以下命令：

mvn clean install docker:build

现在，我们必须等待 Maven 构建并检查 Docker 镜像是否成功生成。

检查 Docker 镜像，我们应该会看到生成的新镜像。为此，我们 可以使用docker images 命令：

docker images

对了，我们应该在图片列表中看到 springfivebyexample/tracked_hashtag:latest，如下图所示：

太棒了，我们的 Docker 镜像已经准备好与我们的第一个 Kotlin 语言的 Spring Boot 应用程序一起运行了。让我们现在运行它。

让我们运行我们的容器。在此之前，我们需要记住 一些事情。该容器应该在 Twitter 网络上运行，以便能够连接到我们也在 Twitter 网络上运行的 Redis 实例。请记住，在容器基础架构中运行时，Redis 的 localhost 地址不再起作用。

要运行我们的容器，我们可以执行以下命令：

docker run -d --name hashtag-tracker --net twitter -p 9090:9090 springfivebyexample/tracked_hashtag

恭喜，我们的应用程序正在 Docker 容器中运行并连接到我们的 Redis 实例。让我们创建并测试我们的 API 以检查所需的行为。