闭环Java应用

最新推荐文章于 2023-05-10 13:47:40 发布
最新推荐文章于 2023-05-10 13:47:40 发布
阅读量2k 收藏 1
点赞数
分类专栏： 读书总结

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

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

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

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

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

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

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

 

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

 

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


应该如何部署应用

项目

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



web应用


打包应用后，会按照相应的目录结构构建。如果项目使用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应用

项目结构


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


maven依赖(pom.xml)

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


打包配置(pom.xml)

nonweb-example\pom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <descriptor>src/assembly/assembly.xml</descriptor>
        <finalName>${project.build.finalName}</finalName>
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>directory</goal>
            </goals>
        </execution>
    </executions>
</plugin>


使用maven-assembly-plugin进行打包；打包配置如下：

<id>package</id>
<formats>
    <format>dir</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
<fileSets>
    <!-- 可执行文件 -->
    <fileSet>
        <directory>src/bin</directory>
        <outputDirectory>bin</outputDirectory>
        <includes>
            <include>*.bat</include>
        </includes>
        <lineEnding>dos</lineEnding>
    </fileSet>
    <fileSet>
        <directory>src/bin</directory>
        <outputDirectory>bin</outputDirectory>
        <includes>
            <include>*.sh</include>
        </includes>
        <lineEnding>unix</lineEnding>
        <fileMode>0755</fileMode>
    </fileSet>
    <!-- classes -->
    <fileSet>
        <directory>${project.build.directory}/classes</directory>
        <outputDirectory>classes</outputDirectory>
    </fileSet>
</fileSets>
<!-- 依赖jar包 -->
<dependencySets>
    <dependencySet>
        <outputDirectory>lib</outputDirectory>
        <excludes>
            <exclude>com.jd:nonweb-example</exclude>
        </excludes>
    </dependencySet>
</dependencySets>

主要有三组配置：

formats：打包格式，此处使用的是dir，还可以是zip、rar等；

fileSet：拷贝文件，本示例主要有bin文件、classes文件需要拷贝；

dependencySets：依赖jar，拷贝到lib目录；

 

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

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

 

启动类

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

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

 

启动脚本

#!/bin/sh
echo -------------------------------------------
echo start server
echo -------------------------------------------
# 设置项目代码路径
export CODE_HOME="/export/App/nonweb-example-startup-package"
#日志路径
export LOG_PATH="/export/Logs/nonweb.example.jd.local"
mkdir -p $LOG_PATH
# 设置依赖路径
export CLASSPATH="$CODE_HOME/classes:$CODE_HOME/lib/*"
# java可执行文件位置
export _EXECJAVA="$JAVA_HOME/bin/java"
# JVM启动参数
export JAVA_OPTS="-server -Xms128m -Xmx256m -Xss256k -XX:MaxDirectMemorySize=128m"
# 启动类
export MAIN_CLASS=com.jd.nonweb.example.startup.Bootstrap

$_EXECJAVA $JAVA_OPTS -classpath $CLASSPATH $MAIN_CLASS &
tail -f $LOG_PATH/stdout.log

配置项目代码路径、日志路径、依赖路径、java执行文件路径、JVM启动参数、启动类。

 

停止脚本

#日志路径
export LOG_PATH="/export/Logs/nonweb.example.jd.local"
mkdir -p $LOG_PATH
# 启动类
export MAIN_CLASS=com.jd.nonweb.example.startup.Bootstrap

echo -------------------------------------------
echo stop server

#所有相关进程
PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'`
#停止进程
if [ -n "$PIDs" ]; then
  for PID in $PIDs; do
      kill $PID
      echo "kill $PID"
  done
fi

#等待50秒
for i in 1 10; do
  PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'`
  if [ ! -n "$PIDs" ]; then
    echo "stop server success"
    echo -------------------------------------------
    break
  fi
  echo "sleep 5s"
  sleep 5
done

#如果等待50秒还没有停止完，直接杀掉
PIDs=`jps -l | grep $MAIN_CLASS | awk '{print $1}'`
if [ -n "$PIDs" ]; then
  for PID in $PIDs; do
      kill -9 $PID
      echo "kill -9 $PID"
  done
fi
tail -fn200 $LOG_PATH/stdout.log

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

 

 

从零构建web应用

项目结构

 


maven依赖(pom.xml)

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


打包配置(pom.xml)

web-example\pom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <descriptor>src/assembly/assembly.xml</descriptor>
        <finalName>${project.build.finalName}</finalName>
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>directory</goal>
            </goals>
        </execution>
    </executions>
