赐我理由在披甲上阵
赐我理由在披甲上阵

kt-rest

buildscript {
  repositories {
    mavenLocal()
    maven {
      url "https://www.artifactrepository.citigroup.net:443/artifactory/maven-icg-dev"
      credentials {
        username = "ocean-devops"
        password = "APBQW78wqY4oewwXFBtTfcN17ZG"
      }
    }
    maven {
      url "https://www.artifactrepository.citigroup.net:443/artifactory/maven-dev"
      credentials {
        username = "ocean-devops"
        password = "APBQW78wqY4oewwXFBtTfcN17ZG"
      }
    }
  }
  ext {
    kt_version = "1.3.40"
  }
  dependencies {
    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kt_version}")
    classpath "org.jetbrains.kotlin:kotlin-allopen:${kt_version}"
    classpath "org.jetbrains.kotlin:kotlin-noarg:${kt_version}"
//        classpath("org.flywaydb:flyway-gradle-plugin:4.0.3")
//    classpath("gradle.plugin.io.vertx:vertx-gradle-plugin:0.8.0")
  }
}

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

apply plugin: 'java'
apply plugin: 'kotlin'
//apply plugin: "kotlin-allopen"
//apply plugin: "kotlin-noarg"
//apply plugin: "io.vertx.vertx-plugin"

group 'com.wh'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

ext {
  kt_version = "1.3.40"
  vt_version = "3.8.2"
  ktorm_version = "2.5"
  h2_version = "1.4.199"
}


repositories {
  mavenLocal()
  maven {
    url = uri("https://www.artifactrepository.citigroup.net:443/artifactory/maven-icg-dev")
    credentials {
      username = "ocean-devops"
      password = "APBQW78wqY4oewwXFBtTfcN17ZG"
    }
  }
  mavenCentral()
  jcenter()
}

dependencies {
  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kt_version}"
  implementation "org.jetbrains.kotlin:kotlin-reflect:${kt_version}"
  implementation "com.fasterxml.jackson.module:jackson-module-kotlin:2.9.10"

  // vertx
  annotationProcessor("io.vertx:vertx-codegen:$vt_version:processor")
  implementation("io.vertx:vertx-core:${vt_version}")
  implementation("io.vertx:vertx-web:$vt_version")
  implementation("io.vertx:vertx-lang-kotlin:$vt_version")
  implementation("io.vertx:vertx-lang-kotlin-coroutines:$vt_version")
  implementation("io.vertx:vertx-jdbc-client:$vt_version")
  implementation("io.vertx:vertx-redis-client:${vt_version}")

  // db
  // java -cp .\h2-1.4.199.jar org.h2.tools.Server -tcp -tcpAllowOthers -web -webAllowOthers -browser -ifNotExists
  implementation("com.h2database:h2:$h2_version")
  implementation("me.liuwj.ktorm:ktorm-core:$ktorm_version")

  testImplementation("io.vertx:vertx-unit:$vt_version")
  testCompile group: 'junit', name: 'junit', version: '4.12'
}

sourceSets {
  main {
    java {
      srcDirs += 'src/main/generated'
    }
  }
}
// compileOnly requires Gradle 2.12+
task annotationProcessing(type: JavaCompile, group: 'build') {
  description 'Generates Vertx js and rxjava shims'
  source = sourceSets.main.java
  classpath = configurations.compileClasspath + configurations.runtimeClasspath
  destinationDir = project.file('src/main/generated')
  options.annotationProcessorPath = configurations.annotationProcessor
  options.compilerArgs = [
          "-proc:only",
          "-processor", "io.vertx.codegen.CodeGenProcessor",
          "-Acodegen.output=${destinationDir.absolutePath}"
  ]
}

compileJava {
  targetCompatibility = 1.8
  sourceCompatibility = 1.8

  dependsOn annotationProcessing
}

compileKotlin {
  kotlinOptions.jvmTarget = "1.8"
}

compileTestKotlin {
  kotlinOptions.jvmTarget = "1.8"
}


jar {
  // by default fat jar
  archiveName = 'kt-rest-todo-backend-fat.jar'
  from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
  manifest {
    attributes 'Main-Class': 'io.vertx.core.Launcher'
    attributes 'Main-Verticle': 'io.vertx.blueprint.todolist.verticle.RxTodoVerticle'
  }
}

