偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

是時候閉環(huán)Java應(yīng)用了

作者：張開濤
開發(fā) 開發(fā)工具
今天的文章只關(guān)注閉環(huán)Java應(yīng)用帶來的好處。首先介紹下應(yīng)該如何部署應(yīng)用，然后介紹下什么是閉環(huán)Java應(yīng)用，它的好處和如何搭建。

[[177168]]

你曾經(jīng)因為部署/上線而痛苦嗎?你曾經(jīng)因為要去運維那改配置而煩惱嗎?在我接觸過的一些部署/上線方式中，曾碰到過以下一些問題：

1、程序代碼和依賴都是人工上傳到服務(wù)器，不是通過工具進行部署和發(fā)布;

2、目錄結(jié)構(gòu)沒有規(guī)范，jar啟動時通過-classpath任意指定;

3、fat jar，把程序代碼、配置文件和依賴jar都打包到一個jar中，改配置文件太費勁;

4、不管是非web應(yīng)用還是web應(yīng)用都部署到web容器環(huán)境，如Tomcat;

5、web應(yīng)用還需要先在服務(wù)器上安裝好環(huán)境(如裝Tomcat)才能部署，想升級版本或者換個容器太難了;

6、線上參數(shù)修改還需要找運維，痛苦。

還有如沒有自動部署平臺，回滾到上一個版本那可真是天方夜談;增量包而非全量包，無法自由在在的回滾;前端代碼直接覆蓋而非版本化，難快速回滾，出問題要清理CDN，痛苦;ngx_lua項目時不按照項目的方式部署，在服務(wù)器上隨意修改代碼，導致某些服務(wù)器忘記修改或者版本不一致，排查問題太痛苦。

還有很多部署中不好的方式，但是本文只關(guān)注閉環(huán)Java應(yīng)用帶來的好處。首先介紹下應(yīng)該如何部署應(yīng)用，然后介紹下什么是閉環(huán)Java應(yīng)用，它的好處和如何搭建。

應(yīng)該如何部署應(yīng)用

應(yīng)該如何部署應(yīng)用

項目

項目中應(yīng)該包括了所有要執(zhí)行的代碼、啟停腳本，比如非web應(yīng)用

部署應(yīng)用項目

web應(yīng)用

部署應(yīng)用項目web應(yīng)用

打包應(yīng)用后，會按照相應(yīng)的目錄結(jié)構(gòu)構(gòu)建。如果項目使用maven，可以使用maven-assembly-plugin進行按照相應(yīng)的目錄結(jié)構(gòu)構(gòu)件。

即項目、打包的應(yīng)用要按照統(tǒng)一的風格來實施。

自動部署系統(tǒng)

自動部署系統(tǒng)負責打包應(yīng)用(比如執(zhí)行mvn相應(yīng)的命令即可)、抽包(從指定目錄抽取要部署的代碼，如target/nonweb-example-package目錄)、部署代碼(發(fā)布代碼，將代碼同步到宿主機器)、啟停應(yīng)用(配置指定的啟停腳本并調(diào)用)。

自動部署除了這些功能外，應(yīng)該還有如發(fā)布歷史管理(回滾)、分組管理(如不同機房不同的配置文件)、配置管理(如要修改啟動/停止腳本、修改配置文件[不同機房不同的配置]、參數(shù)管理[如jvm參數(shù)等])等。

宿主機器

即代碼部署到的機器，它應(yīng)該只安裝最小化環(huán)境，如只需要裝JDK即可，像Tomcat是不需要安裝的，由應(yīng)用決定使用哪個容器。

通過增加自動部署系統(tǒng)可以更好的進行項目的統(tǒng)一發(fā)布、管理和回滾。

閉環(huán)Java應(yīng)用

閉環(huán)Java應(yīng)用指Java代碼、容器、配置文件、啟停腳本等都在同一處維護，修改配置文件、修改環(huán)境參數(shù)、更改容器類型等都不需要到宿主機器上進行更改。宿主機器只提供基本運行環(huán)境，如僅部署JDK環(huán)境即可，不需要部署如Tomcat容器，需要什么容器，都是在Java應(yīng)用中指定。