</plugin>

使用maven-assembly-plugin进行打包；打包配置如下：

<id>package</id>
<formats>
    <format>dir</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
<fileSets>
    <fileSet>
        <directory>src/bin</directory>
        <outputDirectory>bin</outputDirectory>
        <includes>
            <include>*.sh</include>
        </includes>
        <lineEnding>unix</lineEnding>
        <fileMode>0755</fileMode>
    </fileSet>
    <!-- WEB-INF -->
    <fileSet>
        <directory>src/main/webapp</directory>
        <outputDirectory></outputDirectory>
    </fileSet>
    <!-- classes -->
    <fileSet>
        <directory>${project.build.directory}/classes</directory>
        <outputDirectory>WEB-INF/classes</outputDirectory>
    </fileSet>

</fileSets>
<!-- 依赖jar包 -->
<dependencySets>
    <dependencySet>
        <outputDirectory>WEB-INF/lib</outputDirectory>
        <excludes>
            <exclude>com.jd:web-example</exclude>
        </excludes>
    </dependencySet>
</dependencySets>

主要有三组配置：

formats：打包格式，此处使用的是dir，还可以是zip、rar等；

fileSet：拷贝文件，本示例主要有bin文件、classes文件、webapp文件需要拷贝；

dependencySets：依赖jar，拷贝到WEB-INF\lib目录；

 

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

 

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

 

启动类

public class TomcatBootstrap {
  private static final Logger LOG = LoggerFactory.getLogger(TomcatBootstrap.class);
  public static void main(String[] args) throws Exception{
    //提升性能(https://wiki.apache.org/tomcat/HowTo/FasterStartUp)
    System.setProperty("tomcat.util.scan.StandardJarScanFilter.jarsToSkip", "*.jar");
    //System.setProperty("securerandom.source","file:/dev/./urandom");
    int port =Integer.parseInt(System.getProperty("server.port", "8080"));
    String contextPath = System.getProperty("server.contextPath", "");
    String docBase = System.getProperty("server.docBase", getDefaultDocBase());
    LOG.info("server port : {}, context path : {},doc base : {}",port, contextPath, docBase);
    Tomcat tomcat = createTomcat(port,contextPath, docBase);
    tomcat.start();
    Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run(){
            try {
                tomcat.stop();
            } catch (LifecycleException e) {
                LOG.error("stoptomcat error.", e);
            }
        }
    });
    tomcat.getServer().await();
 }

 private static String getDefaultDocBase() {
   File classpathDir = new File(Thread.currentThread().getContextClassLoader().getResource(".").getFile());
   File projectDir =classpathDir.getParentFile().getParentFile();
   return new File(projectDir,"src/main/webapp").getPath();
 }

 private static Tomcat createTomcat(int port,String contextPath, String docBase) throws Exception{
    String tmpdir = System.getProperty("java.io.tmpdir");
    Tomcat tomcat = new Tomcat();
    tomcat.setBaseDir(tmpdir);
    tomcat.getHost().setAppBase(tmpdir);
    tomcat.getHost().setAutoDeploy(false);
    tomcat.getHost().setDeployOnStartup(false);
    tomcat.getEngine().setBackgroundProcessorDelay(-1);
    tomcat.setConnector(newNioConnector());
    tomcat.getConnector().setPort(port);
    tomcat.getService().addConnector(tomcat.getConnector());
    Context context =tomcat.addWebapp(contextPath, docBase);
    StandardServer server =(StandardServer) tomcat.getServer();
    //APR library loader. Documentation at /docs/apr.html
    server.addLifecycleListener(new AprLifecycleListener());
    //Prevent memory leaks due to use of particularjava/javax APIs
    server.addLifecycleListener(new JreMemoryLeakPreventionListener());
    return tomcat;
  }

  //在这里调整参数优化
  private static Connector newNioConnector() {
    Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
    Http11NioProtocol protocol =(Http11NioProtocol) connector.getProtocolHandler();
    return connector;
 }

}

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

 

启动脚本

#!/bin/sh
echo -------------------------------------------
echo start server
echo -------------------------------------------
# 设置项目代码路径
export CODE_HOME="/export/App/web-example-web-package"
#日志路径
export LOG_PATH="/export/Logs/web.example.jd.local"
mkdir -p $LOG_PATH
# 设置依赖路径
export CLASSPATH="$CODE_HOME/WEB-INF/classes:$CODE_HOME/WEB-INF/lib/*"
# java可执行文件位置
export _EXECJAVA="$JAVA_HOME/bin/java"
# JVM启动参数
export JAVA_OPTS="-server -Xms128m -Xmx256m -Xss256k-XX:MaxDirectMemorySize=128m"
# 服务端端口、上下文、项目根配置
export SERVER_INFO="-Dserver.port=8090 -Dserver.contextPath=-Dserver.docBase=$CODE_HOME"
# 启动类
export MAIN_CLASS=com.jd.web.example.startup.TomcatBootstrap