gradle-wrapper.properties

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=file\:/c:/Users/hw83770/.gradle/wrapper/dists/gradle-5.5.1-bin.zip

systemProp.http.proxyHost=natcpproxy.wlb2.nam.nsroot.net
systemProp.http.proxyPort=7777
systemProp.http.proxyUser=hw83770
systemProp.http.proxyPassword=Hw190625
systemProp.http.nonProxyHosts=localhost|*.nsroot.net|*.ssmb.com|*.citigroup.net
org.gradle.warning.mode=all

docker-compose.yml

version: "2"
services:
  redis:
    container_name: vertx-kt-res-redis
    image: redis:latest
    expose:
      - "6379"

  vertx-todo-backend:
    depends_on:
      - redis
    container_name: vertx-kt-rest
    build: .
    links:
      - redis
    ports:
      - "8082:8082"

Dockfile

FROM java:8-jre

ENV VERTICLE_FILE build/libs/vertx-blueprint-todo-backend-fat.jar

# Set the location of the verticles
ENV VERTICLE_HOME /usr/verticles

EXPOSE 8082

COPY $VERTICLE_FILE $VERTICLE_HOME/
COPY config/config_docker.json $VERTICLE_HOME/

WORKDIR $VERTICLE_HOME
ENTRYPOINT ["sh", "-c"]
CMD ["java -jar vertx-blueprint-todo-backend-fat.jar -conf config_docker.json"]

import io.vertx.core.AbstractVerticle
import io.vertx.core.DeploymentOptions
import io.vertx.core.Vertx
import io.vertx.core.VertxOptions
import io.vertx.kotlin.core.json.json
import io.vertx.kotlin.core.json.obj
import todolist.TodoRestVerticle
import todolist.service.ServiceVerticle

/**
 * @Author hw83770
 * @Date 11:04 2019/10/15
 *
 */
object Starter {

  private val vertxOptions by lazy {
    createOption()
  }

  @JvmStatic
  fun main(args: Array) {
    val vertex = Vertx.vertx(vertxOptions)

    val config = json {
      obj(
        "service.type" to "jdbc",
        "url" to "jdbc:h2:tcp://localhost/~/Documents/db/kt_rest",
        "driver_class" to "org.h2.Driver",
        "user" to "sa",
        "password" to "",
        "max_pool_size" to 30,
        "http.port" to 9991
      )
    }

    vertex.deployVerticle(ServiceVerticle(), DeploymentOptions().setWorker(true).setConfig(config))
    vertex.deployVerticle(TodoRestVerticle(), DeploymentOptions().setConfig(config))
  }


  private fun createOption(): VertxOptions {
    return VertxOptions().apply {
      eventLoopPoolSize = 4
      workerPoolSize = 4
    }
  }
}


package todolist

import io.vertx.core.AbstractVerticle
import io.vertx.core.logging.LoggerFactory
import todolist.service.JdbcTodoService
import todolist.service.TodoService

/**
 * @Author hw83770
 * @Date 11:12 2019/10/15
 *
 */
class TodoRestVerticle : AbstractVerticle() {
  private val logger = LoggerFactory.getLogger(TodoRestVerticle::class.java)
  val router by lazy {
    createRouter(vertx)
  }
  val defaultPort = 8080

  val service: TodoService by lazy {
    createService()
  }

  override fun start() {
    val port = config().getInteger("http.port", defaultPort)
    vertx.createHttpServer().requestHandler(router).listen(port)
  }

  private fun createService(): TodoService {
    return JdbcTodoService(vertx, config())
  }

}


package todolist

import me.liuwj.ktorm.dsl.QueryRowSet
import me.liuwj.ktorm.schema.*

/**
 * @Author hw83770
 * @Date 11:30 2019/10/15
 *
 */

data class Todo(
  val id: Int,
  val title: String,
  var completed: Boolean,
  var order: Int,
  var url: String
)

object TODOS : BaseTable(tableName = "TODOS") {
  val id: Column by int("ID").primaryKey()
  val title by varchar("TITLE")
  val completed by boolean("COMPLETED")
  val order by int("ORDER")
  val url by varchar("URL")