這樣的好處是配置文件修改、JVM參數(shù)修改、容器的選擇都可以在Java應(yīng)用中配置，形成閉環(huán)。

閉環(huán)Java應(yīng)用的目的主要是讓Java應(yīng)用能自啟動，這樣程序的控制權(quán)就在我們手里，而不是運維手里。而我們更懂我們的程序。

隨著微服務(wù)概念的流行，spring boot也受到大家的熱捧。spring boot能幫助我們快速構(gòu)建基于spring的應(yīng)用;其能方便創(chuàng)建自啟動應(yīng)用、可以嵌入各種容器(如Tomcat、Jetty)、提供了一些starter pom用于簡化配置文件、自動化配置(只需要引入相關(guān)的pom，就自動獲得了某些功能)等。

在介紹spring boot之前，我們看下在以前是怎么構(gòu)建閉環(huán)Java應(yīng)用。

從零構(gòu)建非web應(yīng)用

項目結(jié)構(gòu)

從零構(gòu)建非web應(yīng)用 項目結(jié)構(gòu)

本示例演示了構(gòu)建一個非web應(yīng)用RPC服務(wù)生產(chǎn)者(如Dubbo服務(wù))，還可以構(gòu)建如Worker類型的應(yīng)用，他們本身不需要web容器，作為普通的java應(yīng)用啟動即可。

maven依賴(pom.xml)

需要自己添加如spring-core、spring-context等相關(guān)依賴，此處就不展示了。

打包配置(pom.xml)

nonweb-example\pom.xml

  1. <plugin> 
  2.     <groupId>org.apache.maven.plugins</groupId> 
  3.     <artifactId>maven-assembly-plugin</artifactId> 
  4.     <version>2.6</version> 
  5.     <configuration> 
  6.         <descriptor>src/assembly/assembly.xml</descriptor> 
  7.         <finalName>${project.build.finalName}</finalName> 
  8.     </configuration> 
  9.     <executions> 
  10.         <execution> 
  11.             <phase>package</phase> 
  12.             <goals> 
  13.                 <goal>directory</goal> 
  14.             </goals> 
  15.         </execution> 
  16.     </executions> 
  17. </plugin> 

使用maven-assembly-plugin進行打包;打包配置如下：

  1. <id>package</id> 
  2. <formats> 
  3.     <format>dir</format> 
  4. </formats> 
  5. <includeBaseDirectory>false</includeBaseDirectory> 
  6. <fileSets> 
  7.     <!-- 可執(zhí)行文件 --> 
  8.     <fileSet> 
  9.         <directory>src/bin</directory> 
  10.         <outputDirectory>bin</outputDirectory> 
  11.         <includes> 
  12.             <include>*.bat</include> 
  13.         </includes> 
  14.         <lineEnding>dos</lineEnding> 
  15.     </fileSet> 
  16.     <fileSet> 
  17.         <directory>src/bin</directory> 
  18.         <outputDirectory>bin</outputDirectory> 
  19.         <includes> 
  20.             <include>*.sh</include> 
  21.         </includes> 
  22.         <lineEnding>unix</lineEnding> 
  23.         <fileMode>0755</fileMode> 
  24.     </fileSet> 
  25.     <!-- classes --> 
  26.     <fileSet> 
  27.         <directory>${project.build.directory}/classes</directory> 
  28.         <outputDirectory>classes</outputDirectory> 
  29.     </fileSet> 
  30. </fileSets> 
  31. <!-- 依賴jar包 --> 
  32. <dependencySets> 
  33.     <dependencySet> 
  34.         <outputDirectory>lib</outputDirectory> 
  35.         <excludes> 
  36.             <exclude>com.jd:nonweb-example</exclude> 
  37.         </excludes> 
  38.     </dependencySet> 
  39. </dependencySets> 

主要有三組配置：

  • formats：打包格式，此處使用的是dir，還可以是zip、rar等;
  • fileSet：拷貝文件，本示例主要有bin文件、classes文件需要拷貝;
  • dependencySets：依賴jar，拷貝到lib目錄;