$_EXECJAVA $JAVA_OPTS -classpath $CLASSPATH $SERVER_INFO $MAIN_CLASS &
tail -f $LOG_PATH/stdout.log

 

配置项目代码路径、日志路径、依赖路径、java执行文件路径、JVM启动参数、启动类；相当于非web应用，多了web服务器端口、上下文、项目根路径配置。

 

停止脚本

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

 

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


Spring Boot构建非web/web应用

项目结构




maven依赖(pom.xml)

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

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.1.BUILD-SNAPSHOT</version>
</parent>

spring-boot-starter-parent中是一些通用配置，如JDK编码、依赖管理（它又继承了spring-boot-dependencies，这里边定义了所有依赖）；

 

依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-velocity</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</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插件：

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

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



启动类

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

@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应用。项目结构如下所示：


项目结构和之前的区别是多了assembly和bin。


打包配置(pom.xml)

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

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

 更改为assembly插件

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <descriptor>src/assembly/assembly.xml</descriptor>
        <finalName>${project.build.finalName}</finalName>
    </configuration>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>directory</goal>
            </goals>
        </execution>
    </executions>
</plugin>

assembly.xml和“从零构建非web应用”的类似，就不贴配置了。

 

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



启停脚本也是类似的，在此也不贴配置了。到此基于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应用的主要目的。