  override fun doCreateEntity(row: QueryRowSet, withReferences: Boolean) = Todo(
    id = row[id] ?: 0,
    title = row[title].orEmpty(),
    completed = row[completed] ?: false,
    order = row[order] ?: 0,
    url = row[url].orEmpty()
  )

}


package todolist

import io.vertx.core.AsyncResult
import io.vertx.core.Handler
import io.vertx.core.http.HttpMethod.*
import io.vertx.core.Vertx
import io.vertx.core.eventbus.Message
import io.vertx.core.http.HttpHeaders.CONTENT_TYPE
import io.vertx.core.http.HttpHeaders.ORIGIN
import io.vertx.core.json.Json
import io.vertx.core.json.JsonArray
import io.vertx.core.json.JsonObject
import io.vertx.ext.web.Router
import io.vertx.ext.web.RoutingContext
import io.vertx.ext.web.handler.BodyHandler
import io.vertx.ext.web.handler.CorsHandler
import io.vertx.kotlin.core.json.json
import io.vertx.kotlin.core.json.obj

/**
 * @Author hw83770
 * @Date 11:16 2019/10/15
 *
 */

fun createRouter(vertx: Vertx): Router = Router.router(vertx).apply {
  route().handler(cors)
  route().handler(BodyHandler.create())

  get(API_GET).handler(getTodo)
  get(API_LIST_ALL).handler(getTodoList)
  post(API_CREATE).handler(addTodo)
  post(API_UPDATE).handler(updateTodo)
  post(API_DELETE).handler(deleteTodo)
  post(API_DELETE_ALL).handler(deleteAll)
}

fun  RoutingContext.sendToEventBusAndResponse(addr: String, msg: JsonObject) {
  vertx().eventBus().request(addr, msg) { res: AsyncResult> ->
    when {
      res.succeeded() -> toJson(res.result().body())
      res.failed() -> fail(500, res.cause())
    }
  }
}

fun RoutingContext.toJson(obj: Any?) {
  response().putHeader(CONTENT_TYPE, "application/json; charset=utf-8")
    .end(if (obj is String) obj else Json.encodePrettily(obj))
}


// handlers
val cors: CorsHandler = CorsHandler.create("*")
  .allowedHeaders(setOf(CONTENT_TYPE.toString(), ORIGIN.toString(), "Access-Control-Allow-Origin"))
  .allowedMethods(setOf(GET, POST, PUT, PATCH, DELETE, OPTIONS))

val getTodo = Handler { ctx ->
  val id = ctx.request().getParam("todoId")
  ctx.sendToEventBusAndResponse("todo", json {
    obj(
      "action" to ACTION_GET,
      "id" to id
    )
  })
}

val getTodoList = Handler { ctx ->
  ctx.sendToEventBusAndResponse("todo", json { obj("action" to ACTION_GET_ALL) })
}

val addTodo = Handler { ctx ->
  ctx.sendToEventBusAndResponse("todo", json {
    obj(
      "action" to ACTION_CREATE,
      "data" to ctx.body.getBytes()
    )
  })
}

val updateTodo = Handler { ctx ->
  ctx.sendToEventBusAndResponse("todo", json {
    obj(
      "action" to ACTION_UPDATE,
      "id" to ctx.request().getParam("todoId"),
      "data" to ctx.body.getBytes()
    )
  })
}

val deleteTodo = Handler { ctx ->
  ctx.sendToEventBusAndResponse("todo", json {
    obj(
      "action" to ACTION_DELETE,
      "id" to ctx.request().getParam("todoId")
    )
  })
}

val deleteAll = Handler { ctx ->
  ctx.sendToEventBusAndResponse("todo", json {
    obj(
      "action" to ACTION_DELETE_ALL
    )
  })
}


package todolist

import io.vertx.ext.jdbc.JDBCClient

/**
 * @Author hw83770
 * @Date 11:46 2019/10/15
 *
 */
//fun createDBClient(vertx, config): JDBCClient = JDBCClient.createShared(vertx, config)
const val API_GET = "/todos/:todoId"
const val API_LIST_ALL = "/todos"
const val API_CREATE = "/todos"
const val API_UPDATE = "/todos/:todoId"
const val API_DELETE = "/todos/:todoId"
const val API_DELETE_ALL = "/todos"

