利用Kotlin + Spring Boot实现后端开发

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测试数据mons:commons-pool2:${libs测试数据mons_pool2}"

implementation "com.alibaba:fastjson:${libs.fastjson}"

}

compilekotlin {

kotlinoptions.jvmtarget = "1.8"

}

compiletestkotlin {

kotlinoptions.jvmtarget = "1.8"

}

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)

}

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

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

  }

}

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

  }

}

data class user(var username:string,var password:string):serializable

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)

}

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

  }

}

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

  }

}

/**

  * created by tony on 2018/11/13.

  */

interface itask {

  fun execute()

}

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

   }

  }

}

import com.kotlin.tutorial.task.itask

import io.reactivex测试数据pletable

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

}

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)

}