后海hh
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA:实现闭环检测DetectLoop链表算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-10 194
JAVA:实现闭环检测DetectLoop链表算法(附完整源码)
CAS Server 5.3搭建
abw986810159的博客
10-25 1万+
参考:https://blog.csdn.net/kunyang199034/article/details/80881118 一、下载CAS5.3  CAS5.3 Server我们下载cas-overlay-template版本  下载地址：https://github.com/apereo/cas-overlay-template  打开网址，点击左上角的Branch master可以选择要...
利用Assembly插件进行高效打包java应用
JL
11-09 694
maven的两种方式打包1.使用maven-jar-plugin插件进行打包 1.使用maven-jar-plugin插件进行打包 maven-jar-plugin插件的使用需要在pom.xml文件中添加此插件，我们可以对此插件进行配置。 配置参考如下： &amp;amp;lt;plugin&amp;amp;gt; &amp;amp;lt;artifactId&amp;amp;gt;maven-jar-plugin&amp;amp;lt
java 利用 maven launch4j-plugin 插件 jar 打包 exe
MrLee的博客
09-26 4592
看了一些博客和技术文章，实现jar 打包成 exe ，都是使用的 exe4j ，操作起来略复杂，有没有简单的方法呢？ 既然写到这答案是肯定的。 launch4j-plugin插件可以直接帮我们jar 打包成exe 使用方法直接在项目pom中引入launch4j-plugin，由于还要指定入口文件我们配合maven-shade-plugin插件。 还是以上一篇的项目为例。 pom引入插...
【JAR包打包为EXE】javafx/java项目（适用jdk1.8）通过Gradle插件打包为exe，包含jre，客户机无需安装JDK（含代码）
NameLoadingFailed的博客
03-03 2745
通常在采用javafx或tornadofx等框架编写的桌面软件后，若要分发给客户机进行使用，就需要先在目标客户机安装合适版本的JDK，对于客户机来说并不需要关注这一步骤，这也增加了多台客户机分发及使用的成本，客户端更关注的是软件功能的使用。安装JDK环境对于技术人员而言可能较简单，而对于非技术人员或不是很熟练的实施人员，那这一步就成为了对使用该软件的一个很大的阻碍。
Java服务-常用技术-maven-assembly-plugin打包springboot、打包目录结构及启动命令
码者人生的技术博客
04-02 3435
maven打包插件 <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <versio...
MagiCude:分布式端口（漏洞）扫描，资产安全管理，实时威胁监控与通知，高效漏洞闭环，漏洞维基，邮件报告通知，poc框架
03-20
具有分布式端口（漏洞）扫描，资产安全管理，实时威胁监控与通知，自动中断闭环，漏洞维基，邮件报告通知，poc框架等功能。 手动资产管理：应用系统-域名-ip-端口-负责人-标签等信息关联 自动资产管理：ip，端口...
Java毕业设计-基于springboot开发的青年公寓服务平台-毕业论文（附毕设源代码）.rar
最新发布
03-07
项目围绕青年公寓服务展开，涵盖了公寓信息管理、用户注册登录、房源展示、在线预订、支付结算等多个功能模块，形成了一个完整的服务闭环。通过Spring Boot框架的使用，项目在开发效率与代码质量上都得到了显著提升...
赤龙ERP旨在研发一款免费开源、业务闭环、灵活稳定的企业级ERP系统
08-11
赤龙ERP旨在研发一款免费开源、业务闭环、灵活稳定的企业级ERP系统。...（4）精确的财务业务一体化实现，（5）快速的应用部署服务、便捷的客户化指导、完备的售后服务体系，（6）可自由定制、与第三方系统快速打通。
基于jsp的网上办公系统毕业论文
09-04
企业网上办公自动化通过对各办公自动化要素的闭环整合，实现了工作流、信息流、知识流和办公自动化系统的整合管理，提供了一个科学、开放、先进的信息化办公平台，实现办公自动化，并进行远程办 公或在家办公。本...
一款免费开源、业务闭环、灵活稳定的企业级ERP系统
04-29
赤龙ERP旨在研发一款免费开源、业务闭环、灵活稳定的企业级ERP系统。实现真正的财务业务一体化；从计划预算、订单、出入库，到发票、收付款，再到凭证、分录、总账，实现对管理流、信息流、数据流的全方位管控。
java整合 pagehelper 分页插件 一套打包带走开箱即用
qq_37741426的博客
04-19 771
java整合 pagehelper 分页插件 一套打包带走开箱即用
【Maven】打包插件使用详解
z_xiao_qiang的博客
04-01 4522
常用Maven打包插件
Maven打包及其相关插件和高级特性
BASK2311的博客
05-10 1601
在Java项目开发中，Maven是非常重要的构建工具之一，它可以帮助我们管理项目的依赖、构建和发布。
maven打包添加依赖
人生无处不青山
10-21 186
<plugins> <plugin> <artifactId>maven-assembly-plugin</artifactId> <version>2.4</version> <configuration> <descripto...
java打包插件,Maven常用打包插件的使用
weixin_35461822的博客
03-22 757
大家好，我是IT修真院深圳分院第01期学员，一枚正直纯洁善良的web程序员。今天给大家分享一下，修真院官网JAVA(职业)任务2的知识点——Maven常用打包插件的使用。1.背景介绍打包，正式说法是构建项目软件包，具体说就是将项目中的各种文件，比如源代码、编译生成的字节码、配置文件、文档，按照规范的格式生成归档，最常见的是JAR包和WAR包。2.知识剖析2.1 关于package任何一个Maven...
三种打jar包插件
Ciel_Y的博客
12-03 949
三种打jar包插件1. 第一种：放到服务模块，pom文件，可以满足基本打包要求2. 自定义jar包名插件：3. Java11，打jar包插件： 1. 第一种：放到服务模块，pom文件，可以满足基本打包要求 <!--打包插件--> <build> <plugins> <plugin> <groupId>org.springframework.boot</gr
java -jar 执行普通main方法（使用spring-boot打包插件）
杨小熊学习笔记
02-20 2096
java -jar fat-jar spring-boot-maven-plugin
maven-assembly-plugin插件
热门推荐
心情舒畅
08-27 1万+
0、背景 　　最近我们项目越来越多了，然后发现项目中都使用assembly插件进行打包的，于是就进行了深入的了解，本文分享该插件的配置以及微服务的统一打包方式。 一、介绍 maven提供的打包插件有如下三种： plugin function maven-jar-plugin maven 默认打包插件【springboot默认使用该方式打包】，用来创建 project jar maven-shade-plugin 用来打可执行包，executable(fat) jar
Java中的闭环 是什么
07-22
在Java中，闭环（Closure）是指可以访问其外部作用域中的变量的函数，即函数可以捕获并访问其外部作用域中的变量。换句话说，闭环是一个函数以及在该函数中定义的引用了自由变量的环境。闭包可以在函数内部访问外部作用域中的变量，即使在外部作用域已经销毁或离开了该作用域。在Java中，使用Lambda表达式和匿名类可以实现闭包的功能。通过闭包，可以实现一些特定的编程需求，比如在函数中访问外部变量，实现回调函数等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值