const val ACTION_GET = "get"
const val ACTION_GET_ALL = "get_all"
const val ACTION_CREATE = "create"
const val ACTION_UPDATE = "update"
const val ACTION_DELETE = "delete"
const val ACTION_DELETE_ALL = "delete_all"


package todolist.service

import io.vertx.core.Vertx
import io.vertx.core.json.JsonObject
import io.vertx.ext.jdbc.JDBCClient
import io.vertx.kotlin.ext.sql.executeAwait
import io.vertx.kotlin.ext.sql.getConnectionAwait
import kotlinx.coroutines.suspendCancellableCoroutine
import me.liuwj.ktorm.database.Database
import me.liuwj.ktorm.dsl.*
import me.liuwj.ktorm.entity.findAll
import me.liuwj.ktorm.entity.findById
import todolist.TODOS
import todolist.Todo
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

/**
 * @Author hw83770
 * @Date 11:40 2019/10/15
 *
 */
class JdbcTodoService(private val vertx: Vertx, private val config: JsonObject) : TodoService {
  val dbClient: JDBCClient by lazy { JDBCClient.createShared(vertx, config) }
  lateinit var database: Database

  override suspend fun initData(): Boolean {
//    val con = dbClient.getConnectionAwait()
//    con.executeAwait(SQL_CREATE)
//    con.close()

    suspendEvent {
      database = Database.connect(
        url = config.getString("url"),
        driver = config.getString("driver_class"),
        user = config.getString("user"),
        password = config.getString("password")
      )
    }
    return true
  }

  override suspend fun insert(todo: Todo): Todo? {
    val res = suspendEvent {
      TODOS.insert {
        TODOS.title to todo.title
        TODOS.completed to todo.completed
        TODOS.order to todo.order
        TODOS.url to todo.url
      }
    }
    return if (res > 0) todo else null
  }

  override suspend fun getAll(): List {
    return suspendEvent {
      TODOS.findAll()
    }
  }

  override suspend fun getCertain(todoID: String): Todo? {
    return suspendEvent { TODOS.findById(todoID.toInt()) }
  }

  override suspend fun update(todoId: String, newTodo: Todo): Todo? {
    val res = suspendEvent {
      TODOS.update {
        it.title to newTodo.title
        it.completed to newTodo.completed
        it.order to newTodo.order
        it.url to newTodo.url
        where { it.id eq todoId.toInt() }
      }
    }
    return if (res > 0) newTodo else null
  }

  override suspend fun delete(todoId: String): Boolean {
    return suspendEvent {
      TODOS.delete { it.id eq todoId.toInt() }
    } > 0
  }

  override suspend fun deleteAll(): Boolean {
    return suspendEvent {
      TODOS.deleteAll()
    } > 0
  }

  // 同步方法 转化为协程suspend方法
  private suspend fun  suspendEvent(block: () -> T): T {
    return suspendCancellableCoroutine { continuation ->
      try {
        continuation.resume(block.invoke())
      } catch (e: java.lang.Exception) {
        continuation.resumeWithException(e)
      }
    }
  }


  private val SQL_CREATE = "CREATE TABLE IF NOT EXISTS `TODOS` (\n" +
          "  `id` int(11) NOT NULL AUTO_INCREMENT,\n" +
          "  `title` varchar(255) DEFAULT NULL,\n" +
          "  `completed` tinyint(1) DEFAULT NULL,\n" +
          "  `order` int(11) DEFAULT NULL,\n" +
          "  `url` varchar(255) DEFAULT NULL,\n" +
          "  PRIMARY KEY (`id`) )"
}


package todolist.service

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import io.vertx.core.eventbus.Message
import io.vertx.core.json.Json
import io.vertx.core.json.JsonObject
import io.vertx.core.logging.LoggerFactory
import io.vertx.kotlin.coroutines.CoroutineVerticle
import io.vertx.kotlin.coroutines.dispatcher
import kotlinx.coroutines.launch
import todolist.*

/**
 * @Author hw83770
 * @Date 15:16 2019/10/15
 *
 */
