真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

成都創(chuàng)新互聯(lián)網(wǎng)站制作重慶分公司

利用Kotlin+SpringBoot實現(xiàn)后端開發(fā)

前言

創(chuàng)新互聯(lián)總部坐落于成都市區(qū)，致力網(wǎng)站建設(shè)服務(wù)有成都做網(wǎng)站、網(wǎng)站制作、網(wǎng)絡(luò)營銷策劃、網(wǎng)頁設(shè)計、網(wǎng)站維護(hù)、公眾號搭建、小程序制作、軟件開發(fā)等為企業(yè)提供一整套的信息化建設(shè)解決方案。創(chuàng)造真正意義上的網(wǎng)站建設(shè)，為互聯(lián)網(wǎng)品牌在互動行銷領(lǐng)域創(chuàng)造價值而不懈努力！

Spring官方最近宣布，將在Spring Framework 5.0版本中正式支持Kotlin語言。這意味著Spring Boot 2.x版本將為Kotlin提供一流的支持。

這并不會令人意外，因為Pivotal團(tuán)隊以廣泛接納​​JVM語言（如Scala和Groovy）而聞名。

Kotlin 是一個基于 JVM 的編程語言，它的簡潔、便利早已不言而喻。Kotlin 能夠勝任 Java 做的所有事。目前，我們公司 C 端 的 Android 產(chǎn)品全部采用 Kotlin 編寫。公司的后端項目也可能會使用 Kotlin，所以我給他們做一些 demo 進(jìn)行演示。

示例一：結(jié)合 redis 進(jìn)行數(shù)據(jù)存儲和查詢

1.1 配置 gradle

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

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 創(chuàng)建 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) {
SpringApplication.run(SpringKotlinApplication::class.java, *args)
}

需要注意open的使用，如果不加open會報如下的錯誤：

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

因為 Kotlin 的類默認(rèn)是final的，所以這里需要使用open關(guān)鍵字。

1.3 配置 redis

在 application.yml 中添加 redis 的配置

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

接下來定義 redis 的序列化器，本文采用fastjson，當(dāng)然使用gson、jackson等都可以，看個人喜好。

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(private val clazz: Class) : RedisSerializer {

 @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")
 }
}

創(chuàng)建 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 {

  val template = RedisTemplate()

  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，理由同上。

1.4 創(chuàng)建 Service

創(chuàng)建一個 User 對象，使用 datat class 類型。

data class User(var userName:String,var password:String):Serializable

創(chuàng)建操作 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)
}

創(chuàng)建 Service 的實現(xiàn)類：

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

 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 創(chuàng)建 Controller

創(chuàng)建一個 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 {

  return HttpResponse(userService.getUser(userName))
 }

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

  userService.createUser(userName,password)

  return HttpResponse("create ${userName} success")
 }
}

創(chuàng)建完 Controller 之后，可以進(jìn)行測試了。

創(chuàng)建用戶tony：

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

查詢用戶tony：

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

創(chuàng)建用戶monica：

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

查詢用戶monica：

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

示例二：結(jié)合 RxJava 模擬順序、并發(fā)地執(zhí)行任務(wù)

2.1 創(chuàng)建 MockTask

首先定義一個任務(wù)接口，所有的任務(wù)都需要實現(xiàn)該接口：

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

 fun execute()
}

再創(chuàng)建一個模擬的任務(wù)，其中delayInSeconds用來模擬任務(wù)所花費(fèi)的時間，單位是秒。

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 創(chuàng)建 ConcurrentTasksExecutor

順序執(zhí)行的話比較簡單，一個任務(wù)接著一個任務(wù)地完成即可，是單線程的操作。

對于并發(fā)而言，在這里借助 RxJava 的 merge 操作符來將多個任務(wù)進(jìn)行合并。還用到了 RxJava 的任務(wù)調(diào)度器 Scheduler，createScheduler()是按照所需的線程數(shù)來創(chuàng)建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 {

 val log = LoggerFactory.getLogger(this.javaClass)

 constructor(numberOfConcurrentThreads: Int, vararg tasks: ITask) : this(numberOfConcurrentThreads, if (tasks == null) null else Arrays.asList(*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
  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()
   }
  }

 /**
  * 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 創(chuàng)建 Controller

創(chuàng)建一個 TasksController，包含 sequential、concurrent 兩個接口，會分別把sequential 和 concurrent 執(zhí)行任務(wù)的時間展示出來。

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 {

  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 {

  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)
}

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

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

每個任務(wù)所花費(fèi)的時間分別是1秒、2秒、3秒和4秒。最后，一共花費(fèi)了10.009秒。

兩個線程并發(fā)地執(zhí)行多個任務(wù)：http://localhost:8080/tasks/concurrent?task=1&task=2&task=3&task=4&threads=2

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

三個線程并發(fā)地執(zhí)行多個任務(wù)：http://localhost:8080/tasks/concurrent?task=1&task=2&task=3&task=4&threads=3

利用Kotlin + Spring Boot實現(xiàn)后端開發(fā)

總結(jié)

本文使用了 Kotlin 的特性跟 Spring Boot 整合進(jìn)行后端開發(fā)。Kotlin 的很多語法糖使得開發(fā)變得更加便利，當(dāng)然 Kotlin 也是 Java 的必要補(bǔ)充。

本文 demo 的 github 地址：https://github.com/fengzhizi715/kotlin-spring-demo

好了，以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，如果有疑問大家可以留言交流，謝謝大家對創(chuàng)新互聯(lián)的支持。


網(wǎng)頁題目：利用Kotlin+SpringBoot實現(xiàn)后端開發(fā)
轉(zhuǎn)載來源：http://weahome.cn/article/ppijjs.html

其他資訊

在線咨詢

微信咨詢

電話咨詢

028-86922220（工作日）

18980820575（7×24）

提交需求

返回頂部