執(zhí)行mvn package后形成了將得到如下結(jié)構(gòu)：

執(zhí)行mvn package后形成的結(jié)構(gòu)

將該目錄通過自動部署抽包并部署到宿主機器即可。然后自動部署系統(tǒng)執(zhí)行bin下的啟停腳本執(zhí)行即可。

啟動類

  1. public class Bootstrap { 
  2.   public static void main(String[] args) throws Exception { 
  3.       ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring-config.xml"); 
  4.       ctx.registerShutdownHook(); 
  5.       Thread.currentThread().join(); 
  6.   } 
  7. } 

本示例沒有使用Java Config方式構(gòu)建，直接加載spring配置文件啟動Java應(yīng)用。

啟動腳本

  1. #!/bin/sh 
  2. echo ------------------------------------------- 
  3. echo start server 
  4. echo ------------------------------------------- 
  5. # 設(shè)置項目代碼路徑 
  6. export CODE_HOME="/export/App/nonweb-example-startup-package" 
  7. #日志路徑 
  8. export LOG_PATH="/export/Logs/nonweb.example.jd.local" 
  9. mkdir -p $LOG_PATH 
  10. # 設(shè)置依賴路徑 
  11. export CLASSPATH="$CODE_HOME/classes:$CODE_HOME/lib/*" 
  12. # java可執(zhí)行文件位置 
  13. export _EXECJAVA="$JAVA_HOME/bin/java" 
  14. # JVM啟動參數(shù) 
  15. export JAVA_OPTS="-server -Xms128m -Xmx256m -Xss256k -XX:MaxDirectMemorySize=128m" 
  16. # 啟動類 
  17. export MAIN_CLASS=com.jd.nonweb.example.startup.Bootstrap 
  18.  
  19. $_EXECJAVA $JAVA_OPTS -classpath $CLASSPATH $MAIN_CLASS & 
  20. tail -f $LOG_PATH/stdout.log 

配置項目代碼路徑、日志路徑、依賴路徑、java執(zhí)行文件路徑、JVM啟動參數(shù)、啟動類。

停止腳本

  1. #日志路徑 
  2. export LOG_PATH="/export/Logs/nonweb.example.jd.local" 
  3. mkdir -p $LOG_PATH 
  4. # 啟動類 
  5. export MAIN_CLASS=com.jd.nonweb.example.startup.Bootstrap 
  6.  
  7. echo ------------------------------------------- 
  8. echo stop server 
  9.  
  10. #所有相關(guān)進程 
  11. PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'` 
  12. #停止進程 
  13. if [ -n "$PIDs" ]; then 
  14.   for PID in $PIDs; do 
  15.       kill $PID 
  16.       echo "kill $PID" 
  17.   done 
  18. fi 
  19.  
  20. #等待50秒 
  21. for i in 1 10; do 
  22.   PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'` 
  23.   if [ ! -n "$PIDs" ]; then 
  24.     echo "stop server success" 
  25.     echo ------------------------------------------- 
  26.     break 
  27.   fi 
  28.   echo "sleep 5s" 
  29.   sleep 5 
  30. done 
  31.  
  32. #如果等待50秒還沒有停止完，直接殺掉 
  33. PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'` 
  34. if [ -n "$PIDs" ]; then 
  35.   for PID in $PIDs; do 
  36.       kill -9 $PID 
  37.       echo "kill -9 $PID" 
  38.   done 
  39. fi 
  40. tail -fn200 $LOG_PATH/stdout.log 

到此一個閉環(huán)非web應(yīng)用就構(gòu)建完了，啟停腳本、啟動類、項目代碼都是統(tǒng)一在一處維護，并使用maven-assembly-plugin將這些打包在一起，通過自動部署發(fā)布并執(zhí)行，達到了閉環(huán)的目的。

從零構(gòu)建web應(yīng)用

項目結(jié)構(gòu)

從零構(gòu)建web應(yīng)用 項目結(jié)構(gòu)

maven依賴(pom.xml)

