使用 Kotlin + Spring Boot 進行後端開發

時間  2019-11-16
標籤 使用 kotlin spring boot 進行 後端 開發 欄目 Spring 简体版
原文   原文鏈接

小舟.jpg

Kotlin

Kotlin 是一個基於 JVM 的編程語言，它的簡潔、便利早已不言而喻。Kotlin 可以勝任 Java 作的全部事。目前，咱們公司 C 端 的 Android 產品所有采用 Kotlin 編寫。公司的後端項目也可能會使用 Kotlin，因此我給他們作一些 demo 進行演示。java

示例一：結合 Redis 進行數據存儲和查詢

1.1 配置 gradle

在build.gradle中添加插件和依賴的庫。react

plugins {
    id 'java'
    id 'org.jetbrains.kotlin.jvm' version '1.3.0'
}

ext {
    libraries = [

            rxjava : "2.2.2",

            logback : "1.2.3",

            spring_boot : "2.1.0.RELEASE",

            commons_pool2 : "2.6.0",

            fastjson : "1.2.51"
    ]
}

group 'com.kotlin.tutorial'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

def libs = rootProject.ext.libraries // 庫

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    compile "org.jetbrains.kotlin:kotlin-reflect:1.3.0"
    testCompile group: 'junit', name: 'junit', version: '4.12'

    implementation "io.reactivex.rxjava2:rxjava:${libs.rxjava}"

    implementation "ch.qos.logback:logback-classic:${libs.logback}"
    implementation "ch.qos.logback:logback-core:${libs.logback}"
    implementation "ch.qos.logback:logback-access:${libs.logback}"

    implementation "org.springframework.boot:spring-boot-starter-web:${libs.spring_boot}"
    implementation "org.springframework.boot:spring-boot-starter-data-redis:${libs.spring_boot}"
    implementation "org.apache.commons:commons-pool2:${libs.commons_pool2}"
    implementation "com.alibaba:fastjson:${libs.fastjson}"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
複製代碼

1.2 建立 SpringKotlinApplication：

import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication


/** * Created by tony on 2018/11/13. */
@SpringBootApplication
open class SpringKotlinApplication

fun main(args: Array<String>) {
    SpringApplication.run(SpringKotlinApplication::class.java, *args)
}
複製代碼

須要注意open的使用，若是不加open會報以下的錯誤：git

org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: @Configuration class 'SpringKotlinApplication' may not be final. Remove the final modifier to continue.github

由於 Kotlin 的類默認是final的，因此這裏須要使用open關鍵字。web

1.3 配置 redis

在 application.yml 中添加 redis 的配置redis

spring:
  redis:
    #數據庫索引
    database: 0
    host: 127.0.0.1
    port: 6379
    password:
    lettuce:
      pool:
        #最大鏈接數
        max-active: 8
        #最大阻塞等待時間(負數表示沒限制)
        max-wait: -1
        #最大空閒
        max-idle: 8
        #最小空閒
        min-idle: 0
    #鏈接超時時間
    timeout: 10000
複製代碼

接下來定義 redis 的序列化器，本文采用fastjson，固然使用gson、jackson等均可以，看我的喜愛。spring

import com.alibaba.fastjson.JSON
import com.alibaba.fastjson.serializer.SerializerFeature
import org.springframework.data.redis.serializer.RedisSerializer
import org.springframework.data.redis.serializer.SerializationException
import java.nio.charset.Charset

/** * Created by tony on 2018/11/13. */

class FastJsonRedisSerializer<T>(private val clazz: Class<T>) : RedisSerializer<T> {

    @Throws(SerializationException::class)
    override fun serialize(t: T?) = if (null == t) {
            ByteArray(0)
        } else JSON.toJSONString(t, SerializerFeature.WriteClassName).toByteArray(DEFAULT_CHARSET)

    @Throws(SerializationException::class)
    override fun deserialize(bytes: ByteArray?): T? {

        if (null == bytes || bytes.size <= 0) {
            return null
        }
        val str = String(bytes, DEFAULT_CHARSET)
        return JSON.parseObject(str, clazz) as T
    }

    companion object {
        private val DEFAULT_CHARSET = Charset.forName("UTF-8")
    }
}
複製代碼

建立 RedisConfig數據庫

import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.context.annotation.Bean
import org.springframework.data.redis.cache.RedisCacheManager
import org.springframework.cache.CacheManager
import org.springframework.cache.annotation.CachingConfigurerSupport
import org.springframework.cache.annotation.EnableCaching
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.data.redis.core.RedisOperations
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass
import org.springframework.boot.autoconfigure.data.redis.RedisProperties


/** * Created by tony on 2018/11/13. */

@EnableCaching
@Configuration
@ConditionalOnClass(RedisOperations::class)
@EnableConfigurationProperties(RedisProperties::class)
open class RedisConfig : CachingConfigurerSupport() {