class ServiceVerticle : CoroutineVerticle() {
  lateinit var todoService: TodoService
  val mapper = jacksonObjectMapper()

  private val logger = LoggerFactory.getLogger(ServiceVerticle::class.java)

  override suspend fun start() {
    vertx.eventBus().consumer("todo") { msg ->
      handleMessage(msg)
    }

    todoService = JdbcTodoService(vertx, config)
    todoService.initData()
  }

  private fun handleMessage(msg: Message) {
    val action = msg.body().getString("action")
    when (action) {
      ACTION_GET -> doAsync(msg) { todoService.getCertain(msg.body().getString("id")) }
      ACTION_GET_ALL -> doAsync(msg) { todoService.getAll() }

      ACTION_CREATE -> doAsync(msg) {
        val obj: ByteArray = msg.body().getBinary("data")
        val todo: Todo = mapper.readValue(obj)
        todoService.insert(todo)
      }

      ACTION_UPDATE -> doAsync(msg) {
        val id = msg.body().getString("id")
        val obj: ByteArray = msg.body().getBinary("data")
        val todo: Todo = mapper.readValue(obj)
        todoService.update(id, todo)
      }
      ACTION_DELETE -> doAsync(msg) { todoService.delete(msg.body().getString("id")) }
      ACTION_DELETE_ALL -> doAsync(msg) { todoService.deleteAll() }
    }
  }

  fun  doAsync(msg: Message, block: suspend () -> T) {
    launch(vertx.dispatcher()) {
      val t = block.invoke()
      msg.reply(Json.encodePrettily(t))
    }
  }

//  fun Route.coroutineHandler(fn: suspend (RoutingContext) -> Unit) {
//    handler { ctx ->
//      launch(ctx.vertx().dispatcher()) {
//        try {
//          fn(ctx)
//        } catch (e: Exception) {
//          ctx.fail(e)
//        }
//      }
//    }
//  }
}


package todolist.service

import todolist.Todo


/**
 * @Author hw83770
 * @Date 11:36 2019/10/15
 *
 */
interface TodoService {
  suspend fun initData(): Boolean

  suspend fun insert(todo: Todo): Todo?

  suspend fun getAll(): List?

  suspend fun getCertain(todoID: String): Todo?

  suspend fun update(todoId: String, newTodo: Todo): Todo?

  suspend fun delete(todoId: String): Boolean

  suspend fun deleteAll(): Boolean
}

