diff --git a/src/main/scala/gitbucket/core/controller/ControllerBase.scala b/src/main/scala/gitbucket/core/controller/ControllerBase.scala
index f05770b..a4bc72c 100644
--- a/src/main/scala/gitbucket/core/controller/ControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/ControllerBase.scala
@@ -20,6 +20,7 @@
 import is.tagomor.woothee.Classifier
 
 import scala.util.Try
+import scala.util.Using
 import net.coobird.thumbnailator.Thumbnails
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.ObjectId
@@ -240,7 +241,7 @@
       case false                                => None
     }
 
-    using(new TreeWalk(git.getRepository)) { treeWalk =>
+    Using.resource(new TreeWalk(git.getRepository)) { treeWalk =>
       treeWalk.addTree(revCommit.getTree)
       treeWalk.setRecursive(true)
       _getPathObjectId(path, treeWalk)
@@ -268,7 +269,7 @@
           response.setContentLength(attrs("size").toInt)
           val oid = attrs("oid").split(":")(1)
 
-          using(new FileInputStream(FileUtil.getLfsFilePath(repository.owner, repository.name, oid))) { in =>
+          Using.resource(new FileInputStream(FileUtil.getLfsFilePath(repository.owner, repository.name, oid))) { in =>
             IOUtils.copy(in, response.getOutputStream)
           }
         } else {
diff --git a/src/main/scala/gitbucket/core/controller/FileUploadController.scala b/src/main/scala/gitbucket/core/controller/FileUploadController.scala
index c751776..3d7a834 100644
--- a/src/main/scala/gitbucket/core/controller/FileUploadController.scala
+++ b/src/main/scala/gitbucket/core/controller/FileUploadController.scala
@@ -16,6 +16,8 @@
 import org.scalatra.servlet.{FileItem, FileUploadSupport, MultipartConfig}
 import org.apache.commons.io.{FileUtils, IOUtils}
 
+import scala.util.Using
+
 /**
  * Provides Ajax based file upload functionality.
  *
@@ -80,7 +82,7 @@
             { (file, fileId) =>
               val fileName = file.getName
               LockUtil.lock(s"${owner}/${repository}/wiki") {
-                using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) {
+                Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) {
                   git =>
                     val builder = DirCache.newInCore.builder()
                     val inserter = git.getRepository.newObjectInserter()
diff --git a/src/main/scala/gitbucket/core/controller/PullRequestsController.scala b/src/main/scala/gitbucket/core/controller/PullRequestsController.scala
index 2eae306..4c0bfd8 100644
--- a/src/main/scala/gitbucket/core/controller/PullRequestsController.scala
+++ b/src/main/scala/gitbucket/core/controller/PullRequestsController.scala
@@ -1,7 +1,5 @@
 package gitbucket.core.controller
 
-import gitbucket.core.model.{CommitComment, CommitComments, IssueComment, WebHook}
-import gitbucket.core.plugin.PluginRegistry
 import gitbucket.core.pulls.html
 import gitbucket.core.service.CommitStatusService
 import gitbucket.core.service.MergeService
@@ -15,11 +13,9 @@
 import gitbucket.core.util._
 import org.scalatra.forms._
 import org.eclipse.jgit.api.Git
-import org.eclipse.jgit.lib.{ObjectId, PersonIdent}
-import org.eclipse.jgit.revwalk.RevWalk
 import org.scalatra.BadRequest
 
-import scala.collection.JavaConverters._
+import scala.util.Using
 
 class PullRequestsController
     extends PullRequestsControllerBase
@@ -273,7 +269,7 @@
       } else {
         if (repository.repository.defaultBranch != pullreq.requestBranch) {
           val userName = context.loginAccount.get.userName
-          using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+          Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
             git.branchDelete().setForce(true).setBranchNames(pullreq.requestBranch).call()
             recordDeleteBranchActivity(repository.owner, repository.name, userName, pullreq.requestBranch)
           }
@@ -316,9 +312,11 @@
             } else {
               s"${pullreq.userName}:${pullreq.branch}"
             }
-          val existIds = using(Git.open(Directory.getRepositoryDir(owner, name))) { git =>
-            JGitUtil.getAllCommitIds(git)
-          }.toSet
+          val existIds = Using
+            .resource(Git.open(Directory.getRepositoryDir(owner, name))) { git =>
+              JGitUtil.getAllCommitIds(git)
+            }
+            .toSet
           pullRemote(
             repository,
             pullreq.requestBranch,
@@ -372,7 +370,7 @@
       case (Some(originUserName), Some(originRepositoryName)) => {
         getRepository(originUserName, originRepositoryName).map {
           originRepository =>
-            using(
+            Using.resources(
               Git.open(getRepositoryDir(originUserName, originRepositoryName)),
               Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
             ) { (oldGit, newGit) =>
@@ -388,7 +386,7 @@
         } getOrElse NotFound()
       }
       case _ => {
-        using(Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))) { git =>
+        Using.resource(Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))) { git =>
           JGitUtil.getDefaultBranch(git, forkedRepository).map {
             case (_, defaultBranch) =>
               redirect(
@@ -510,7 +508,7 @@
             }
           };
           originRepository <- getRepository(originOwner, originRepositoryName)) yield {
-      using(
+      Using.resources(
         Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
         Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
       ) {
@@ -585,7 +583,7 @@
       context.loginAccount.map(x => Seq(x.mailAddress) ++ getAccountExtraMailAddresses(x.userName)).getOrElse(Nil)
 
     val branches =
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) {
         git =>
           JGitUtil
             .getBranches(
diff --git a/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala b/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
index c736226..b4b509e 100644
--- a/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
+++ b/src/main/scala/gitbucket/core/controller/RepositorySettingsController.scala
@@ -12,12 +12,14 @@
 import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.Directory._
+import gitbucket.core.model.WebHookContentType
 import org.scalatra.forms._
 import org.scalatra.i18n.Messages
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.lib.Constants
 import org.eclipse.jgit.lib.ObjectId
-import gitbucket.core.model.WebHookContentType
+
+import scala.util.Using
 
 class RepositorySettingsController
     extends RepositorySettingsControllerBase
@@ -164,7 +166,7 @@
     } else {
       saveRepositoryDefaultBranch(repository.owner, repository.name, form.defaultBranch)
       // Change repository HEAD
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         git.getRepository.updateRef(Constants.HEAD, true).link(Constants.R_HEADS + form.defaultBranch)
       }
       flash.update("info", "Repository default branch has been updated.")
@@ -252,7 +254,7 @@
       Array(h.getName, h.getValue)
     }
 
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         import scala.concurrent.duration._
         import scala.concurrent._
@@ -386,7 +388,7 @@
    */
   post("/:owner/:repository/settings/gc")(ownerOnly { repository =>
     LockUtil.lock(s"${repository.owner}/${repository.name}") {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         git.gc().call()
       }
     }
diff --git a/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala b/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala
index b13e948..386bee2 100644
--- a/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala
+++ b/src/main/scala/gitbucket/core/controller/RepositoryViewerController.scala
@@ -2,6 +2,7 @@
 
 import java.io.File
 
+import scala.util.Using
 import javax.servlet.http.{HttpServletRequest, HttpServletResponse}
 import gitbucket.core.plugin.PluginRegistry
 import gitbucket.core.repo.html
@@ -262,7 +263,7 @@
       state -> summary
     }
 
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         def getTags(sha: String): List[String] = {
           JGitUtil.getTagsOnCommit(git, sha)
@@ -315,7 +316,7 @@
     val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch)
       .needStatusCheck(context.loginAccount.get.userName)
 
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch))
 
       html.editor(
@@ -384,7 +385,7 @@
     val protectedBranch = getProtectedBranchInfo(repository.owner, repository.name, branch)
       .needStatusCheck(context.loginAccount.get.userName)
 
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch))
 
@@ -411,7 +412,7 @@
 
   get("/:owner/:repository/remove/*")(writableUsersOnly { repository =>
     val (branch, path) = repository.splitPath(multiParams("splat").head)
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch))
 
@@ -487,8 +488,6 @@
       loginAccount = context.loginAccount.get
     )
 
-    println(form.path)
-
     redirect(
       s"/${repository.owner}/${repository.name}/tree/${form.branch}${if (form.path.length == 0) "" else "/" + form.path}"
     )