需要自己添加如spring-core、spring-context、spring-web、spring-webmvc、velocity等相關(guān)依賴，此處就不展示了。

打包配置(pom.xml)

web-example\pom.xml

  1. <plugin> 
  2.     <groupId>org.apache.maven.plugins</groupId> 
  3.     <artifactId>maven-assembly-plugin</artifactId> 
  4.     <version>2.6</version> 
  5.     <configuration> 
  6.         <descriptor>src/assembly/assembly.xml</descriptor> 
  7.         <finalName>${project.build.finalName}</finalName> 
  8.     </configuration> 
  9.     <executions> 
  10.         <execution> 
  11.             <phase>package</phase> 
  12.             <goals> 
  13.                 <goal>directory</goal> 
  14.             </goals> 
  15.         </execution> 
  16.     </executions> 
  17. </plugin> 

使用maven-assembly-plugin進行打包;打包配置如下：

  1. <id>package</id> 
  2. <formats> 
  3.     <format>dir</format> 
  4. </formats> 
  5. <includeBaseDirectory>false</includeBaseDirectory> 
  6. <fileSets> 
  7.     <fileSet> 
  8.         <directory>src/bin</directory> 
  9.         <outputDirectory>bin</outputDirectory> 
  10.         <includes> 
  11.             <include>*.sh</include> 
  12.         </includes> 
  13.         <lineEnding>unix</lineEnding> 
  14.         <fileMode>0755</fileMode> 
  15.     </fileSet> 
  16.     <!-- WEB-INF --> 
  17.     <fileSet> 
  18.         <directory>src/main/webapp</directory> 
  19.         <outputDirectory></outputDirectory> 
  20.     </fileSet> 
  21.     <!-- classes --> 
  22.     <fileSet> 
  23.         <directory>${project.build.directory}/classes</directory> 
  24.         <outputDirectory>WEB-INF/classes</outputDirectory> 
  25.     </fileSet> 
  26.  
  27. </fileSets> 
  28. <!-- 依賴jar包 --> 
  29. <dependencySets> 
  30.     <dependencySet> 
  31.         <outputDirectory>WEB-INF/lib</outputDirectory> 
  32.         <excludes> 
  33.             <exclude>com.jd:web-example</exclude> 
  34.         </excludes> 
  35.     </dependencySet> 
  36. </dependencySets> 

 

 

 

主要有三組配置：

  • formats：打包格式，此處使用的是dir，還可以是zip、rar等;
  • fileSet：拷貝文件，本示例主要有bin文件、classes文件、webapp文件需要拷貝;
  • dependencySets：依賴jar，拷貝到WEB-INF\lib目錄;

執(zhí)行mvn package后形成了將得到如下結(jié)構(gòu)：

執(zhí)行mvn package后形成的結(jié)構(gòu)

打包的目錄結(jié)構(gòu)和普通web結(jié)構(gòu)完全一樣;將該目錄通過自動部署抽包并發(fā)布到宿主機器即可。然后自動部署系統(tǒng)執(zhí)行bin下的啟停腳本執(zhí)行即可。