你可能感兴趣的:(kt-rest)

  • kt-rest 赐我理由在披甲上阵
    buildscript{repositories{mavenLocal()maven{url"https://www.artifactrepository.citigroup.net:443/artifactory/maven-icg-dev"credentials{username="ocean-devops"password="APBQW78wqY4oewwXFBtTfcN17ZG"}}mav
  • Maven Array_06 eclipsejdkmaven
    Maven Maven是基于项目对象模型(POM)， 信息来管理项目的构建，报告和文档的软件项目管理工具。 Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
  • ibatis的queyrForList和queryForMap区别 bijian1013 javaibatis
    一.说明         iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之：         1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
  • LeetCode[位运算] - #191 计算汉明权重 Cwind java位运算LeetCodeAlgorithm题解
    原题链接：#191 Number of 1 Bits 要求： 写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。 汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。 难度：简单 分析： 将十进制参数转换为二进制，然后计算其中1的个数即可。 “
  • 浅谈java类与对象 15700786134 java
          java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
  • linux下双网卡同一个IP 被触发 linux
    转自： http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少： 一、 关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
  • 安卓按主页键隐藏程序之后无法再次打开 肆无忌惮_ 安卓
    遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity   本来代码：   // 销毁这个Activity fin
  • 通过cookie保存并读取用户登录信息实例 知了ing JavaScripthtml
    通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。 下面通过cookie保存并读取用户登录信息的例子加深一下理解。 （1）创建index.jsp文件。在改
  • JAVA 对象池 矮蛋蛋 javaObjectPool
    原文地址： http://www.blogjava.net/baoyaer/articles/218460.html Jakarta对象池       ☆为什么使用对象池   恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
  • ArrayList根据条件+for循环批量删除的方法 alleni123 java
    场景如下： ArrayList<Obj> list Obj-> createTime, sid. 现在要根据obj的createTime来进行定期清理。（释放内存） ------------------------- 首先想到的方法就是 for(Obj o:list){ if(o.createTime-currentT>xxx){
  • 阿里巴巴“耕地宝”大战各种宝 百合不是茶 平台战略
    “耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿 ，主要是用来进行农业方面，将农民手中的散地集中起来 不仅加大农民集体在土地上面的话语权，还增加了土地的流通与 利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的 发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权 将更少，国家应出台相应的法律法规保护
  • Spring注入有继承关系的类（1） bijian1013 javaspring
    一个类一个类的注入 1.AClass类 package com.bijian.spring.test2; public class AClass { String a; String b; public String getA() { return a; } public void setA(Strin
  • 30岁转型期你能否成为成功人士 bijian1013 成功
            很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
  • [Velocity三]基于Servlet+Velocity的web应用 bit1129 velocity
    什么是VelocityViewServlet 使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用   Servlet + Velocity的一般步骤 1.自定义Servlet，实现VelocityViewServl
  • 【Kafka十二】关于Kafka是一个Commit Log Service bit1129 service
    Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？   A message is considered "committed" when all in sync replicas for that partition have applied i
  • NGINX + LUA实现复杂的控制 ronin47 lua nginx 控制
    安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。 这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
  • java-14.输入一个已经按升序排序过的数组和一个数字， 在数组中查找两个数，使得它们的和正好是输入的那个数字 bylijinnan java
    public class TwoElementEqualSum { /** * 第 14 题： 题目：输入一个已经按升序排序过的数组和一个数字， 在数组中查找两个数，使得它们的和正好是输入的那个数字。 要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。 例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于
  • Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder bylijinnan javanetty
    今天看Netty如何实现一个Http Server org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： pipeline.addLast("decoder", new HttpRequestDecoder()); pipeline.addLast(&quo
  • java敏感词过虑-基于多叉树原理 cngolon 违禁词过虑替换违禁词敏感词过虑多叉树
    基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。   2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 utf-8的words.dict文本文件，
  • 多线程知识 cuishikuan 多线程
    T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 public class T1 implements Runnable{           @Override      
  • spring整合activemq dalan_123 java spring jms
    整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分：     a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接      b、真正产生到JMS服务器链接的ConnectionFactory还得
  • MySQL时间字段究竟使用INT还是DateTime？ dcj3sjt126com mysql
      环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 第一步、创建一个表date_test（非定长、int时间） CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
  • Parcel: unable to marshal value dcj3sjt126com marshal
    在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。   在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）：   Intent intent = new Intent(this, Next
  • linux进程的查看上（ps） eksliang linux pslinux ps -llinux ps aux
    ps:将某个时间点的进程运行情况选取下来 转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 http://eksliang.iteye.com         ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
  • 为什么第三方应用能早于System的app启动 gqdy365 System
    Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
  • App Framework发送JSONP请求(3) hw1287789687 jsonp跨域请求发送jsonpajax请求越狱请求
    App Framework 中如何发送JSONP请求呢? 使用jsonp,详情请参考:http://json-p.org/ 如何发送Ajax请求呢? (1)登录 /*** * 会员登录 * @param username * @param password */ var user_login=function(username,password){ // aler
  • 发福利，整理了一份关于“资源汇总”的汇总 justjavac 资源
    觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN 通用 free-programming-books-zh_CN 免费的计算机编程类中文书籍 精彩博客集合 hacke2/hacke2.github.io#2 ResumeSample 程序员简历
  • 用 Java 技术创建 RESTful Web 服务 macroli java编程WebREST
    转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/   JAX-RS (JSR-311) 【 Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
  • CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项 超声波 oraclelinux
    前言： 这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。   安装过程中可能遇到的问题（注
  • HttpClient 4.3 设置keeplive 和 timeout 的方法 supben httpclient
    ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() { @Override public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive
  • Spring 4.2新特性-@Import注解的升级 wiselyman spring 4
    3.1 @Import @Import注解在4.2之前只支持导入配置类 在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 3.2 示例 演示java类 package com.wisely.spring4_2.imp; public class DemoService { public void doSomethin
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他