Spring Boot 与 Kotlin 上传文件

group 'name.quanke.kotlin'
version '1.0-SNAPSHOT'

buildscript {
 ext.kotlin_version = '1.2.10'
 ext.spring_boot_version = '1.5.4.RELEASE'
 repositories {
 mavenCentral()
 }
 dependencies {
 classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
 classpath("org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_version")

// Kotlin整合SpringBoot的默认无参构造函数，默认把所有的类设置open类插件
 classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlin_version")
 classpath("org.jetbrains.kotlin:kotlin-allopen:$kotlin_version")
 
 }
}

apply plugin: 'kotlin'
apply plugin: "kotlin-spring" // See https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-spring-compiler-plugin
apply plugin: 'org.springframework.boot'


jar {
 baseName = 'chapter11-5-6-service'
 version = '0.1.0'
}
repositories {
 mavenCentral()
}


dependencies {
 compile "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
 compile "org.springframework.boot:spring-boot-starter-web:$spring_boot_version"
 compile "org.springframework.boot:spring-boot-starter-thymeleaf:$spring_boot_version"

 testCompile "org.springframework.boot:spring-boot-starter-test:$spring_boot_version"
 testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"

}

compileKotlin {
 kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
 kotlinOptions.jvmTarget = "1.8"
}

import name.quanke.kotlin.chaper11_5_6.storage.StorageFileNotFoundException
import name.quanke.kotlin.chaper11_5_6.storage.StorageService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.core.io.Resource
import org.springframework.http.HttpHeaders
import org.springframework.http.ResponseEntity
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.*
import org.springframework.web.multipart.MultipartFile
import org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder
import org.springframework.web.servlet.mvc.support.RedirectAttributes

import java.io.IOException
import java.util.stream.Collectors


/**
 * 文件上传控制器
 * Created by http://quanke.name on 2018/1/12.
 */

@Controller
class FileUploadController @Autowired
constructor(private val storageService: StorageService) {

 @GetMapping("/")
 @Throws(IOException::class)
 fun listUploadedFiles(model: Model): String {

 model.addAttribute("files", storageService
 .loadAll()
 .map { path ->
 MvcUriComponentsBuilder
 .fromMethodName(FileUploadController::class.java, "serveFile", path.fileName.toString())
 .build().toString()
 }
 .collect(Collectors.toList()))

 return "uploadForm"
 }

 @GetMapping("/files/{filename:.+}")
 @ResponseBody
 fun serveFile(@PathVariable filename: String): ResponseEntity<Resource> {

 val file = storageService.loadAsResource(filename)
 return ResponseEntity
 .ok()
 .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=/"" + file.filename + "/"")
 .body(file)
 }

 @PostMapping("/")
 fun handleFileUpload(@RequestParam("file") file: MultipartFile,
 redirectAttributes: RedirectAttributes): String {

 storageService.store(file)
 redirectAttributes.addFlashAttribute("message",
 "You successfully uploaded " + file.originalFilename + "!")

 return "redirect:/"
 }

 @ExceptionHandler(StorageFileNotFoundException::class)
 fun handleStorageFileNotFound(exc: StorageFileNotFoundException): ResponseEntity<*> {
 return ResponseEntity.notFound().build<Any>()
 }

}

import org.springframework.core.io.Resource
import org.springframework.web.multipart.MultipartFile

import java.nio.file.Path
import java.util.stream.Stream

interface StorageService {

 fun init()

 fun store(file: MultipartFile)

 fun loadAll(): Stream<Path>

 fun load(filename: String): Path

 fun loadAsResource(filename: String): Resource

 fun deleteAll()

}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.core.io.Resource
import org.springframework.core.io.UrlResource
import org.springframework.stereotype.Service
import org.springframework.util.FileSystemUtils
import org.springframework.util.StringUtils
import org.springframework.web.multipart.MultipartFile
import java.io.IOException
import java.net.MalformedURLException
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import java.nio.file.StandardCopyOption
import java.util.stream.Stream

@Service
class FileSystemStorageService @Autowired
constructor(properties: StorageProperties) : StorageService {

 private val rootLocation: Path

 init {
 this.rootLocation = Paths.get(properties.location)
 }

 override fun store(file: MultipartFile) {
 val filename = StringUtils.cleanPath(file.originalFilename)
 try {
 if (file.isEmpty) {
 throw StorageException("Failed to store empty file " + filename)
 }
 if (filename.contains("..")) {
 // This is a security check
 throw StorageException(
 "Cannot store file with relative path outside current directory " + filename)
 }
 Files.copy(file.inputStream, this.rootLocation.resolve(filename),
 StandardCopyOption.REPLACE_EXISTING)
 } catch (e: IOException) {
 throw StorageException("Failed to store file " + filename, e)
 }

 }

 override fun loadAll(): Stream<Path> {
 try {
 return Files.walk(this.rootLocation, 1)
 .filter { path -> path != this.rootLocation }
 .map { path -> this.rootLocation.relativize(path) }
 } catch (e: IOException) {
 throw StorageException("Failed to read stored files", e)
 }

 }

 override fun load(filename: String): Path {
 return rootLocation.resolve(filename)
 }

 override fun loadAsResource(filename: String): Resource {
 try {
 val file = load(filename)
 val resource = UrlResource(file.toUri())
 return if (resource.exists() || resource.isReadable) {
 resource
 } else {
 throw StorageFileNotFoundException(
 "Could not read file: " + filename)

 }
 } catch (e: MalformedURLException) {
 throw StorageFileNotFoundException("Could not read file: " + filename, e)
 }

 }

 override fun deleteAll() {
 FileSystemUtils.deleteRecursively(rootLocation.toFile())
 }

 override fun init() {
 try {
 Files.createDirectories(rootLocation)
 } catch (e: IOException) {
 throw StorageException("Could not initialize storage", e)
 }

 }
}

open class StorageException : RuntimeException {

 constructor(message: String) : super(message)

 constructor(message: String, cause: Throwable) : super(message, cause)
}

class StorageFileNotFoundException : StorageException {

 constructor(message: String) : super(message)

 constructor(message: String, cause: Throwable) : super(message, cause)
}

import org.springframework.boot.context.properties.ConfigurationProperties

@ConfigurationProperties("storage")
class StorageProperties {

 /**
 * Folder location for storing files
 */
 var location = "upload-dir"

}

/**
 * Created by http://quanke.name on 2018/1/9.
 */

@SpringBootApplication
@EnableConfigurationProperties(StorageProperties::class)
class Application {

 @Bean
 internal fun init(storageService: StorageService) = CommandLineRunner {
 storageService.deleteAll()
 storageService.init()
 }

 companion object {

 @Throws(Exception::class)
 @JvmStatic
 fun main(args: Array<String>) {
 SpringApplication.run(Application::class.java, *args)
 }
 }
}

<html xmlns:th="http://www.thymeleaf.org">
<body>

<div th:if="${message}">
 <h2 th:text="${message}"/>
</div>

<div>
 <form method="POST" enctype="multipart/form-data" action="/">
 <table>
 <tr>
 <td>File to upload:</td>
 <td><input type="file" name="file"/></td>
 </tr>
 <tr>
 <td></td>
 <td><input type="submit" value="Upload"/></td>
 </tr>
 </table>
 </form>
</div>

<div>
 <ul>
 <li th:each="file : ${files}">
 <a th:href="${file}" th:text="${file}"/>
 </li>
 </ul>
</div>

</body>
</html>

spring:
 http:
 multipart:
 max-file-size: 128KB
 max-request-size: 128KB