    @Bean(name = arrayOf("redisTemplate"))
    @ConditionalOnMissingBean(name = arrayOf("redisTemplate"))
    open fun redisTemplate(redisConnectionFactory: RedisConnectionFactory): RedisTemplate<Any, Any> {

        val template = RedisTemplate<Any, Any>()

        val fastJsonRedisSerializer = FastJsonRedisSerializer(Any::class.java)

        template.valueSerializer = fastJsonRedisSerializer
        template.hashValueSerializer = fastJsonRedisSerializer

        template.keySerializer = StringRedisSerializer()
        template.hashKeySerializer = StringRedisSerializer()

        template.connectionFactory = redisConnectionFactory
        return template
    }

    //緩存管理器
    @Bean
    open fun cacheManager(redisConnectionFactory: RedisConnectionFactory): CacheManager {
        val builder = RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory)
        return builder.build()
    }

}
複製代碼

這裏也都須要使用open，理由同上。apache

1.4 建立 Service

建立一個 User 對象，使用 datat class 類型。編程

data class User(var userName:String,var password:String):Serializable
複製代碼

建立操做 User 的Service接口

import com.kotlin.tutorial.user.User

/** * Created by tony on 2018/11/13. */
interface IUserService {

    fun getUser(username: String): User

    fun createUser(username: String,password: String)
}
複製代碼

建立 Service 的實現類：

import com.kotlin.tutorial.user.User
import com.kotlin.tutorial.user.service.IUserService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.stereotype.Service


/** * Created by tony on 2018/11/13. */
@Service
class UserServiceImpl : IUserService {

    @Autowired
    lateinit var redisTemplate: RedisTemplate<Any, Any>

    override fun getUser(username: String): User {

        var user = redisTemplate.opsForValue().get("user_${username}")

        if (user == null) {

            user = User("default","000000")
         }

        return user as User
    }

    override fun createUser(username: String, password: String) {

        redisTemplate.opsForValue().set("user_${username}", User(username, password))
    }

}
複製代碼

1.5 建立 Controller

建立一個 UserController，包含 createUser、getUser 兩個接口。

import com.kotlin.tutorial.user.User
import com.kotlin.tutorial.user.service.IUserService
import com.kotlin.tutorial.web.dto.HttpResponse

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController


/** * Created by tony on 2018/11/13. */
@RestController
@RequestMapping("/user")
class UserController {

    @Autowired
    lateinit var userService: IUserService

    @GetMapping("/getUser")
    fun getUser(@RequestParam("name") userName: String): HttpResponse<User> {

        return HttpResponse(userService.getUser(userName))
    }

    @GetMapping("/createUser")
    fun createUser(@RequestParam("name") userName: String,@RequestParam("password") password: String): HttpResponse<String> {

        userService.createUser(userName,password)

        return HttpResponse("create ${userName} success")
    }
}
複製代碼

建立完 Controller 以後，能夠進行測試了。

建立用戶tony：

建立用戶tony.png

查詢用戶tony：

查詢用戶tony.jpeg

建立用戶monica：

建立用戶monica.jpeg

查詢用戶monica：

查詢用戶monica.jpeg

示例二：結合 RxJava 模擬順序、併發地執行任務

2.1 建立 MockTask

首先定義一個任務接口，全部的任務都須要實現該接口：

/** * Created by tony on 2018/11/13. */
interface ITask {

    fun execute()
}
複製代碼

再建立一個模擬的任務，其中delayInSeconds用來模擬任務所花費的時間，單位是秒。

import java.util.concurrent.TimeUnit
import com.kotlin.tutorial.task.ITask

/** * Created by tony on 2018/11/13. */
class MockTask(private val delayInSeconds: Int) : ITask {

    /** * Stores information if task was started. */
    var started: Boolean = false

    /** * Stores information if task was successfully finished. */
    var finishedSuccessfully: Boolean = false

    /** * Stores information if the task was interrupted. * It can happen if the thread that is running this task was killed. */
    var interrupted: Boolean = false

    /** * Stores the thread identifier in which the task was executed. */
    var threadId: Long = 0

    override fun execute() {
        try {
            this.threadId = Thread.currentThread().id
            this.started = true
            TimeUnit.SECONDS.sleep(delayInSeconds.toLong())
            this.finishedSuccessfully = true
        } catch (e: InterruptedException) {
            this.interrupted = true
        }

    }
}
複製代碼

2.2 建立 ConcurrentTasksExecutor

順序執行的話比較簡單，一個任務接着一個任務地完成便可，是單線程的操做。

對於併發而言，在這裏藉助 RxJava 的 merge 操做符來將多個任務進行合併。還用到了 RxJava 的任務調度器 Scheduler，createScheduler()是按照所需的線程數來建立Scheduler的。

import com.kotlin.tutorial.task.ITask
import io.reactivex.Completable
import io.reactivex.schedulers.Schedulers
import org.slf4j.LoggerFactory
import org.springframework.util.CollectionUtils
import java.util.*
import java.util.concurrent.Executors
import java.util.stream.Collectors


/** * Created by tony on 2018/11/13. */
class ConcurrentTasksExecutor(private val numberOfConcurrentThreads: Int, private val tasks: Collection<ITask>?) : ITask {

    val log = LoggerFactory.getLogger(this.javaClass)