啟動類

  1. public class TomcatBootstrap { 
  2.   private static final Logger LOG = LoggerFactory.getLogger(TomcatBootstrap.class); 
  3.   public static void main(String[] args) throws Exception{ 
  4.     //提升性能(https://wiki.apache.org/tomcat/HowTo/FasterStartUp) 
  5.     System.setProperty("tomcat.util.scan.StandardJarScanFilter.jarsToSkip", "*.jar"); 
  6.     //System.setProperty("securerandom.source","file:/dev/./urandom"); 
  7.     int port =Integer.parseInt(System.getProperty("server.port", "8080")); 
  8.     String contextPath = System.getProperty("server.contextPath", ""); 
  9.     String docBase = System.getProperty("server.docBase", getDefaultDocBase()); 
  10.     LOG.info("server port : {}, context path : {},doc base : {}",port, contextPath, docBase); 
  11.     Tomcat tomcat = createTomcat(port,contextPath, docBase); 
  12.     tomcat.start(); 
  13.      Runtime.getRuntime().addShutdownHook(new Thread() { 
  14.         @Override 
  15.         public void run(){ 
  16.             try { 
  17.                 tomcat.stop(); 
  18.             } catch (LifecycleException e) { 
  19.                 LOG.error("stoptomcat error.", e); 
  20.             } 
  21.         } 
  22.     }); 
  23.     tomcat.getServer().await(); 
  24.   } 
  25.  
  26.   private static String getDefaultDocBase() { 
  27.    File classpathDir = new File(Thread.currentThread().getContextClassLoader().getResource(".").getFile()); 
  28.    File projectDir =classpathDir.getParentFile().getParentFile(); 
  29.    return new File(projectDir,"src/main/webapp").getPath(); 
  30.   } 
  31.  private static Tomcat createTomcat(int port,String contextPath, String docBase) throws Exception{ 
  32.     String tmpdir = System.getProperty("java.io.tmpdir"); 
  33.     Tomcat tomcat = new Tomcat(); 
  34.     tomcat.setBaseDir(tmpdir); 
  35.     tomcat.getHost().setAppBase(tmpdir); 
  36.     tomcat.getHost().setAutoDeploy(false); 
  37.     tomcat.getHost().setDeployOnStartup(false); 
  38.     tomcat.getEngine().setBackgroundProcessorDelay(-1); 
  39.     tomcat.setConnector(newNioConnector()); 
  40.     tomcat.getConnector().setPort(port); 
  41.     tomcat.getService().addConnector(tomcat.getConnector());  
  42.     Context context =tomcat.addWebapp(contextPath, docBase); 
  43.     StandardServer server =(StandardServer) tomcat.getServer(); 
  44.     //APR library loader. Documentation at /docs/apr.html 
  45.     server.addLifecycleListener(new AprLifecycleListener()); 
  46.     //Prevent memory leaks due to use of particularjava/javax APIs 
  47.     server.addLifecycleListener(new JreMemoryLeakPreventionListener()); 
  48.     return tomcat; 
  49.   } 
  50.  
  51.   //在這里調(diào)整參數(shù)優(yōu)化 
  52.   private static Connector newNioConnector() { 
  53.     Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol"); 
  54.     Http11NioProtocol protocol =(Http11NioProtocol) connector.getProtocolHandler(); 
  55.     return connector; 
  56.   } 
  57.  
  58. } 

通過嵌入Tomcat容器啟動，這種方式的確定是需要先寫Tomcat的啟動代碼，優(yōu)點也很明顯：以后Tomcat的控制權(quán)在我們手中，可以隨時進行切換或者優(yōu)化，不需要改線上的配置文件。

啟動腳本

  1. #!/bin/sh 
  2. echo ------------------------------------------- 
  3. echo start server 
  4. echo ------------------------------------------- 
  5. # 設(shè)置項目代碼路徑 
  6. export CODE_HOME="/export/App/web-example-web-package" 
  7. #日志路徑 
  8. export LOG_PATH="/export/Logs/web.example.jd.local" 
  9. mkdir -p $LOG_PATH 
  10. # 設(shè)置依賴路徑 
  11. export CLASSPATH="$CODE_HOME/WEB-INF/classes:$CODE_HOME/WEB-INF/lib/*" 
  12. # java可執(zhí)行文件位置 
  13. export _EXECJAVA="$JAVA_HOME/bin/java" 
  14. # JVM啟動參數(shù) 
  15. export JAVA_OPTS="-server -Xms128m -Xmx256m -Xss256k-XX:MaxDirectMemorySize=128m" 
  16. # 服務(wù)端端口、上下文、項目根配置 
  17. export SERVER_INFO="-Dserver.port=8090 -Dserver.contextPath=-Dserver.docBase=$CODE_HOME" 
  18. # 啟動類 
  19. export MAIN_CLASS=com.jd.web.example.startup.TomcatBootstrap 
  20.  
  21. $_EXECJAVA $JAVA_OPTS -classpath $CLASSPATH $SERVER_INFO $MAIN_CLASS & 
  22. tail -f $LOG_PATH/stdout.log 