@@ -496,7 +495,7 @@
 
   get("/:owner/:repository/raw/*")(referrersOnly { repository =>
     val (id, path) = repository.splitPath(multiParams("splat").head)
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
 
       getPathObjectId(git, path, revCommit).map { objectId =>
@@ -511,7 +510,7 @@
   val blobRoute = get("/:owner/:repository/blob/*")(referrersOnly { repository =>
     val (id, path) = repository.splitPath(multiParams("splat").head)
     val raw = params.get("raw").getOrElse("false").toBoolean
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
         getPathObjectId(git, path, revCommit).map {
@@ -551,7 +550,7 @@
   ajaxGet("/:owner/:repository/get-blame/*")(referrersOnly { repository =>
     val (id, path) = repository.splitPath(multiParams("splat").head)
     contentType = formats("json")
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         val last = git.log.add(git.getRepository.resolve(id)).addPath(path).setMaxCount(1).call.iterator.next.name
         Serialization.write(
@@ -586,7 +585,7 @@
     val id = params("id")
 
     try {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+      Using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
         git =>
           defining(JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))) {
             revCommit =>
@@ -615,7 +614,7 @@
 
   get("/:owner/:repository/patch/:id")(referrersOnly { repository =>
     try {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         val diff = JGitUtil.getPatch(git, None, params("id"))
         contentType = formats("txt")
         diff
@@ -628,7 +627,7 @@
   get("/:owner/:repository/patch/*...*")(referrersOnly { repository =>
     try {
       val Seq(fromId, toId) = multiParams("splat")
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         val diff = JGitUtil.getPatch(git, Some(fromId), toId)
         contentType = formats("txt")
         diff
@@ -748,7 +747,7 @@
    */
   get("/:owner/:repository/branches")(referrersOnly { repository =>
     val protectedBranches = getProtectedBranchList(repository.owner, repository.name).toSet
-    val branches = using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    val branches = Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         JGitUtil
           .getBranches(
@@ -788,7 +787,7 @@
    * Creates a tag.
    */
   post("/:owner/:repository/tag", tagForm)(writableUsersOnly { (form, repository) =>
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       JGitUtil.createTag(git, form.tagName, form.message, form.commitId)
     } match {
       case Right(message) =>
@@ -806,7 +805,7 @@
   post("/:owner/:repository/branches")(writableUsersOnly { repository =>
     val newBranchName = params.getOrElse("new", halt(400))
     val fromBranchName = params.getOrElse("from", halt(400))
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       JGitUtil.createBranch(git, fromBranchName, newBranchName)
     } match {
       case Right(message) =>
@@ -827,7 +826,7 @@
     val branchName = multiParams("splat").head
     val userName = context.loginAccount.get.userName
     if (repository.repository.defaultBranch != branchName) {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         git.branchDelete().setForce(true).setBranchNames(branchName).call()
         recordDeleteBranchActivity(repository.owner, repository.name, userName, branchName)
       }
@@ -879,7 +878,7 @@
    * Displays the file find of branch.
    */
   get("/:owner/:repository/find/*")(referrersOnly { repository =>
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       val ref = multiParams("splat").head
       JGitUtil.getTreeId(git, ref).map { treeId =>
         html.find(ref, treeId, repository)
@@ -891,7 +890,7 @@
    * Get all file list of branch.
    */
   ajaxGet("/:owner/:repository/tree-list/:tree")(referrersOnly { repository =>
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       val treeId = params("tree")
       contentType = formats("json")
       Map("paths" -> JGitUtil.getAllFileListByTreeId(git, treeId))
@@ -915,7 +914,7 @@
    * @return HTML of the file list
    */
   private def fileList(repository: RepositoryService.RepositoryInfo, revstr: String = "", path: String = ".") = {
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       if (JGitUtil.isEmpty(git)) {
         html.guide(repository, hasDeveloperRole(repository.owner, repository.name, context.loginAccount))
       } else {
@@ -974,7 +973,7 @@
     def archive(revision: String, archiveFormat: String, archive: ArchiveOutputStream)(
       entryCreator: (String, Long, java.util.Date, Int) => ArchiveEntry
     ): Unit = {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         val oid = git.getRepository.resolve(revision)
         val commit = JGitUtil.getRevCommitFromId(git, oid)
         val date = commit.getCommitterIdent.getWhen
@@ -983,7 +982,7 @@
         val pathSuffix = if (path.isEmpty) "" else s"-${path.replace('/', '-')}"
         val baseName = repository.name + "-" + repositorySuffix + pathSuffix
 
-        using(new TreeWalk(git.getRepository)) { treeWalk =>
+        Using.resource(new TreeWalk(git.getRepository)) { treeWalk =>
           treeWalk.addTree(commit.getTree)
           treeWalk.setRecursive(true)
           if (!path.isEmpty) {
@@ -1032,7 +1031,7 @@
         )
         contentType = "application/octet-stream"
         response.setBufferSize(1024 * 1024)
-        using(new ZipArchiveOutputStream(response.getOutputStream)) { zip =>
+        Using.resource(new ZipArchiveOutputStream(response.getOutputStream)) { zip =>
           archive(revision, ".zip", zip) { (path, size, date, mode) =>
             val entry = new ZipArchiveEntry(path)
             entry.setUnixMode(mode)
@@ -1048,12 +1047,12 @@
         )
         contentType = "application/octet-stream"
         response.setBufferSize(1024 * 1024)
-        using(compressor match {
+        Using.resource(compressor match {
           case "gz"  => new GzipCompressorOutputStream(response.getOutputStream)
           case "bz2" => new BZip2CompressorOutputStream(response.getOutputStream)
           case "xz"  => new XZCompressorOutputStream(response.getOutputStream)
         }) { compressorOutputStream =>
-          using(new TarArchiveOutputStream(compressorOutputStream)) { tar =>
+          Using.resource(new TarArchiveOutputStream(compressorOutputStream)) { tar =>
             tar.setBigNumberMode(TarArchiveOutputStream.BIGNUMBER_STAR)
             tar.setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU)
             tar.setAddPaxHeadersForNonAsciiNames(true)
@@ -1081,7 +1080,7 @@
       val branch = params("branch")
 
       LockUtil.lock(s"${owner}/${repository}") {
-        using(Git.open(getRepositoryDir(owner, repository))) { git =>
+        Using.resource(Git.open(getRepositoryDir(owner, repository))) { git =>
           val headName = s"refs/heads/${branch}"
           val headTip = git.getRepository.resolve(headName)
           if (headTip.getName != value) {
diff --git a/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala b/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala
index cff406a..7d9aefc 100644
--- a/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala
+++ b/src/main/scala/gitbucket/core/controller/SystemSettingsController.scala
@@ -19,6 +19,7 @@
 import org.scalatra.i18n.Messages
 
 import scala.collection.mutable.ListBuffer
+import scala.util.Using
 
 class SystemSettingsController
     extends SystemSettingsControllerBase
@@ -225,20 +226,20 @@
     val conn = request2Session(request).conn
     val meta = conn.getMetaData
     val tables = ListBuffer[Table]()
-    using(meta.getTables(null, "%", "%", Array("TABLE", "VIEW"))) {
+    Using.resource(meta.getTables(null, "%", "%", Array("TABLE", "VIEW"))) {
       rs =>
         while (rs.next()) {
           val tableName = rs.getString("TABLE_NAME")
 
           val pkColumns = ListBuffer[String]()
-          using(meta.getPrimaryKeys(null, null, tableName)) { rs =>
+          Using.resource(meta.getPrimaryKeys(null, null, tableName)) { rs =>
             while (rs.next()) {
               pkColumns += rs.getString("COLUMN_NAME").toUpperCase
             }
           }
 
           val columns = ListBuffer[Column]()
-          using(meta.getColumns(null, "%", tableName, "%")) { rs =>
+          Using.resource(meta.getColumns(null, "%", tableName, "%")) { rs =>
             while (rs.next()) {
               val columnName = rs.getString("COLUMN_NAME").toUpperCase
               columns += Column(columnName, pkColumns.contains(columnName))
@@ -259,10 +260,10 @@
         if (trimmedQuery.nonEmpty) {
           try {
             val conn = request2Session(request).conn
-            using(conn.prepareStatement(query)) {
+            Using.resource(conn.prepareStatement(query)) {
               stmt =>
                 if (trimmedQuery.toUpperCase.startsWith("SELECT")) {
-                  using(stmt.executeQuery()) {
+                  Using.resource(stmt.executeQuery()) {
                     rs =>
                       val meta = rs.getMetaData
                       val columns = for (i <- 1 to meta.getColumnCount) yield {
@@ -516,7 +517,7 @@
     response.setHeader("Content-Disposition", "attachment; filename=" + file.getName)
     response.setContentLength(file.length.toInt)
 
-    using(new FileInputStream(file)) { in =>
+    Using.resource(new FileInputStream(file)) { in =>
       IOUtils.copy(in, response.outputStream)
     }
 
diff --git a/src/main/scala/gitbucket/core/controller/WikiController.scala b/src/main/scala/gitbucket/core/controller/WikiController.scala
index 2c9764e..0441df4 100644
--- a/src/main/scala/gitbucket/core/controller/WikiController.scala
+++ b/src/main/scala/gitbucket/core/controller/WikiController.scala
@@ -13,6 +13,7 @@
 import org.scalatra.forms._
 import org.eclipse.jgit.api.Git
 import org.scalatra.i18n.Messages
+import scala.util.Using
 
 class WikiController
     extends WikiControllerBase
@@ -90,7 +91,7 @@
   get("/:owner/:repository/wiki/:page/_history")(referrersOnly { repository =>
     val pageName = StringUtil.urlDecode(params("page"))
 
-    using(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
       JGitUtil.getCommitLog(git, "master", path = pageName + ".md") match {
         case Right((logs, hasNext)) => html.history(Some(pageName), logs, repository, isEditable(repository))
         case Left(_)                => NotFound()
@@ -102,7 +103,7 @@
     val pageName = StringUtil.urlDecode(params("page"))
     val Array(from, to) = params("commitId").split("\\.\\.\\.")
 
-    using(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
       html.compare(
         Some(pageName),
         from,
@@ -118,7 +119,7 @@
   get("/:owner/:repository/wiki/_compare/:commitId")(referrersOnly { repository =>
     val Array(from, to) = params("commitId").split("\\.\\.\\.")
 
-    using(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
       html.compare(
         None,
         from,
@@ -269,7 +270,7 @@
   })
 
   get("/:owner/:repository/wiki/_history")(referrersOnly { repository =>
-    using(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
       JGitUtil.getCommitLog(git, "master") match {
         case Right((logs, hasNext)) => html.history(None, logs, repository, isEditable(repository))
         case Left(_)                => NotFound()
@@ -279,7 +280,7 @@
 
   get("/:owner/:repository/wiki/_blob/*")(referrersOnly { repository =>
     val path = multiParams("splat").head
-    using(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getWikiRepositoryDir(repository.owner, repository.name))) { git =>
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve("master"))
 
       getPathObjectId(git, path, revCommit).map { objectId =>
diff --git a/src/main/scala/gitbucket/core/controller/api/ApiGitReferenceControllerBase.scala b/src/main/scala/gitbucket/core/controller/api/ApiGitReferenceControllerBase.scala
index 198c842..1b97741 100644
--- a/src/main/scala/gitbucket/core/controller/api/ApiGitReferenceControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/api/ApiGitReferenceControllerBase.scala
@@ -3,11 +3,11 @@
 import gitbucket.core.controller.ControllerBase
 import gitbucket.core.util.Directory.getRepositoryDir
 import gitbucket.core.util.ReferrerAuthenticator
-import gitbucket.core.util.SyntaxSugars.using
 import gitbucket.core.util.Implicits._
 import org.eclipse.jgit.api.Git
 
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 trait ApiGitReferenceControllerBase extends ControllerBase {
   self: ReferrerAuthenticator =>
@@ -18,7 +18,7 @@
    */
   get("/api/v3/repos/:owner/:repository/git/refs/*")(referrersOnly { repository =>
     val revstr = multiParams("splat").head
-    using(Git.open(getRepositoryDir(params("owner"), params("repository")))) { git =>
+    Using.resource(Git.open(getRepositoryDir(params("owner"), params("repository")))) { git =>
       val ref = git.getRepository().findRef(revstr)
 
       if (ref != null) {
diff --git a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryBranchControllerBase.scala b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryBranchControllerBase.scala
index 04f42f6..6ecd316 100644
--- a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryBranchControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryBranchControllerBase.scala
@@ -3,11 +3,11 @@
 import gitbucket.core.controller.ControllerBase
 import gitbucket.core.service.{AccountService, ProtectedBranchService, RepositoryService}
 import gitbucket.core.util._
-import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.JGitUtil.getBranches
 import org.eclipse.jgit.api.Git
+import scala.util.Using
 
 trait ApiRepositoryBranchControllerBase extends ControllerBase {
   self: RepositoryService
@@ -25,7 +25,7 @@
    * https://developer.github.com/v3/repos/branches/#list-branches
    */
   get("/api/v3/repos/:owner/:repository/branches")(referrersOnly { repository =>
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       JsonFormat(
         JGitUtil
           .getBranches(
@@ -45,7 +45,7 @@
    * https://developer.github.com/v3/repos/branches/#get-branch
    */
   get("/api/v3/repos/:owner/:repository/branches/*")(referrersOnly { repository =>
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         (for {
           branch <- params.get("splat") if repository.branchList.contains(branch)
@@ -214,7 +214,7 @@
    */
   patch("/api/v3/repos/:owner/:repository/branches/*")(ownerOnly { repository =>
     import gitbucket.core.api._
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) {
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) {
       git =>
         (for {
           branch <- params.get("splat") if repository.branchList.contains(branch)
diff --git a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryCommitControllerBase.scala b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryCommitControllerBase.scala
index 5455f9c..92173b7 100644
--- a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryCommitControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryCommitControllerBase.scala
@@ -7,9 +7,9 @@
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util.{JGitUtil, ReferrerAuthenticator, RepositoryName}
-import gitbucket.core.util.SyntaxSugars.using
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.revwalk.RevWalk
+import scala.util.Using
 
 trait ApiRepositoryCommitControllerBase extends ControllerBase {
   self: AccountService with CommitsService with ReferrerAuthenticator =>
@@ -27,11 +27,11 @@
     val name = repository.name
     val sha = params("sha")
 
-    using(Git.open(getRepositoryDir(owner, name))) {
+    Using.resource(Git.open(getRepositoryDir(owner, name))) {
       git =>
         val repo = git.getRepository
         val objectId = repo.resolve(sha)
-        val commitInfo = using(new RevWalk(repo)) { revWalk =>
+        val commitInfo = Using.resource(new RevWalk(repo)) { revWalk =>
           new CommitInfo(revWalk.parseCommit(objectId))
         }
 
diff --git a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryControllerBase.scala b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryControllerBase.scala
index 5c4b13d..fa6740e 100644
--- a/src/main/scala/gitbucket/core/controller/api/ApiRepositoryControllerBase.scala
+++ b/src/main/scala/gitbucket/core/controller/api/ApiRepositoryControllerBase.scala
@@ -6,12 +6,12 @@
 import gitbucket.core.util.Directory.getRepositoryDir
 import gitbucket.core.util._
 import gitbucket.core.util.Implicits._
-import gitbucket.core.util.SyntaxSugars.using
 import gitbucket.core.model.Profile.profile.blockingApi._
 import org.eclipse.jgit.api.Git
 
 import scala.concurrent.Await
 import scala.concurrent.duration.Duration
+import scala.util.Using
 
 trait ApiRepositoryControllerBase extends ControllerBase {
   self: RepositoryService
@@ -193,7 +193,7 @@
    */
   get("/api/v3/repos/:owner/:repository/raw/*")(referrersOnly { repository =>
     val (id, path) = repository.splitPath(multiParams("splat").head)
-    using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
       val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(id))
 
       getPathObjectId(git, path, revCommit).map { objectId =>
diff --git a/src/main/scala/gitbucket/core/plugin/Plugin.scala b/src/main/scala/gitbucket/core/plugin/Plugin.scala
index e5ccb59..6d2979d 100644
--- a/src/main/scala/gitbucket/core/plugin/Plugin.scala
+++ b/src/main/scala/gitbucket/core/plugin/Plugin.scala
@@ -6,10 +6,10 @@
 import gitbucket.core.model.{Account, Issue}
 import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.service.SystemSettingsService.SystemSettings
-import gitbucket.core.util.SyntaxSugars._
 import io.github.gitbucket.solidbase.model.Version
 import org.apache.sshd.server.command.Command
 import play.twirl.api.Html
+import scala.util.Using
 
 /**
  * Trait for define plugin interface.
@@ -434,7 +434,7 @@
    * Helper method to get a resource from classpath.
    */
   protected def fromClassPath(path: String): Array[Byte] =
-    using(getClass.getClassLoader.getResourceAsStream(path)) { in =>
+    Using.resource(getClass.getClassLoader.getResourceAsStream(path)) { in =>
       val bytes = new Array[Byte](in.available)
       in.read(bytes)
       bytes
diff --git a/src/main/scala/gitbucket/core/service/MergeService.scala b/src/main/scala/gitbucket/core/service/MergeService.scala
index e3762e4..ac897b1 100644
--- a/src/main/scala/gitbucket/core/service/MergeService.scala
+++ b/src/main/scala/gitbucket/core/service/MergeService.scala
@@ -7,7 +7,6 @@
 import gitbucket.core.service.RepositoryService.RepositoryInfo
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.{JGitUtil, LockUtil}
-import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.model.Profile.profile.blockingApi._
 import org.eclipse.jgit.merge.{MergeStrategy, Merger, RecursiveMerger}
 import org.eclipse.jgit.api.Git
@@ -17,6 +16,7 @@
 import org.eclipse.jgit.revwalk.{RevCommit, RevWalk}
 
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 trait MergeService {
   self: AccountService
@@ -33,7 +33,7 @@
    * Returns true if conflict will be caused.
    */
   def checkConflict(userName: String, repositoryName: String, branch: String, issueId: Int): Option[String] = {
-    using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
+    Using.resource(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
       new MergeCacheInfo(git, branch, issueId).checkConflict()
     }
   }
@@ -50,7 +50,7 @@
     branch: String,
     issueId: Int
   ): Option[Option[String]] = {
-    using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
+    Using.resource(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
       new MergeCacheInfo(git, branch, issueId).checkConflictCache()
     }
   }
@@ -97,7 +97,7 @@
     requestBranch: String,
     issueId: Int
   ): Unit = {
-    using(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
+    Using.resource(Git.open(getRepositoryDir(userName, repositoryName))) { git =>
       git.fetch
         .setRemote(getRepositoryDir(requestUserName, requestRepositoryName).toURI.toString)
         .setRefSpecs(new RefSpec(s"refs/heads/${requestBranch}:refs/pull/${issueId}/head"))
@@ -116,7 +116,7 @@
     remoteRepositoryName: String,
     remoteBranch: String
   ): Either[String, (ObjectId, ObjectId, ObjectId)] = {
-    using(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
+    Using.resource(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
       val remoteRefName = s"refs/heads/${remoteBranch}"
       val tmpRefName = s"refs/remote-temp/${remoteUserName}/${remoteRepositoryName}/${remoteBranch}"
       val refSpec = new RefSpec(s"${remoteRefName}:${tmpRefName}").setForceUpdate(true)
@@ -175,7 +175,7 @@
     val remoteRepositoryName = remoteRepository.name
     tryMergeRemote(localUserName, localRepositoryName, localBranch, remoteUserName, remoteRepositoryName, remoteBranch).map {
       case (newTreeId, oldBaseId, oldHeadId) =>
-        using(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
+        Using.resource(Git.open(getRepositoryDir(localUserName, localRepositoryName))) { git =>
           val existIds = JGitUtil.getAllCommitIds(git).toSet
 
           val committer = new PersonIdent(loginAccount.fullName, loginAccount.mailAddress)
@@ -259,7 +259,7 @@
           getPullRequest(repository.owner, repository.name, issueId)
             .map {
               case (issue, pullreq) =>
-                using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+                Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
                   // mark issue as merged and close.
                   val commentId =
                     createComment(repository.owner, repository.name, loginAccount.userName, issueId, message, "merge")
@@ -278,11 +278,13 @@
                     pullreq.commitIdTo
                   )
 
-                  val revCommits = using(new RevWalk(git.getRepository)) { revWalk =>
-                    commits.flatten.map { commit =>
-                      revWalk.parseCommit(git.getRepository.resolve(commit.id))
+                  val revCommits = Using
+                    .resource(new RevWalk(git.getRepository)) { revWalk =>
+                      commits.flatten.map { commit =>
+                        revWalk.parseCommit(git.getRepository.resolve(commit.id))
+                      }
                     }
-                  }.reverse
+                    .reverse
 
                   // merge git repository
                   (strategy match {
@@ -402,7 +404,7 @@
       mergeCommit.setCommitter(committer)
       mergeCommit.setMessage(message)
       // insertObject and got mergeCommit Object Id
-      using(repository.newObjectInserter) { inserter =>
+      Using.resource(repository.newObjectInserter) { inserter =>
         val mergeCommitId = inserter.insert(mergeCommit)
         inserter.flush()
         mergeCommitId
@@ -470,7 +472,7 @@
       } catch {
         case e: NoMergeBaseException => true
       }
-      val mergeTipCommit = using(new RevWalk(repository))(_.parseCommit(mergeTip))
+      val mergeTipCommit = Using.resource(new RevWalk(repository))(_.parseCommit(mergeTip))
       val committer = mergeTipCommit.getCommitterIdent
 
       def _updateBranch(treeId: ObjectId, message: String, branchName: String): Unit = {
@@ -523,10 +525,10 @@
         newCommit
       }
 
-      val mergeBaseTipCommit = using(new RevWalk(repository))(_.parseCommit(mergeBaseTip))
+      val mergeBaseTipCommit = Using.resource(new RevWalk(repository))(_.parseCommit(mergeBaseTip))
       var previousId = mergeBaseTipCommit.getId
 
-      using(repository.newObjectInserter) { inserter =>
+      Using.resource(repository.newObjectInserter) { inserter =>
         commits.foreach { commit =>
           val nextCommit = _cloneCommit(commit, previousId, mergeBaseTipCommit.getId)
           previousId = inserter.insert(nextCommit)
@@ -542,8 +544,9 @@
         throw new RuntimeException("This pull request can't merge automatically.")
       }
 
-      val mergeBaseTipCommit = using(new RevWalk(repository))(_.parseCommit(mergeBaseTip))
-      val mergeBranchHeadCommit = using(new RevWalk(repository))(_.parseCommit(repository.resolve(mergedBranchName)))
+      val mergeBaseTipCommit = Using.resource(new RevWalk(repository))(_.parseCommit(mergeBaseTip))
+      val mergeBranchHeadCommit =
+        Using.resource(new RevWalk(repository))(_.parseCommit(repository.resolve(mergedBranchName)))
 
       // Create squash commit
       val mergeCommit = new CommitBuilder()
@@ -554,7 +557,7 @@
       mergeCommit.setMessage(message)
 
       // insertObject and got squash commit Object Id
-      val newCommitId = using(repository.newObjectInserter) { inserter =>
+      val newCommitId = Using.resource(repository.newObjectInserter) { inserter =>
         val newCommitId = inserter.insert(mergeCommit)
         inserter.flush()
         newCommitId
@@ -577,7 +580,7 @@
     private def createMergeCommit(treeId: ObjectId, committer: PersonIdent, message: String) =
       Util.createMergeCommit(repository, treeId, committer, message, Seq[ObjectId](mergeBaseTip, mergeTip))
 
-    private def parseCommit(id: ObjectId) = using(new RevWalk(repository))(_.parseCommit(id))
+    private def parseCommit(id: ObjectId) = Using.resource(new RevWalk(repository))(_.parseCommit(id))
 
   }
 
diff --git a/src/main/scala/gitbucket/core/service/PullRequestService.scala b/src/main/scala/gitbucket/core/service/PullRequestService.scala
index 871b3f9..10e9958 100644
--- a/src/main/scala/gitbucket/core/service/PullRequestService.scala
+++ b/src/main/scala/gitbucket/core/service/PullRequestService.scala
@@ -8,7 +8,6 @@
 import gitbucket.core.api.JsonFormat
 import gitbucket.core.controller.Context
 import gitbucket.core.plugin.PluginRegistry
-import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.Implicits._
 import gitbucket.core.util.JGitUtil
@@ -20,6 +19,7 @@
 import org.eclipse.jgit.lib.ObjectId
 
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 trait PullRequestService {
   self: IssuesService
@@ -387,7 +387,7 @@
     requestRepositoryName: String,
     requestCommitId: String
   ): (Seq[Seq[CommitInfo]], Seq[DiffInfo]) =
-    using(
+    Using.resources(
       Git.open(getRepositoryDir(userName, repositoryName)),
       Git.open(getRepositoryDir(requestUserName, requestRepositoryName))
     ) { (oldGit, newGit) =>
@@ -478,7 +478,7 @@
     originId: String,
     forkedId: String
   ): (Option[ObjectId], Option[ObjectId]) = {
-    using(
+    Using.resources(
       Git.open(getRepositoryDir(originRepository.owner, originRepository.name)),
       Git.open(getRepositoryDir(forkedRepository.owner, forkedRepository.name))
     ) {
diff --git a/src/main/scala/gitbucket/core/service/RepositoryCommitFileService.scala b/src/main/scala/gitbucket/core/service/RepositoryCommitFileService.scala
index a808af0..dd95c82 100644
--- a/src/main/scala/gitbucket/core/service/RepositoryCommitFileService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositoryCommitFileService.scala
@@ -8,11 +8,11 @@
 import gitbucket.core.util.Directory.getRepositoryDir
 import gitbucket.core.util.JGitUtil.CommitInfo
 import gitbucket.core.util.{JGitUtil, LockUtil}
-import gitbucket.core.util.SyntaxSugars.using
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.dircache.{DirCache, DirCacheBuilder}
 import org.eclipse.jgit.lib._
 import org.eclipse.jgit.transport.{ReceiveCommand, ReceivePack}
+import scala.util.Using
 
 trait RepositoryCommitFileService {
   self: AccountService with ActivityService with IssuesService with PullRequestService with WebHookPullRequestService =>
@@ -117,7 +117,7 @@
   )(implicit s: Session, c: JsonFormat.Context): ObjectId = {
 
     LockUtil.lock(s"${repository.owner}/${repository.name}") {
-      using(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
+      Using.resource(Git.open(getRepositoryDir(repository.owner, repository.name))) { git =>
         val builder = DirCache.newInCore.builder()
         val inserter = git.getRepository.newObjectInserter()
         val headName = s"refs/heads/${branch}"
diff --git a/src/main/scala/gitbucket/core/service/RepositorySearchService.scala b/src/main/scala/gitbucket/core/service/RepositorySearchService.scala
index a06af1d..5458659 100644
--- a/src/main/scala/gitbucket/core/service/RepositorySearchService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositorySearchService.scala
@@ -4,12 +4,12 @@
 import gitbucket.core.util._
 import gitbucket.core.util.StringUtil
 import Directory._
-import SyntaxSugars._
 import org.eclipse.jgit.revwalk.RevWalk
 import org.eclipse.jgit.treewalk.TreeWalk
 import org.eclipse.jgit.lib.FileMode
 import org.eclipse.jgit.api.Git
 import gitbucket.core.model.Profile.profile.blockingApi._
+import scala.util.Using
 
 trait RepositorySearchService { self: IssuesService =>
   import RepositorySearchService._
@@ -37,12 +37,12 @@
     }
 
   def countFiles(owner: String, repository: String, query: String): Int =
-    using(Git.open(getRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(getRepositoryDir(owner, repository))) { git =>
       if (JGitUtil.isEmpty(git)) 0 else searchRepositoryFiles(git, query).length
     }
 
   def searchFiles(owner: String, repository: String, query: String): List[FileSearchResult] =
-    using(Git.open(getRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(getRepositoryDir(owner, repository))) { git =>
       if (JGitUtil.isEmpty(git)) {
         Nil
       } else {
@@ -57,12 +57,12 @@
     }
 
   def countWikiPages(owner: String, repository: String, query: String): Int =
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
       if (JGitUtil.isEmpty(git)) 0 else searchRepositoryFiles(git, query).length
     }
 
   def searchWikiPages(owner: String, repository: String, query: String): List[FileSearchResult] =
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
       if (JGitUtil.isEmpty(git)) {
         Nil
       } else {
diff --git a/src/main/scala/gitbucket/core/service/RepositoryService.scala b/src/main/scala/gitbucket/core/service/RepositoryService.scala
index 2f152db..3081952 100644
--- a/src/main/scala/gitbucket/core/service/RepositoryService.scala
+++ b/src/main/scala/gitbucket/core/service/RepositoryService.scala
@@ -17,6 +17,7 @@
 import org.eclipse.jgit.dircache.{DirCache, DirCacheBuilder}
 import org.eclipse.jgit.lib.{Repository => _, _}
 import org.eclipse.jgit.transport.{ReceiveCommand, ReceivePack}
+import scala.util.Using
 
 trait RepositoryService {
   self: AccountService =>
@@ -763,7 +764,7 @@
         }
 
     // Get template file from project root. When didn't find, will lookup default folder.
-    using(Git.open(Directory.getRepositoryDir(repository.owner, repository.name))) { git =>
+    Using.resource(Git.open(Directory.getRepositoryDir(repository.owner, repository.name))) { git =>
       choiceTemplate(JGitUtil.getFileList(git, repository.repository.defaultBranch, "."))
         .orElse {
           choiceTemplate(JGitUtil.getFileList(git, repository.repository.defaultBranch, ".gitbucket"))
diff --git a/src/main/scala/gitbucket/core/service/SystemSettingsService.scala b/src/main/scala/gitbucket/core/service/SystemSettingsService.scala
index 93e896c..8f4e50e 100644
--- a/src/main/scala/gitbucket/core/service/SystemSettingsService.scala
+++ b/src/main/scala/gitbucket/core/service/SystemSettingsService.scala
@@ -8,6 +8,7 @@
 import gitbucket.core.util.ConfigUtil._
 import gitbucket.core.util.Directory._
 import gitbucket.core.util.SyntaxSugars._
+import scala.util.Using
 
 trait SystemSettingsService {
 
@@ -70,7 +71,7 @@
       props.setProperty(SkinName, settings.skinName.toString)
       props.setProperty(ShowMailAddress, settings.showMailAddress.toString)
 
-      using(new java.io.FileOutputStream(GitBucketConf)) { out =>
+      Using.resource(new java.io.FileOutputStream(GitBucketConf)) { out =>
         props.store(out, null)
       }
     }
@@ -79,7 +80,7 @@
   def loadSystemSettings(): SystemSettings = {
     defining(new java.util.Properties()) { props =>
       if (GitBucketConf.exists) {
-        using(new java.io.FileInputStream(GitBucketConf)) { in =>
+        Using.resource(new java.io.FileInputStream(GitBucketConf)) { in =>
           props.load(in)
         }
       }
diff --git a/src/main/scala/gitbucket/core/service/WikiService.scala b/src/main/scala/gitbucket/core/service/WikiService.scala
index 47be225..bdae1c7 100644
--- a/src/main/scala/gitbucket/core/service/WikiService.scala
+++ b/src/main/scala/gitbucket/core/service/WikiService.scala
@@ -16,6 +16,7 @@
 import org.eclipse.jgit.api.errors.PatchFormatException
 
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 object WikiService {
 
@@ -74,7 +75,7 @@
    * Returns the wiki page.
    */
   def getWikiPage(owner: String, repository: String, pageName: String): Option[WikiPageInfo] = {
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
       if (!JGitUtil.isEmpty(git)) {
         JGitUtil.getFileList(git, "master", ".").find(_.name == pageName + ".md").map { file =>
           WikiPageInfo(
@@ -93,7 +94,7 @@
    * Returns the list of wiki page names.
    */
   def getWikiPageList(owner: String, repository: String): List[String] = {
-    using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
       JGitUtil
         .getFileList(git, "master", ".")
         .filter(_.name.endsWith(".md"))
@@ -119,7 +120,7 @@
 
     try {
       LockUtil.lock(s"${owner}/${repository}/wiki") {
-        using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+        Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
           val reader = git.getRepository.newObjectReader
           val oldTreeIter = new CanonicalTreeParser
           oldTreeIter.reset(reader, git.getRepository.resolve(from + "^{tree}"))
@@ -134,7 +135,7 @@
             }
           }
 
-          val patch = using(new java.io.ByteArrayOutputStream()) { out =>
+          val patch = Using.resource(new java.io.ByteArrayOutputStream()) { out =>
             val formatter = new DiffFormatter(out)
             formatter.setRepository(git.getRepository)
             formatter.format(diffs.asJava)
@@ -238,7 +239,7 @@
     currentId: Option[String]
   ): Option[String] = {
     LockUtil.lock(s"${owner}/${repository}/wiki") {
-      using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+      Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
         val builder = DirCache.newInCore.builder()
         val inserter = git.getRepository.newObjectInserter()
         val headId = git.getRepository.resolve(Constants.HEAD + "^{commit}")
@@ -310,7 +311,7 @@
     message: String
   ): Unit = {
     LockUtil.lock(s"${owner}/${repository}/wiki") {
-      using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+      Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
         val builder = DirCache.newInCore.builder()
         val inserter = git.getRepository.newObjectInserter()
         val headId = git.getRepository.resolve(Constants.HEAD + "^{commit}")
diff --git a/src/main/scala/gitbucket/core/servlet/GitLfsTransferServlet.scala b/src/main/scala/gitbucket/core/servlet/GitLfsTransferServlet.scala
index 62b61dc..17f1a34 100644
--- a/src/main/scala/gitbucket/core/servlet/GitLfsTransferServlet.scala
+++ b/src/main/scala/gitbucket/core/servlet/GitLfsTransferServlet.scala
@@ -8,7 +8,8 @@
 import org.apache.commons.io.{FileUtils, IOUtils}
 import org.json4s.jackson.Serialization._
 import org.apache.http.HttpStatus
-import gitbucket.core.util.SyntaxSugars._
+
+import scala.util.Using
 
 /**
  * Provides GitLFS Transfer API
@@ -29,7 +30,7 @@
         res.setStatus(HttpStatus.SC_OK)
         res.setContentType("application/octet-stream")
         res.setHeader("Content-Length", file.length.toString)
-        using(new FileInputStream(file), res.getOutputStream) { (in, out) =>
+        Using.resources(new FileInputStream(file), res.getOutputStream) { (in, out) =>
           IOUtils.copy(in, out)
           out.flush()
         }
@@ -45,7 +46,7 @@
     } yield {
       val file = new File(FileUtil.getLfsFilePath(owner, repository, oid))
       FileUtils.forceMkdir(file.getParentFile)
-      using(req.getInputStream, new FileOutputStream(file)) { (in, out) =>
+      Using.resources(req.getInputStream, new FileOutputStream(file)) { (in, out) =>
         IOUtils.copy(in, out)
       }
       res.setStatus(HttpStatus.SC_OK)
@@ -71,7 +72,7 @@
 
   private def sendError(res: HttpServletResponse, status: Int, message: String): Unit = {
     res.setStatus(status)
-    using(res.getWriter()) { out =>
+    Using.resource(res.getWriter()) { out =>
       out.write(write(GitLfs.Error(message)))
       out.flush()
     }
diff --git a/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala b/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala
index 6151e09..51e5896 100644
--- a/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala
+++ b/src/main/scala/gitbucket/core/servlet/GitRepositoryServlet.scala
@@ -4,6 +4,8 @@
 import java.util
 import java.util.Date
 
+import scala.util.Using
+
 import gitbucket.core.api
 import gitbucket.core.model.WebHook
 import gitbucket.core.plugin.{GitRepositoryRouting, PluginRegistry}
@@ -144,7 +146,7 @@
               }
 
               res.setContentType("application/vnd.git-lfs+json")
-              using(res.getWriter) { out =>
+              Using.resource(res.getWriter) { out =>
                 out.print(write(batchResponse))
                 out.flush()
               }
@@ -254,7 +256,7 @@
               command.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, error)
             }
         }
-        using(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
+        Using.resource(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
           existIds = JGitUtil.getAllCommitIds(git)
         }
       } catch {
@@ -269,7 +271,7 @@
   def onPostReceive(receivePack: ReceivePack, commands: java.util.Collection[ReceiveCommand]): Unit = {
     Database() withTransaction { implicit session =>
       try {
-        using(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
+        Using.resource(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
           JGitUtil.removeCache(git)
 
           val pushedIds = scala.collection.mutable.Set[String]()
@@ -293,7 +295,7 @@
             if (JGitUtil.isEmpty(git) && commits.nonEmpty && branchName != repositoryInfo.repository.defaultBranch) {
               saveRepositoryDefaultBranch(owner, repository, branchName)
               // Change repository HEAD
-              using(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
+              Using.resource(Git.open(Directory.getRepositoryDir(owner, repository))) { git =>
                 git.getRepository.updateRef(Constants.HEAD, true).link(Constants.R_HEADS + branchName)
               }
             }
@@ -447,7 +449,7 @@
 
           commitIds.foreach {
             case (oldCommitId, newCommitId) =>
-              val commits = using(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
+              val commits = Using.resource(Git.open(Directory.getWikiRepositoryDir(owner, repository))) { git =>
                 JGitUtil.getCommitLog(git, oldCommitId, newCommitId).flatMap { commit =>
                   val diffs = JGitUtil.getDiffs(git, None, commit.id, false, false)
                   diffs.collect {
diff --git a/src/main/scala/gitbucket/core/servlet/InitializeListener.scala b/src/main/scala/gitbucket/core/servlet/InitializeListener.scala
index 1c03e5a..b2335f1 100644
--- a/src/main/scala/gitbucket/core/servlet/InitializeListener.scala
+++ b/src/main/scala/gitbucket/core/servlet/InitializeListener.scala
@@ -9,7 +9,6 @@
 import gitbucket.core.service.{ActivityService, SystemSettingsService}
 import gitbucket.core.util.DatabaseConfig
 import gitbucket.core.util.Directory._
-import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.util.JDBCUtil._
 import gitbucket.core.model.Profile.profile.blockingApi._
 // Imported names have higher precedence than names, defined in other files.
@@ -26,6 +25,7 @@
 import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension
 
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 
 /**
  * Initialize GitBucket system.
@@ -142,7 +142,7 @@
     logger.info("Extract bundled plugins...")
     val cl = Thread.currentThread.getContextClassLoader
     try {
-      using(cl.getResourceAsStream("bundle-plugins.txt")) { pluginsFile =>
+      Using.resource(cl.getResourceAsStream("bundle-plugins.txt")) { pluginsFile =>
         if (pluginsFile != null) {
           val plugins = IOUtils.readLines(pluginsFile, "UTF-8")
           val gitbucketVersion = GitBucketCoreModule.getVersions.asScala.last.getVersion
@@ -157,7 +157,7 @@
                   logger.info(s"Extract to ${file.getAbsolutePath}")
 
                   FileUtils.forceMkdirParent(file)
-                  using(in, new FileOutputStream(file)) {
+                  Using.resources(in, new FileOutputStream(file)) {
                     case (in, out) => IOUtils.copy(in, out)
                   }
                 }
diff --git a/src/main/scala/gitbucket/core/ssh/GitCommand.scala b/src/main/scala/gitbucket/core/ssh/GitCommand.scala
index 8e8cfe5..f6a42cb 100644
--- a/src/main/scala/gitbucket/core/ssh/GitCommand.scala
+++ b/src/main/scala/gitbucket/core/ssh/GitCommand.scala
@@ -11,13 +11,13 @@
 import org.slf4j.LoggerFactory
 import java.io.{File, InputStream, OutputStream}
 
-import SyntaxSugars._
 import org.eclipse.jgit.api.Git
 import Directory._
 import gitbucket.core.ssh.PublicKeyAuthenticator.AuthType
 import org.eclipse.jgit.transport.{ReceivePack, UploadPack}
 import org.apache.sshd.server.shell.UnknownCommand
 import org.eclipse.jgit.errors.RepositoryNotFoundException
+import scala.util.Using
 
 object GitCommand {
   val DefaultCommandRegex = """\Agit-(upload|receive)-pack '/([a-zA-Z0-9\-_.]+)/([a-zA-Z0-9\-\+_.]+).git'\Z""".r
@@ -152,7 +152,7 @@
     }
 
     if (execute) {
-      using(Git.open(getRepositoryDir(owner, repoName))) { git =>
+      Using.resource(Git.open(getRepositoryDir(owner, repoName))) { git =>
         val repository = git.getRepository
         val upload = new UploadPack(repository)
         upload.upload(in, out, err)
@@ -177,7 +177,7 @@
     }
 
     if (execute) {
-      using(Git.open(getRepositoryDir(owner, repoName))) { git =>
+      Using.resource(Git.open(getRepositoryDir(owner, repoName))) { git =>
         val repository = git.getRepository
         val receive = new ReceivePack(repository)
         if (!repoName.endsWith(".wiki")) {
@@ -202,7 +202,7 @@
 
     if (execute) {
       val path = routing.urlPattern.r.replaceFirstIn(repoName, routing.localPath)
-      using(Git.open(new File(Directory.GitBucketHome, path))) { git =>
+      Using.resource(Git.open(new File(Directory.GitBucketHome, path))) { git =>
         val repository = git.getRepository
         val upload = new UploadPack(repository)
         upload.upload(in, out, err)
@@ -222,7 +222,7 @@
 
     if (execute) {
       val path = routing.urlPattern.r.replaceFirstIn(repoName, routing.localPath)
-      using(Git.open(new File(Directory.GitBucketHome, path))) { git =>
+      Using.resource(Git.open(new File(Directory.GitBucketHome, path))) { git =>
         val repository = git.getRepository
         val receive = new ReceivePack(repository)
         receive.receive(in, out, err)
diff --git a/src/main/scala/gitbucket/core/util/EditorConfigUtil.scala b/src/main/scala/gitbucket/core/util/EditorConfigUtil.scala
index e68efaf..f5edc45 100644
--- a/src/main/scala/gitbucket/core/util/EditorConfigUtil.scala
+++ b/src/main/scala/gitbucket/core/util/EditorConfigUtil.scala
@@ -12,7 +12,8 @@
 import org.eclipse.jgit.lib.{ObjectReader, Repository}
 import org.eclipse.jgit.revwalk.{RevTree, RevWalk}
 import org.eclipse.jgit.treewalk.TreeWalk
-import gitbucket.core.util.SyntaxSugars._
+
+import scala.util.Using
 
 object EditorConfigUtil {
   private class JGitResource(repo: Repository, revStr: String, path: Ec4jPath) extends Resource {
@@ -27,7 +28,7 @@
     }
 
     private def getRevTree: RevTree = {
-      using(repo.newObjectReader()) { reader: ObjectReader =>
+      Using.resource(repo.newObjectReader()) { reader: ObjectReader =>
         val revWalk = new RevWalk(reader)
         val id = repo.resolve(revStr)
         val commit = revWalk.parseCommit(id)
@@ -36,7 +37,7 @@
     }
 
     override def exists(): Boolean = {
-      using(repo.newObjectReader()) { reader: ObjectReader =>
+      Using.resource(repo.newObjectReader()) { reader: ObjectReader =>
         try {
           val treeWalk = Option(TreeWalk.forPath(reader, removeInitialSlash(path), getRevTree))
           treeWalk.isDefined
@@ -59,7 +60,7 @@
     }
 
     override def openReader(): Reader = {
-      using(repo.newObjectReader) { reader: ObjectReader =>
+      Using.resource(repo.newObjectReader) { reader: ObjectReader =>
         val treeWalk = TreeWalk.forPath(reader, removeInitialSlash(path), getRevTree)
         new InputStreamReader(reader.open(treeWalk.getObjectId(0)).openStream, StandardCharsets.UTF_8)
       }
diff --git a/src/main/scala/gitbucket/core/util/JDBCUtil.scala b/src/main/scala/gitbucket/core/util/JDBCUtil.scala
index 6e7e043..0b2fa65 100644
--- a/src/main/scala/gitbucket/core/util/JDBCUtil.scala
+++ b/src/main/scala/gitbucket/core/util/JDBCUtil.scala
@@ -3,9 +3,9 @@
 import java.io._
 import java.sql._
 import java.text.SimpleDateFormat
-import SyntaxSugars._
 import scala.annotation.tailrec
 import scala.collection.mutable.ListBuffer
+import scala.util.Using
 
 /**
  * Provides implicit class which extends java.sql.Connection.
@@ -26,7 +26,7 @@
 
     def find[T](sql: String, params: Any*)(f: ResultSet => T): Option[T] = {
       execute(sql, params: _*) { stmt =>
-        using(stmt.executeQuery()) { rs =>
+        Using.resource(stmt.executeQuery()) { rs =>
           if (rs.next) Some(f(rs)) else None
         }
       }
@@ -34,7 +34,7 @@
 
     def select[T](sql: String, params: Any*)(f: ResultSet => T): Seq[T] = {
       execute(sql, params: _*) { stmt =>
-        using(stmt.executeQuery()) { rs =>
+        Using.resource(stmt.executeQuery()) { rs =>
           val list = new ListBuffer[T]
           while (rs.next) {
             list += f(rs)
@@ -46,14 +46,14 @@
 
     def selectInt(sql: String, params: Any*): Int = {
       execute(sql, params: _*) { stmt =>
-        using(stmt.executeQuery()) { rs =>
+        Using.resource(stmt.executeQuery()) { rs =>
           if (rs.next) rs.getInt(1) else 0
         }
       }
     }
 
     private def execute[T](sql: String, params: Any*)(f: (PreparedStatement) => T): T = {
-      using(conn.prepareStatement(sql)) { stmt =>
+      Using.resource(conn.prepareStatement(sql)) { stmt =>
         params.zipWithIndex.foreach {
           case (p, i) =>
             p match {
@@ -68,7 +68,7 @@
     def importAsSQL(in: InputStream): Unit = {
       conn.setAutoCommit(false)
       try {
-        using(in) { in =>
+        Using.resource(in) { in =>
           var out = new ByteArrayOutputStream()
 
           var length = 0
@@ -111,7 +111,7 @@
       val dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")
       val file = File.createTempFile("gitbucket-export-", ".sql")
 
-      using(new FileOutputStream(file)) { out =>
+      Using.resource(new FileOutputStream(file)) { out =>
         val dbMeta = conn.getMetaData
         val allTablesInDatabase = allTablesOrderByDependencies(dbMeta)
 
@@ -168,7 +168,7 @@
     }
 
     def allTableNames(): Seq[String] = {
-      using(conn.getMetaData.getTables(null, null, "%", Seq("TABLE").toArray)) { rs =>
+      Using.resource(conn.getMetaData.getTables(null, null, "%", Seq("TABLE").toArray)) { rs =>
         val tableNames = new ListBuffer[String]
         while (rs.next) {
           val name = rs.getString("TABLE_NAME").toUpperCase
@@ -188,7 +188,7 @@
           tableName
         }
 
-      using(meta.getExportedKeys(null, null, normalizedTableName)) { rs =>
+      Using.resource(meta.getExportedKeys(null, null, normalizedTableName)) { rs =>
         val children = new ListBuffer[String]
         while (rs.next) {
           val childTableName = rs.getString("FKTABLE_NAME").toUpperCase
diff --git a/src/main/scala/gitbucket/core/util/JGitUtil.scala b/src/main/scala/gitbucket/core/util/JGitUtil.scala
index c2ad5e2..8f1df6d 100644
--- a/src/main/scala/gitbucket/core/util/JGitUtil.scala
+++ b/src/main/scala/gitbucket/core/util/JGitUtil.scala
@@ -10,6 +10,7 @@
 
 import scala.annotation.tailrec
 import scala.jdk.CollectionConverters._
+import scala.util.Using
 import org.eclipse.jgit.lib._
 import org.eclipse.jgit.revwalk._
 import org.eclipse.jgit.revwalk.filter._
@@ -28,6 +29,8 @@
 import org.eclipse.jgit.util.io.DisabledOutputStream
 import org.slf4j.LoggerFactory
 
+import scala.util.Using.Releasable
+
 /**
  * Provides complex JGit operations.
  */
@@ -35,6 +38,10 @@
 
   private val logger = LoggerFactory.getLogger(JGitUtil.getClass)
 
+  implicit val objectDatabaseReleasable = new Releasable[ObjectDatabase] {
+    override def release(resource: ObjectDatabase): Unit = resource.close()
+  }
+
   /**
    * The repository data.
    *
@@ -317,7 +324,7 @@
    * Returns the repository information. It contains branch names and tag names.
    */
   def getRepositoryInfo(owner: String, repository: String): RepositoryInfo = {
-    using(Git.open(getRepositoryDir(owner, repository))) { git =>
+    Using.resource(Git.open(getRepositoryDir(owner, repository))) { git =>
       try {
         RepositoryInfo(
           owner,
@@ -364,7 +371,7 @@
    * @return HTML of the file list
    */
   def getFileList(git: Git, revision: String, path: String = ".", baseUrl: Option[String] = None): List[FileInfo] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       val objectId = git.getRepository.resolve(revision)
       if (objectId == null) return Nil
       val revCommit = revWalk.parseCommit(objectId)
@@ -373,12 +380,12 @@
         if (path == ".") {
           val treeWalk = new TreeWalk(git.getRepository)
           treeWalk.addTree(rev.getTree)
-          using(treeWalk)(f)
+          Using.resource(treeWalk)(f)
         } else {
           val treeWalk = TreeWalk.forPath(git.getRepository, path, rev.getTree)
           if (treeWalk != null) {
             treeWalk.enterSubtree
-            using(treeWalk)(f)
+            Using.resource(treeWalk)(f)
           }
         }
       @tailrec
@@ -386,7 +393,7 @@
         tuple: (ObjectId, FileMode, String, String, Option[String], RevCommit)
       ): (ObjectId, FileMode, String, String, Option[String], RevCommit) = tuple match {
         case (oid, FileMode.TREE, name, path, _, commit) =>
-          (using(new TreeWalk(git.getRepository)) { walk =>
+          (Using.resource(new TreeWalk(git.getRepository)) { walk =>
             walk.addTree(oid)
             // single tree child, or None
             if (walk.next() && walk.getFileMode(0) == FileMode.TREE) {
@@ -520,7 +527,7 @@
    * get all file list by revision. only file.
    */
   def getTreeId(git: Git, revision: String): Option[String] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       val objectId = git.getRepository.resolve(revision)
       if (objectId == null) return None
       val revCommit = revWalk.parseCommit(objectId)
@@ -532,10 +539,10 @@
    * get all file list by tree object id.
    */
   def getAllFileListByTreeId(git: Git, treeId: String): List[String] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       val objectId = git.getRepository.resolve(treeId + "^{tree}")
       if (objectId == null) return Nil
-      using(new TreeWalk(git.getRepository)) { treeWalk =>
+      Using.resource(new TreeWalk(git.getRepository)) { treeWalk =>
         treeWalk.addTree(objectId)
         treeWalk.setRecursive(true)
         var ret: List[String] = Nil
@@ -586,7 +593,7 @@
         case _ => (logs, i.hasNext)
       }
 
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       defining(git.getRepository.resolve(revision)) { objectId =>
         if (objectId == null) {
           Left(s"${revision} can't be resolved.")
@@ -618,7 +625,7 @@
         case false => logs
       }
 
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       revWalk.markStart(revWalk.parseCommit(git.getRepository.resolve(begin)))
       getCommitLog(revWalk.iterator, Nil).reverse
     }
@@ -678,7 +685,7 @@
   }
 
   private def getDiffEntries(git: Git, from: Option[String], to: String): Seq[DiffEntry] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       val df = new DiffFormatter(DisabledOutputStream.INSTANCE)
       df.setRepository(git.getRepository)
 
@@ -704,7 +711,7 @@
   }
 
   def getParentCommitId(git: Git, id: String): Option[String] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       val commit = revWalk.parseCommit(git.getRepository.resolve(id))
       commit.getParentCount match {
         case 0 => None
@@ -786,7 +793,7 @@
 
   private def makePatchFromDiffEntry(git: Git, diff: DiffEntry): String = {
     val out = new ByteArrayOutputStream()
-    using(new DiffFormatter(out)) { formatter =>
+    Using.resource(new DiffFormatter(out)) { formatter =>
       formatter.setRepository(git.getRepository)
       formatter.format(diff)
       val patch = new String(out.toByteArray) // TODO charset???
@@ -798,7 +805,7 @@
    * Returns the list of branch names of the specified commit.
    */
   def getBranchesOfCommit(git: Git, commitId: String): List[String] =
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       defining(revWalk.parseCommit(git.getRepository.resolve(commitId + "^0"))) { commit =>
         git.getRepository.getRefDatabase
           .getRefsByPrefix(Constants.R_HEADS)
@@ -841,7 +848,7 @@
    * Returns the list of tags which contains the specified commit.
    */
   def getTagsOfCommit(git: Git, commitId: String): List[String] =
-    using(new RevWalk(git.getRepository)) { revWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
       defining(revWalk.parseCommit(git.getRepository.resolve(commitId + "^0"))) { commit =>
         git.getRepository.getRefDatabase
           .getRefsByPrefix(Constants.R_TAGS)
@@ -862,13 +869,13 @@
     }
 
   def initRepository(dir: java.io.File): Unit =
-    using(new RepositoryBuilder().setGitDir(dir).setBare.build) { repository =>
+    Using.resource(new RepositoryBuilder().setGitDir(dir).setBare.build) { repository =>
       repository.create(true)
       setReceivePack(repository)
     }
 
   def cloneRepository(from: java.io.File, to: java.io.File): Unit =
-    using(Git.cloneRepository.setURI(from.toURI.toString).setDirectory(to).setBare(true).call) { git =>
+    Using.resource(Git.cloneRepository.setURI(from.toURI.toString).setDirectory(to).setBare(true).call) { git =>
       setReceivePack(git.getRepository)
     }
 
@@ -898,7 +905,7 @@
   def createTag(git: Git, name: String, message: Option[String], commitId: String) = {
     try {
       val objectId: ObjectId = git.getRepository.resolve(commitId)
-      using(new RevWalk(git.getRepository)) { walk =>
+      Using.resource(new RevWalk(git.getRepository)) { walk =>
         val tagCommand = git.tag().setName(name).setObjectId(walk.parseCommit(objectId))
         message.foreach { message =>
           tagCommand.setMessage(message)
@@ -1003,7 +1010,7 @@
       case false                                => None
     }
 
-    using(new TreeWalk(git.getRepository)) { treeWalk =>
+    Using.resource(new TreeWalk(git.getRepository)) { treeWalk =>
       treeWalk.addTree(revTree)
       treeWalk.setRecursive(true)
       getPathObjectId(path, treeWalk)
@@ -1048,7 +1055,7 @@
 
   def getContentInfo(git: Git, path: String, objectId: ObjectId): ContentInfo = {
     // Viewer
-    using(git.getRepository.getObjectDatabase) { db =>
+    Using.resource(git.getRepository.getObjectDatabase) { db =>
       val loader = db.open(objectId)
       val isLfs = isLfsPointer(loader)
       val large = FileUtil.isLarge(loader.getSize)
@@ -1086,7 +1093,7 @@
    */
   def getContentFromId(git: Git, id: ObjectId, fetchLargeFile: Boolean): Option[Array[Byte]] =
     try {
-      using(git.getRepository.getObjectDatabase) { db =>
+      Using.resource(git.getRepository.getObjectDatabase) { db =>
         val loader = db.open(id)
         if (loader.isLarge || (fetchLargeFile == false && FileUtil.isLarge(loader.getSize))) {
           None
@@ -1108,7 +1115,7 @@
    */
   def getObjectLoaderFromId[A](git: Git, id: ObjectId)(f: ObjectLoader => A): Option[A] =
     try {
-      using(git.getRepository.getObjectDatabase) { db =>
+      Using.resource(git.getRepository.getObjectDatabase) { db =>
         Some(f(db.open(id)))
       }
     } catch {
@@ -1131,8 +1138,8 @@
     }
 
   def processTree[T](git: Git, id: ObjectId)(f: (String, CanonicalTreeParser) => T): Seq[T] = {
-    using(new RevWalk(git.getRepository)) { revWalk =>
-      using(new TreeWalk(git.getRepository)) { treeWalk =>
+    Using.resource(new RevWalk(git.getRepository)) { revWalk =>
+      Using.resource(new TreeWalk(git.getRepository)) { treeWalk =>
         val index = treeWalk.addTree(revWalk.parseTree(id))
         treeWalk.setRecursive(true)
         val result = new collection.mutable.ListBuffer[T]()
@@ -1176,7 +1183,7 @@
     requestRepositoryName: String,
     requestBranch: String
   ): (String, String) =
-    using(
+    Using.resources(
       Git.open(Directory.getRepositoryDir(userName, repositoryName)),
       Git.open(Directory.getRepositoryDir(requestUserName, requestRepositoryName))
     ) { (oldGit, newGit) =>
@@ -1293,7 +1300,7 @@
    * @return sha1
    */
   def getShaByRef(owner: String, name: String, revstr: String): Option[String] = {
-    using(Git.open(getRepositoryDir(owner, name))) { git =>
+    Using.resource(Git.open(getRepositoryDir(owner, name))) { git =>
       Option(git.getRepository.resolve(revstr)).map(ObjectId.toString(_))
     }
   }
@@ -1308,14 +1315,14 @@
       if (lfsAttrs.nonEmpty) {
         val oid = lfsAttrs("oid").split(":")(1)
 
-        using(new FileInputStream(FileUtil.getLfsFilePath(repository.owner, repository.name, oid))) { in =>
+        Using.resource(new FileInputStream(FileUtil.getLfsFilePath(repository.owner, repository.name, oid))) { in =>
           f(in)
         }
       } else {
         throw new NoSuchElementException("LFS attribute is empty.")
       }
     } else {
-      using(loader.openStream()) { in =>
+      Using.resource(loader.openStream()) { in =>
         f(in)
       }
     }
@@ -1324,7 +1331,7 @@
   def openFile[T](git: Git, repository: RepositoryService.RepositoryInfo, tree: RevTree, path: String)(
     f: InputStream => T
   ): T = {
-    using(TreeWalk.forPath(git.getRepository, path, tree)) { treeWalk =>
+    Using.resource(TreeWalk.forPath(git.getRepository, path, tree)) { treeWalk =>
       openFile(git, repository, treeWalk)(f)
     }
   }
diff --git a/src/main/scala/gitbucket/core/util/SyntaxSugars.scala b/src/main/scala/gitbucket/core/util/SyntaxSugars.scala
index cc3ad41..6188cfa 100644
--- a/src/main/scala/gitbucket/core/util/SyntaxSugars.scala
+++ b/src/main/scala/gitbucket/core/util/SyntaxSugars.scala
@@ -11,6 +11,7 @@
 
   def defining[A, B](value: A)(f: A => B): B = f(value)
 
+  @deprecated("Use scala.util.Using.resource instead", "4.32.0")
   def using[A <: { def close(): Unit }, B](resource: A)(f: A => B): B =
     try f(resource)
     finally {
@@ -21,6 +22,7 @@
       }
     }
 
+  @deprecated("Use scala.util.Using.resources instead", "4.32.0")
   def using[A <: { def close(): Unit }, B <: { def close(): Unit }, C](resource1: A, resource2: B)(f: (A, B) => C): C =
     try f(resource1, resource2)
     finally {
@@ -36,10 +38,12 @@
       }
     }
 
+  @deprecated("Use scala.util.Using.resource instead", "4.32.0")
   def using[T](git: Git)(f: Git => T): T =
     try f(git)
     finally git.getRepository.close()
 
+  @deprecated("Use scala.util.Using.resources instead", "4.32.0")
   def using[T](git1: Git, git2: Git)(f: (Git, Git) => T): T =
     try f(git1, git2)
     finally {
diff --git a/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala b/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala
index ffac0c0..67f4bbc 100644
--- a/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala
+++ b/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala
@@ -1,7 +1,6 @@
 package gitbucket.core.service
 
 import gitbucket.core.util.Directory._
-import gitbucket.core.util.SyntaxSugars._
 import gitbucket.core.util.GitSpecUtil._
 
 import org.eclipse.jgit.api.Git
@@ -10,6 +9,7 @@
 import org.scalatest.FunSpec
 
 import java.io.File
+import scala.util.Using
 
 class MergeServiceSpec extends FunSpec {
   val service = new MergeService with AccountService with ActivityService with IssuesService with LabelsService
@@ -19,7 +19,7 @@
   val issueId = 10
   def initRepository(owner: String, name: String): File = {
     val dir = createTestRepository(getRepositoryDir(owner, name))
-    using(Git.open(dir)) { git =>
+    Using.resource(Git.open(dir)) { git =>
       createFile(git, "refs/heads/master", "test.txt", "hoge")
       git.branchCreate().setStartPoint(s"refs/heads/master").setName(s"refs/pull/${issueId}/head").call()
     }
@@ -39,7 +39,7 @@
     }
     it("checkConflict true if not conflicted, and create cache") {
       val repo2Dir = initRepository("user1", "repo2")
-      using(Git.open(repo2Dir)) { git =>
+      Using.resource(Git.open(repo2Dir)) { git =>
         createConfrict(git)
       }
       assert(service.checkConflictCache("user1", "repo2", branch, issueId) == None)
@@ -56,7 +56,7 @@
       val repo3Dir = initRepository("user1", "repo3")
       assert(service.checkConflict("user1", "repo3", branch, issueId).isEmpty)
       assert(service.checkConflictCache("user1", "repo3", branch, issueId) == Some(None))
-      using(Git.open(repo3Dir)) { git =>
+      Using.resource(Git.open(repo3Dir)) { git =>
         createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2")
       }
       assert(service.checkConflictCache("user1", "repo3", branch, issueId) == None)
@@ -65,7 +65,7 @@
       val repo4Dir = initRepository("user1", "repo4")
       assert(service.checkConflict("user1", "repo4", branch, issueId).isEmpty)
       assert(service.checkConflictCache("user1", "repo4", branch, issueId) == Some(None))
-      using(Git.open(repo4Dir)) { git =>
+      Using.resource(Git.open(repo4Dir)) { git =>
         createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4")
       }
       assert(service.checkConflictCache("user1", "repo4", branch, issueId) == None)
@@ -74,14 +74,14 @@
       val repo5Dir = initRepository("user1", "repo5")
       assert(service.checkConflict("user1", "repo5", branch, issueId).isEmpty)
       assert(service.checkConflictCache("user1", "repo5", branch, issueId) == Some(None))
-      using(Git.open(repo5Dir)) { git =>
+      Using.resource(Git.open(repo5Dir)) { git =>
         createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2")
       }
       assert(service.checkConflictCache("user1", "repo5", branch, issueId) == None)
     }
     it("conflicted cache invalid if request branch moved") {
       val repo6Dir = initRepository("user1", "repo6")
-      using(Git.open(repo6Dir)) { git =>
+      Using.resource(Git.open(repo6Dir)) { git =>
         createConfrict(git)
       }
       assert(service.checkConflict("user1", "repo6", branch, issueId).isDefined)
@@ -89,14 +89,14 @@
         case Some(Some(_: String)) => true
         case _                     => false
       })
-      using(Git.open(repo6Dir)) { git =>
+      Using.resource(Git.open(repo6Dir)) { git =>
         createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4")
       }
       assert(service.checkConflictCache("user1", "repo6", branch, issueId) == None)
     }
     it("conflicted cache invalid if origin branch moved") {
       val repo7Dir = initRepository("user1", "repo7")
-      using(Git.open(repo7Dir)) { git =>
+      Using.resource(Git.open(repo7Dir)) { git =>
         createConfrict(git)
       }
       assert(service.checkConflict("user1", "repo7", branch, issueId).isDefined)
@@ -104,7 +104,7 @@
         case Some(Some(_)) => true
         case _             => false
       })
-      using(Git.open(repo7Dir)) { git =>
+      Using.resource(Git.open(repo7Dir)) { git =>
         createFile(git, s"refs/heads/${branch}", "test.txt", "hoge4")
       }
       assert(service.checkConflictCache("user1", "repo7", branch, issueId) == None)
@@ -113,7 +113,7 @@
   describe("mergePullRequest") {
     it("can merge") {
       val repo8Dir = initRepository("user1", "repo8")
-      using(Git.open(repo8Dir)) { git =>
+      Using.resource(Git.open(repo8Dir)) { git =>
         createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge2")
         val committer = new PersonIdent("dummy2", "dummy2@example.com")
         assert(getFile(git, branch, "test.txt").content.get == "hoge")
@@ -121,7 +121,7 @@
         val masterId = git.getRepository.resolve(branch)
         service.mergePullRequest(git, branch, issueId, "merged", committer)
         val lastCommitId = git.getRepository.resolve(branch)
-        val commit = using(new RevWalk(git.getRepository))(_.parseCommit(lastCommitId))
+        val commit = Using.resource(new RevWalk(git.getRepository))(_.parseCommit(lastCommitId))
         assert(commit.getCommitterIdent() == committer)
         assert(commit.getAuthorIdent() == committer)
         assert(commit.getFullMessage() == "merged")
diff --git a/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala b/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala
index 6bf96ba..cc8cd01 100644
--- a/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala
+++ b/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala
@@ -2,7 +2,6 @@
 
 import gitbucket.core.GitBucketCoreModule
 import gitbucket.core.util.{DatabaseConfig, Directory, FileUtil, JGitUtil}
-import gitbucket.core.util.SyntaxSugars._
 import io.github.gitbucket.solidbase.Solidbase
 import liquibase.database.core.H2Database
 import liquibase.database.jvm.JdbcConnection
@@ -19,6 +18,7 @@
 import org.mockito.Mockito._
 
 import scala.util.Random
+import scala.util.Using
 
 trait ServiceSpecBase extends MockitoSugar {
 
@@ -58,7 +58,7 @@
     FileUtil.withTmpDir(new File(FileUtils.getTempDirectory(), Random.alphanumeric.take(10).mkString)) { dir =>
       val (url, user, pass) = (DatabaseConfig.url(Some(dir.toString)), DatabaseConfig.user, DatabaseConfig.password)
       org.h2.Driver.load()
-      using(DriverManager.getConnection(url, user, pass)) { conn =>
+      Using.resource(DriverManager.getConnection(url, user, pass)) { conn =>
         val solidbase = new Solidbase()
         val db = new H2Database()
         db.setConnection(new JdbcConnection(conn)) // TODO Remove setConnection in the future
diff --git a/src/test/scala/gitbucket/core/util/GitSpecUtil.scala b/src/test/scala/gitbucket/core/util/GitSpecUtil.scala
index 8462ed7..d43b7a5 100644
--- a/src/test/scala/gitbucket/core/util/GitSpecUtil.scala
+++ b/src/test/scala/gitbucket/core/util/GitSpecUtil.scala
@@ -1,7 +1,5 @@
 package gitbucket.core.util
 
-import gitbucket.core.util.SyntaxSugars._
-
 import org.apache.commons.io.FileUtils
 import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.dircache.DirCache
@@ -13,6 +11,7 @@
 
 import java.nio.file._
 import java.io.File
+import scala.util.Using
 
 object GitSpecUtil {
 
@@ -28,7 +27,8 @@
     }
   }
 
-  def withTestRepository[U](f: Git => U): U = withTestFolder(folder => using(Git.open(createTestRepository(folder)))(f))
+  def withTestRepository[U](f: Git => U): U =
+    withTestFolder(folder => Using.resource(Git.open(createTestRepository(folder)))(f))
 
   def createTestRepository(dir: File): File = {
     RepositoryCache.clear()
@@ -81,7 +81,7 @@
 
   def getFile(git: Git, branch: String, path: String) = {
     val revCommit = JGitUtil.getRevCommitFromId(git, git.getRepository.resolve(branch))
-    val objectId = using(new TreeWalk(git.getRepository)) { walk =>
+    val objectId = Using.resource(new TreeWalk(git.getRepository)) { walk =>
       walk.addTree(revCommit.getTree)
       walk.setRecursive(true)
       @scala.annotation.tailrec
@@ -108,7 +108,7 @@
     if (conflicted) {
       throw new RuntimeException("conflict!")
     }
-    val mergeTipCommit = using(new RevWalk(repository))(_.parseCommit(mergeTip))
+    val mergeTipCommit = Using.resource(new RevWalk(repository))(_.parseCommit(mergeTip))
     val committer = mergeTipCommit.getCommitterIdent
     // creates merge commit
     val mergeCommit = new CommitBuilder()