是时候闭环Java应用了

[[177168]]

你曾经因为部署/上线而痛苦吗?你曾经因为要去运维那改配置而烦恼吗?在我接触过的一些部署/上线方式中,曾碰到过以下一些问题:

1、程序代码和依赖都是人工上传到服务器,不是通过工具进行部署和发布;

2、目录结构没有规范,jar启动时通过-classpath任意指定;

3、fat jar,把程序代码、配置文件和依赖jar都打包到一个jar中,改配置文件太费劲;

4、不管是非web应用还是web应用都部署到web容器环境,如Tomcat;

5、web应用还需要先在服务器上安装好环境(如装Tomcat)才能部署,想升级版本或者换个容器太难了;

6、线上参数修改还需要找运维,痛苦。

还有如没有自动部署平台,回滚到上一个版本那可真是天方夜谈;增量包而非全量包,无法自由在在的回滚;前端代码直接覆盖而非版本化,难快速回滚,出问题要清理CDN,痛苦;ngx_lua项目时不按照项目的方式部署,在服务器上随意修改代码,导致某些服务器忘记修改或者版本不一致,排查问题太痛苦。

还有很多部署中不好的方式,但是本文只关注闭环Java应用带来的好处。首先介绍下应该如何部署应用,然后介绍下什么是闭环Java应用,它的好处和如何搭建。

应该如何部署应用

是时候闭环Java应用了插图

项目

项目中应该包括了所有要执行的代码、启停脚本,比如非web应用

是时候闭环Java应用了插图1

web应用

是时候闭环Java应用了插图2

打包应用后,会按照相应的目录结构构建。如果项目使用maven,可以使用maven-assembly-plugin进行按照相应的目录结构构件。

即项目、打包的应用要按照统一的风格来实施。

自动部署系统

自动部署系统负责打包应用(比如执行mvn相应的命令即可)、抽包(从指定目录抽取要部署的代码,如target/nonweb-example-package目录)、部署代码(发布代码,将代码同步到宿主机器)、启停应用(配置指定的启停脚本并调用)。

自动部署除了这些功能外,应该还有如发布历史管理(回滚)、分组管理(如不同机房不同的配置文件)、配置管理(如要修改启动/停止脚本、修改配置文件[不同机房不同的配置]、参数管理[如jvm参数等])等。

宿主机器

即代码部署到的机器,它应该只安装最小化环境,如只需要装JDK即可,像Tomcat是不需要安装的,由应用决定使用哪个容器。

通过增加自动部署系统可以更好的进行项目的统一发布、管理和回滚。

闭环Java应用

闭环Java应用指Java代码、容器、配置文件、启停脚本等都在同一处维护,修改配置文件、修改环境参数、更改容器类型等都不需要到宿主机器上进行更改。宿主机器只提供基本运行环境,如仅部署JDK环境即可,不需要部署如Tomcat容器,需要什么容器,都是在Java应用中指定。

这样的好处是配置文件修改、JVM参数修改、容器的选择都可以在Java应用中配置,形成闭环。

闭环Java应用的目的主要是让Java应用能自启动,这样程序的控制权就在我们手里,而不是运维手里。而我们更懂我们的程序。

随着微服务概念的流行,spring boot也受到大家的热捧。spring boot能帮助我们快速构建基于spring的应用;其能方便创建自启动应用、可以嵌入各种容器(如Tomcat、Jetty)、提供了一些starter pom用于简化配置文件、自动化配置(只需要引入相关的pom,就自动获得了某些功能)等。

在介绍spring boot之前,我们看下在以前是怎么构建闭环Java应用。

从零构建非web应用

项目结构

是时候闭环Java应用了插图3

本示例演示了构建一个非web应用RPC服务生产者(如Dubbo服务),还可以构建如Worker类型的应用,他们本身不需要web容器,作为普通的java应用启动即可。

maven依赖(pom.xml)

需要自己添加如spring-core、spring-context等相关依赖,此处就不展示了。

打包配置(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.     <!-- 可执行文件 --> 
  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目录;

执行mvn package后形成了将得到如下结构:

是时候闭环Java应用了插图4

将该目录通过自动部署抽包并部署到宿主机器即可。然后自动部署系统执行bin下的启停脚本执行即可。

启动类

 
 
  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.   } 

本示例没有使用Java Config方式构建,直接加载spring配置文件启动Java应用。

启动脚本

 
 
  1. #!/bin/sh 
  2. echo ------------------------------------------- 
  3. echo start server 
  4. echo ------------------------------------------- 
  5. # 设置项目代码路径 
  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. # 设置依赖路径 
  11. export CLASSPATH="$CODE_HOME/classes:$CODE_HOME/lib/*" 
  12. # java可执行文件位置 
  13. export _EXECJAVA="$JAVA_HOME/bin/java" 
  14. # JVM启动参数 
  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执行文件路径、JVM启动参数、启动类。