配置項目代碼路徑、日志路徑、依賴路徑、java執(zhí)行文件路徑、JVM啟動參數(shù)、啟動類;相當于非web應(yīng)用，多了web服務(wù)器端口、上下文、項目根路徑配置。

停止腳本

和非web的類似就不再重復(fù)了。

到此一個閉環(huán)web應(yīng)用就構(gòu)建完了，啟停腳本、啟動類、項目代碼都是統(tǒng)一在一處維護，并使用maven-assembly-plugin將這些打包在一起，通過自動部署發(fā)布并執(zhí)行。達到了閉環(huán)的目的。

Spring Boot構(gòu)建非web/web應(yīng)用

項目結(jié)構(gòu)

Spring Boot構(gòu)建非web/web應(yīng)用 項目結(jié)構(gòu)

maven依賴(pom.xml)

spring-boot-example/pom.xml繼承spring-boot-starter-parent

  1. <parent> 
  2.     <groupId>org.springframework.boot</groupId> 
  3.     <artifactId>spring-boot-starter-parent</artifactId> 
  4.     <version>1.4.1.BUILD-SNAPSHOT</version> 
  5. </parent> 

spring-boot-starter-parent中是一些通用配置，如JDK編碼、依賴管理(它又繼承了spring-boot-dependencies，這里邊定義了所有依賴);

依賴

  1. <dependency> 
  2.     <groupId>org.springframework.boot</groupId> 
  3.     <artifactId>spring-boot-starter</artifactId> 
  4. </dependency> 
  5. <dependency> 
  6.     <groupId>org.springframework.boot</groupId> 
  7.     <artifactId>spring-boot-starter-web</artifactId> 
  8. </dependency> 
  9. <dependency> 
  10.     <groupId>org.springframework.boot</groupId> 
  11.     <artifactId>spring-boot-starter-velocity</artifactId> 
  12. </dependency> 
  13. <dependency> 
  14.     <groupId>org.springframework.boot</groupId> 
  15.     <artifactId>spring-boot-starter-log4j2</artifactId> 
  16. </dependency> 

spring-boot-starter是最小化的spring boot環(huán)境(spring-core、spring-context等);spring-boot-starter-web是spring mvc環(huán)境，并使用Tomcat作為web容器;spring-boot-starter-velocity將自動將模板引擎配置為velocity。此處可以看到starter的好處了，需要什么功能只需要引入一個starter，相關(guān)的依賴自動添加，而且會自動配置使用該特性。

打包配置(pom.xml)

spring-boot-example-web\pom.xml添加如下maven插件：

  1. <plugin> 
  2.     <groupId>org.springframework.boot</groupId> 
  3.     <artifactId>spring-boot-maven-plugin</artifactId> 
  4. </plugin> 

執(zhí)行mvn package時將得到如下fat jar：

執(zhí)行mvn package時將得到如下fat jar

啟動類

  1. package com.jd.springboot.example.web.startup; 
  2. import org.springframework.boot.SpringApplication; 
  3. import org.springframework.boot.autoconfigure.SpringBootApplication; 
  4. import org.springframework.context.annotation.ImportResource; 
  5. @SpringBootApplication(scanBasePackages = "com.jd.springboot.example") 
  6. @ImportResource("classpath:spring-config.xml") 
  7. public class Bootstrap { 
  8.   public static void main(String[] args) { 
  9.       SpringApplication.run(Bootstrap.class, args); 
  10.   } 
  11. } 

@SpringBootApplication指定了要掃描的包、可以使用@ImportResource引入xml配置文件。然后可以直接作為普通java應(yīng)用啟動即可，此時自動使用tomcat作為web容器啟動。

運行 jar -jar spring-boot-example-1.0-SNAPSHOT.jar即可啟動(META-INF\MANIFEST.MF指定了Main-Class)。

個人不太喜歡fat jar的方式。可以使用maven-assembly-plugin配合來打包Java應(yīng)用。項目結(jié)構(gòu)如下所示：