    constructor(numberOfConcurrentThreads: Int, vararg tasks: ITask) : this(numberOfConcurrentThreads, if (tasks == null) null else Arrays.asList<ITask>(*tasks)) {}

    init {

        if (numberOfConcurrentThreads < 0) {
            throw RuntimeException("Amount of threads must be higher than zero.")
        }
    }

    /** * Converts collection of tasks (except null tasks) to collection of completable actions. * Each action will be executed in thread according to the scheduler created with [.createScheduler] method. * * @return list of completable actions */
    private val asConcurrentTasks: List<Completable>
        get() {

            if (tasks!=null) {

                val scheduler = createScheduler()

                return tasks.stream()
                        .filter { task -> task != null }
                        .map { task ->
                            Completable
                                    .fromAction {
                                        task.execute()
                                    }
                                    .subscribeOn(scheduler)
                        }
                        .collect(Collectors.toList())
            } else {

                return ArrayList<Completable>()
            }
        }

    /** * Checks whether tasks collection is empty. * * @return true if tasks collection is null or empty, false otherwise */
    private val isTasksCollectionEmpty: Boolean
        get() = CollectionUtils.isEmpty(tasks)


    /** * Executes all tasks concurrent way only if collection of tasks is not empty. * Method completes when all of the tasks complete (or one of them fails). * If one of the tasks failed the the exception will be rethrown so that it can be handled by mechanism that calls this method. */
    override fun execute() {

        if (isTasksCollectionEmpty) {
            log.warn("There are no tasks to be executed.")
            return
        }

        log.debug("Executing #{} tasks concurrent way.", tasks?.size)
        Completable.merge(asConcurrentTasks).blockingAwait()
    }

    /** * Creates a scheduler that will be used for executing tasks concurrent way. * Scheduler will use number of threads defined in [.numberOfConcurrentThreads] * * @return scheduler */
    private fun createScheduler() = Schedulers.from(Executors.newFixedThreadPool(numberOfConcurrentThreads))
}
複製代碼

2.3 建立 Controller

建立一個 TasksController，包含 sequential、concurrent 兩個接口，會分別把sequential 和 concurrent 執行任務的時間展現出來。

import com.kotlin.tutorial.task.impl.ConcurrentTasksExecutor
import com.kotlin.tutorial.task.impl.MockTask
import com.kotlin.tutorial.web.dto.TaskResponse
import com.kotlin.tutorial.web.dto.ErrorResponse
import com.kotlin.tutorial.web.dto.HttpResponse
import org.springframework.http.HttpStatus
import org.springframework.util.StopWatch
import org.springframework.web.bind.annotation.*
import java.util.stream.Collectors
import java.util.stream.IntStream

/** * Created by tony on 2018/11/13. */
@RestController
@RequestMapping("/tasks")
class TasksController {

    @GetMapping("/sequential")
    fun sequential(@RequestParam("task") taskDelaysInSeconds: IntArray): HttpResponse<TaskResponse> {

        val watch = StopWatch()
        watch.start()

        IntStream.of(*taskDelaysInSeconds)
                .mapToObj{
                    MockTask(it)
                }
                .forEach{
                    it.execute()
                }

        watch.stop()
        return HttpResponse(TaskResponse(watch.totalTimeSeconds))
    }

    @GetMapping("/concurrent")
    fun concurrent(@RequestParam("task") taskDelaysInSeconds: IntArray, @RequestParam("threads",required = false,defaultValue = "1") numberOfConcurrentThreads: Int): HttpResponse<TaskResponse> {

        val watch = StopWatch()
        watch.start()

        val delayedTasks = IntStream.of(*taskDelaysInSeconds)
                .mapToObj{
                    MockTask(it)
                }
                .collect(Collectors.toList())

        ConcurrentTasksExecutor(numberOfConcurrentThreads, delayedTasks).execute()

        watch.stop()
        return HttpResponse(TaskResponse(watch.totalTimeSeconds))
    }

    @ExceptionHandler(IllegalArgumentException::class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    fun handleException(e: IllegalArgumentException) = ErrorResponse(e.message)
}
複製代碼

順序地執行多個任務：http://localhost:8080/tasks/sequential?task=1&task=2&task=3&task=4

順序執行多個任務.jpeg

每一個任務所花費的時間分別是1秒、2秒、3秒和4秒。最後，一共花費了10.009秒。

兩個線程併發地執行多個任務：http://localhost:8080/tasks/concurrent?task=1&task=2&task=3&task=4&threads=2

兩個線程併發執行多任務.jpeg

三個線程併發地執行多個任務：http://localhost:8080/tasks/concurrent?task=1&task=2&task=3&task=4&threads=3

三個線程併發執行多任務.jpeg

總結

本文使用了 Kotlin 的特性跟 Spring Boot 整合進行後端開發。Kotlin 的不少語法糖使得開發變得更加便利，固然 Kotlin 也是 Java 的必要補充。

本文 demo 的 github 地址：github.com/fengzhizi71…

Java與Android技術棧：每週更新推送原創技術文章，歡迎掃描下方的公衆號二維碼並關注，期待與您的共同成長和進步。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程