停止脚本

 
 
  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. #所有相关进程 
  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 

到此一个闭环非web应用就构建完了,启停脚本、启动类、项目代码都是统一在一处维护,并使用maven-assembly-plugin将这些打包在一起,通过自动部署发布并执行,达到了闭环的目的。

从零构建web应用

项目结构

是时候闭环Java应用了插图5

maven依赖(pom.xml)

需要自己添加如spring-core、spring-context、spring-web、spring-webmvc、velocity等相关依赖,此处就不展示了。

打包配置(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目录;

执行mvn package后形成了将得到如下结构:

是时候闭环Java应用了插图6

打包的目录结构和普通web结构完全一样;将该目录通过自动部署抽包并发布到宿主机器即可。然后自动部署系统执行bin下的启停脚本执行即可。

启动类

 
 
  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.   //在这里调整参数优化 
  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.  

通过嵌入Tomcat容器启动,这种方式的确定是需要先写Tomcat的启动代码,优点也很明显:以后Tomcat的控制权在我们手中,可以随时进行切换或者优化,不需要改线上的配置文件。

启动脚本

 
 
  1. #!/bin/sh 
  2. echo ------------------------------------------- 
  3. echo start server 
  4. echo ------------------------------------------- 
  5. # 设置项目代码路径 
  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. # 设置依赖路径 
  11. export CLASSPATH="$CODE_HOME/WEB-INF/classes:$CODE_HOME/WEB-INF/lib/*" 
  12. # java可执行文件位置 
  13. export _EXECJAVA="$JAVA_HOME/bin/java" 
  14. # JVM启动参数 
  15. export JAVA_OPTS="-server -Xms128m -Xmx256m -Xss256k-XX:MaxDirectMemorySize=128m" 
  16. # 服务端端口、上下文、项目根配置 
  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执行文件路径、JVM启动参数、启动类;相当于非web应用,多了web服务器端口、上下文、项目根路径配置。

停止脚本

和非web的类似就不再重复了。

到此一个闭环web应用就构建完了,启停脚本、启动类、项目代码都是统一在一处维护,并使用maven-assembly-plugin将这些打包在一起,通过自动部署发布并执行。达到了闭环的目的。

Spring Boot构建非web/web应用

项目结构

是时候闭环Java应用了插图7

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环境(spring-core、spring-context等);spring-boot-starter-web是spring mvc环境,并使用Tomcat作为web容器;spring-boot-starter-velocity将自动将模板引擎配置为velocity。此处可以看到starter的好处了,需要什么功能只需要引入一个starter,相关的依赖自动添加,而且会自动配置使用该特性。

打包配置(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> 

执行mvn package时将得到如下fat jar:

是时候闭环Java应用了插图8

启动类

 
 
  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.   } 

@SpringBootApplication指定了要扫描的包、可以使用@ImportResource引入xml配置文件。然后可以直接作为普通java应用启动即可,此时自动使用tomcat作为web容器启动。

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

个人不太喜欢fat jar的方式。可以使用maven-assembly-plugin配合来打包Java应用。项目结构如下所示:

是时候闭环Java应用了插图9

项目结构和之前的区别是多了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和“从零构建非web应用”的类似,就不贴配置了。

执行mvn package时将得到如下打包:

是时候闭环Java应用了插图10

启停脚本也是类似的,在此也不贴配置了。到此基于spring boot的非fat jar方式的自启动Java应用就构建好了。

总结

从零构建非web应用/web应用需要我们查找相关依赖并配置,还需要进行一些配置(Spring配置、容器配置),如果构建一个新的项目还是相对较慢的,但是在公司内大家应该都有自己的“starter pom”,因此实际构建也不会很慢。而如果没有一些项目的积累,使用spring boot可以非常容易而且快速的就能搭建出想要的项目。使用spring boot后:容易添加依赖、启动类不用自己创建、享受到自动配置的好处等;而自带的spring-boot-maven-plugin会生成fat jar,不过可以配合maven-assembly-plugin来实现之前的方式的。

另外因笔者所在公司使用Docker容器,一个宿主机器只部署一个JVM示例,示例中的启停脚本不用考虑单机多JVM实例问题。

创建闭环Java应用,可以更容易的进行如JVM参数调优、修改容器配置文件、非web应用不需要部署到Tomcat容器中;这是笔者想进行闭环Java应用的主要目的。

【本文是专栏作者张开涛的原创文章,作者微信公众号:开涛的博客( kaitao-1234567)】

THE END