使用maven-assembly-plugin配合來打包Java應(yīng)用

項目結(jié)構(gòu)和之前的區(qū)別是多了assembly和bin。

打包配置(pom.xml)

spring-boot-example-web\pom.xml將如下maven插件

  1. <plugin> 
  2.     <groupId>org.springframework.boot</groupId> 
  3.     <artifactId>spring-boot-maven-plugin</artifactId> 
  4. </plugin> 

更改為assembly插件

  1. <plugin> 
  2.     <groupId>org.apache.maven.plugins</groupId> 
  3.     <artifactId>maven-assembly-plugin</artifactId> 
  4.     <version>2.6</version> 
  5.     <configuration> 
  6.         <descriptor>src/assembly/assembly.xml</descriptor> 
  7.         <finalName>${project.build.finalName}</finalName> 
  8.     </configuration> 
  9.     <executions> 
  10.         <execution> 
  11.             <phase>package</phase> 
  12.             <goals> 
  13.                 <goal>directory</goal> 
  14.             </goals> 
  15.         </execution> 
  16.     </executions> 
  17. </plugin> 

assembly.xml和“從零構(gòu)建非web應(yīng)用”的類似，就不貼配置了。

執(zhí)行mvn package時將得到如下打包：

執(zhí)行mvn package時得到的打包

啟停腳本也是類似的，在此也不貼配置了。到此基于spring boot的非fat jar方式的自啟動Java應(yīng)用就構(gòu)建好了。

總結(jié)

從零構(gòu)建非web應(yīng)用/web應(yīng)用需要我們查找相關(guān)依賴并配置，還需要進行一些配置(Spring配置、容器配置)，如果構(gòu)建一個新的項目還是相對較慢的，但是在公司內(nèi)大家應(yīng)該都有自己的“starter pom”，因此實際構(gòu)建也不會很慢。而如果沒有一些項目的積累，使用spring boot可以非常容易而且快速的就能搭建出想要的項目。使用spring boot后：容易添加依賴、啟動類不用自己創(chuàng)建、享受到自動配置的好處等;而自帶的spring-boot-maven-plugin會生成fat jar，不過可以配合maven-assembly-plugin來實現(xiàn)之前的方式的。

另外因筆者所在公司使用Docker容器，一個宿主機器只部署一個JVM示例，示例中的啟停腳本不用考慮單機多JVM實例問題。

創(chuàng)建閉環(huán)Java應(yīng)用，可以更容易的進行如JVM參數(shù)調(diào)優(yōu)、修改容器配置文件、非web應(yīng)用不需要部署到Tomcat容器中;這是筆者想進行閉環(huán)Java應(yīng)用的主要目的。

【本文是51CTO專欄作者張開濤的原創(chuàng)文章，作者微信公眾號：開濤的博客( kaitao-1234567)】

責任編輯：趙寧寧 來源： 開濤的博客
部署閉環(huán)Java應(yīng)用
相關(guān)推薦

2022-10-08 06:49:32

LinuxWindows操作系統(tǒng)

2021-02-23 10:42:45

AI

2024-12-06 09:47:13

2023-05-08 08:03:10

2018-08-21 05:12:10

2017-02-17 07:46:29

2024-01-02 07:34:38

CentOSLinuxRedhat

2023-10-26 21:41:45

云計算企業(yè)云基礎(chǔ)

2023-10-19 15:25:40

2024-06-05 09:22:43

2022-02-08 11:31:23

Linux端口命令

2022-01-13 09:58:26

Linux端口命令

2017-01-15 18:32:39

Openresty架構(gòu)性能

2024-05-30 07:37:30

2019-04-08 18:15:38

加密Tutanota應(yīng)用

2021-07-25 21:36:24

Windows操作系統(tǒng)功能

2025-02-27 14:10:00

模型AI訓練

2020-12-18 06:09:07

Java淺拷貝深拷貝

2021-10-09 14:35:20

物聯(lián)網(wǎng)IOT人工智能

2022-07-06 23:28:53

元宇宙Web3.0
點贊
收藏

51CTO技術(shù)棧公眾號