程序员在工作中，经常会有绘制时序图、流程图的需求，尤其是在写文档的时候。平时我们会选择ProcessOn这类工具来绘制，但有时候用代码来画图可能会更高效一点，毕竟没有比程序员更熟悉代码的了。今天给大家推荐一款画图工具PlantUML，可以配合IDEA使用，画图更高效！ SpringBoot实战电商项目mall（50k+star）地址：github.com/macrozheng/… PlantUML简介 PlantUML是一款开源的UML图绘制工具，支持通过文本来生成图形，使用起来非常高效。可以支持时序图、类图、对象图、活动图、思维导图等图形的绘制。 下面使用PlantUML来绘制一张流程图，可以实时预览，速度也很快！ 安装 通过在IDEA中安装插件来使用PlantUML无疑是最方便的，接下来我们来安装下IDEA的PlantUML插件。 首先在IDEA的插件市场中搜索PlantUML，安装这个排名第一的插件； 有时候网络不好的话可能下载不下来，可以点击Plguin homepage按钮访问插件主页，然后选择合适的版本下载压缩包； 下载成功后，选择从本地安装即可。 使用 接下来我们使用PlantUML插件分别绘制时序图、用例图、类图、活动图、思维导图，来体验下PlantUML是不是真的好用！ 时序图 时序图（Sequence Diagram），是一种UML交互图。它通过描述对象之间发送消息的时间顺序显示多个对象之间的动态协作。我们在学习Oauth2的时候，第一步就是要搞懂Oauth2的流程，这时候有个时序图帮助可就大了。下面我们使用PlantUML来绘制Oauth2中使用授权码模式颁发令牌的时序图。 首先我们需要新建一个PlantUML文件，选择时序图； 我们可以通过PlantUML提供的语法来生成Oauth2的时序图，语法还是非常简单的，具体内容如下；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
@startuml title Oauth2令牌颁发之授权码模式 actor User as user participant "User Agent" as userAgent participant "Client" as client participant "Auth Login" as login participant "Auth Server" as server autonumber user->userAgent:访问客户端 activate userAgent userAgent->login:重定向到授权页面+clientId+redirectUrl activate login login->server:用户名+密码+clientId+redirectUrl activate server server-->login:返回授权码 login-->userAgent:重定向到redirectUrl+授权码code deactivate login userAgent->client:使用授权码code换取令牌 activate client client->server:授权码code+clientId+clientSecret server-->client:颁发访问令牌accessToken+refreshToken deactivate server client-->userAgent:返回访问和刷新令牌 deactivate client userAgent--> user:令牌颁发完成 deactivate userAgent @enduml <span class="copy-code-btn">复制代码</span> |
该代码将生成如下时序图，用写代码的方式来画时序图，是不是够炫酷； 本时序图关键说明如下： title可以用于指定UML图的标题； 通过actor可以声明人形的参与者； 通过participant可以声明普通类型的参与者； 通过as可以给参与者取别名； 通过->可以绘制参与者之间的关系，虚线箭头可以使用-->； 在每个参与者关系后面，可以使用:给关系添加说明； 通过autonumber我们可以给参与者关系自动添加序号； 通过activate和deactivate可以指定参与者的生命线。 这里还有个比较神奇的功能，当我们右键时序图时，可以生成一个在线访问的链接； 直接访问这个链接，可以在线访问UML时序图，并进行编辑，是不是很酷！ 用例图 用例图（Usecase Diagram）是用户与系统交互的最简表示形式，展现了用户和与他相关的用例之间的关系。通过用例图，我们可以很方便地表示出系统中各个角色与用例之间的关系，下面我们用PlantUML来画个用例图。 首先我们需要新建一个PlantUML文件，选择用例图，该用例图用于表示顾客、主厨、美食家与餐馆中各个用例之间的关系，具体内容如下；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@startuml left to right direction actor Guest as g package Professional { actor Chief as c actor "Food Critic" as fc } package Restaurant { usecase "Eat Food" as uc1 usecase "Pay For Food" as uc2 usecase "Drink" as uc3 usecase "Review" as uc4 } g--> uc1 g--> uc2 g--> uc3 fc--> uc4 @enduml <span class="copy-code-btn">复制代码</span> |
该代码将生成如下用例图； 本用例图关键说明如下： left to right direction表示按从左到右的顺序绘制用例图，默认是从上到下； 通过package可以对角色和用例进行分组； 通过actor可以定义用户； 通过usecase可以定义用例； 角色和用例之间的关系可以使用-->来表示。 类图 类图（Class Diagram）可以表示类的静态结构，比如类中包含的属性和方法，还有类的继承结构。下面我们用PlantUML来画个类图。 首先我们需要新建一个PlantUML文件，选择类图，该图用于表示Person、Student、Teacher类的结构，具体内容如下；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@startuml class Person { # String name # Integer age + void move() + void say() } class Student { - String studentNo + void study() } class Teacher { - String teacherNo + void teach() } Person <|-- Student Person <|-- Teacher @enduml <span class="copy-code-btn">复制代码</span> |
该代码将生成如下类图，看下代码和类图，是不是发现和我们用代码定义类还挺像的； 本类图关键说明如下： 通过class可以定义类； 通过在属性和方法左边加符号可以定义可见性，-表示private，#表示protected，+表示public； 通过<|--表示类之间的继承关系。 活动图 活动图（Activity Diagram）是我们用的比较多的UML图，经常用于表示业务流程，比如电商中的下单流程就可以用它来表示。下面我们用PlantUML来画个活动图。 首先我们需要新建一个PlantUML文件，选择活动图，这里使用了mall项目中购物车中生成确认单的流程，具体内容如下；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
@startuml title 生成确认单流程 start :获取购物车信息并计算好优惠; :从ums_member_receive_address表中\n获取会员收货地址列表; :获取该会员所有优惠券信息; switch(根据use_type判断每个优惠券是否可用) case(0) :全场通用; if (判断所有商品总金额是否\n满足使用起点金额) then (否) :得到用户不可用优惠券列表; stop endif case(-1) :指定分类; if (判断指定分类商品总金额\n是否满足使用起点金额) then (否) :得到用户不可用优惠券列表; stop endif case(-2) :判断指定商品总金额是否满足使用起点金额; if (判断指定分类商品总金额\n是否满足使用起点金额) then (否) :得到用户不可用优惠券列表; stop endif endswitch :得到用户可用优惠券列表; :获取用户积分; :获取积分使用规则; :计算总金额，活动优惠，应付金额; stop @enduml <span class="copy-code-btn">复制代码</span> |
该代码将生成如下活动图，在活动图中我们既可以用if else，又可以使用switch，甚至还可以使用while循环，功能还是挺强大的； 本活动图关键说明如下： 通过start和stop可以表示流程的开始和结束； 通过:和;中间添加文字来定义活动流程节点； 通过if+then+endif定义条件判断； 通过switch+case+endswitch定义switch判断。 思维导图 思维导图（Mind Map），是表达发散性思维的有效图形工具，它简单却又很有效，是一种实用性的思维工具。之前在我的mall学习教程中就有很多地方用到了，下面我们用PlantUML来画个思维导图。 首先我们需要新建一个PlantUML文件，选择思维导图，这里使用了mall学习路线中的大纲视图，具体内容如下；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
@startmindmap +[#17ADF1] mall学习路线 ++[#lightgreen] 推荐资料 ++[#lightblue] 后端技术栈 +++_ 项目框架 +++_ 数据存储 +++_ 运维部署 +++_ 其他 ++[#orange] 搭建项目骨架 ++[#1DBAAF] 项目部署 +++_ Windows下的部署 +++_ Linux下使用Docker部署 +++_ Linux下使用Docker Compose部署 +++_ Linux下使用Jenkins自动化部署 --[#1DBAAF] 电商业务 ---_ 权限管理模块 ---_ 商品模块 ---_ 订单模块 ---_ 营销模块 --[#orange] 技术要点 --[#lightblue] 前端技术栈 --[#lightgreen] 进阶微服务 ---_ Spring Cloud技术栈 ---_ 项目部署 ---_ 技术要点 --[#yellow] 开发工具 --[#lightgrey] 扩展学习 @endmindmap <span class="copy-code-btn">复制代码</span> |
该代码将生成如下思维导图，其实使用PlantUML我们可以自己定义图形的样式，这里我自定义了下颜色； 本思维导图关键说明如下： 通过+和-可以表示思维导图中的节点，具有方向性； 通过[#颜色]可以定义节点的边框颜色； 通过_可以去除节点的边框； 总结 虽然目前可以绘制UML图的图形化工具很多，但是对于程序员来说，使用代码来绘图可能更直接，效率更高，尤其是配合IDEA使用。如果你想使用代码来绘图，不妨尝试下PlantUML吧。 参考资料 官方文档：plantuml.com/zh/ 作者：MacroZheng 链接：https://juejin.cn/post/7017988314053492767 来源：稀土掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View DetailsGradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy、Kotlin和Scala。 到此不得不说另一个很火的工具maven，众所周知，maven的两大作用： ①：管理jar包 ②：构建项目 使用maven的缺点，XML配置文件的繁琐，特别是项目较大时，pom.xml配置眼花缭乱。 Gradle在maven的基础上，简化了配置文件，自动搜索Gradle等，使得我们创建管理项目更加简单。 一、下载，Gradle是压缩文件，下载解压即可。https://gradle.org/releases/ 这个是发布版，当然你还可以去 https://services.gradle.org/ 下载更新的版本。本人下载5.2.1的发布版 https://gradle.org/next-steps/?version=5.2.1&format=all 下载完毕后在本地目录解压即可。 二、配置环境变量：GRADLE_HOME 变量值为Gradle文件解压的实际路径，本文为例：E:\Gradle\gradle-5.2.1-all\gradle-5.2.1 在系统变量 path中加入：%GRADLE_HOME%\bin; 在cmd输入gradle -v验证是否安装成功 三、配置Gradle使用maven本地仓库，这样Gradle就不会重新下载已经存在maven本地仓库的jar包，从而节省时间和空间。 在环境变量中加入新的系统变量：GRADLE_USER_HOME 变量值是maven本地仓库的路径，本文为例C:\Users\Administrator\.m2\repository 此时，Gradle下载的文件将放到指定的仓库路径中。但是还需要修改build.gradle文件中加入mavenLocal() 引用本地仓库 repositories { //repositories闭包 mavenLocal() //配置先从本地仓库寻找jar包，优先寻找上一个配置，找到不执行下面的配置 mavenCentral() //配置从中央仓库寻找 google() //第三方仓库 jcenter() //代码托管库：设置之后可以在项目中轻松引用jcenter上的开源项目 } from:https://www.cnblogs.com/zeussbook/p/10556025.html
View Details此前的 Java 社区报告曾指出，Java 8 仍是开发人员使用的主要版本，新版本并未“得宠”。但 Snyk 近期发布的 JVM Ecosystem Report 2021 则指出，开发人员已经逐渐从 Java 8 迁移到了 Java 11。 JVM Ecosystem Report 2021 展示了关于 JVM 生态系统状态的最大年度调查的结果。该调查在 2021 年 2 月和 3 月的六周时间里进行，收集了来自 2000 多名 Java 开发者的回复。 调查结果显示，有 44.1% 的受访者在生产中使用免费的 AdoptOpenJDK 发行版。但 Oracle 仍然是市场上的重要参与者，其 OpenJDK 构建占 28%，商业 Oracle JDK 占 23%。 40% 的调查参与者在生产中使用了一个以上的 Java 版本。升级到 8 版本以上的人也比预料的要多。目前，有 61.5% 的人在生产中使用 Java 11，近 12% 的人使用最新版本，即调查期间的 Java 15。 Snyk 方面在报告中指出，这表明开发人员确实将他们的 Java 版本升级到了 Java 8 以上的版本，有关大多数 Java 开发人员都乐于使用 Java 8 的现象似乎正在慢慢瓦解。不过值得注意的是，仍有一半的 Java 11 用户（目前使用最多的版本）在他们的生产堆栈中使用 Java 8。 从长远来看，虽然 JVM 语言的种类在过去几年中有所增长，但 Java 仍然是最受欢迎的语言。超过 90% 的开发者使用 Java；Kotlin 次之，为 17.7%。 而 JetBrains IntelliJ IDEA […]
View DetailsSecureRandom在java各种组件中使用广泛，可以可靠的产生随机数。但在大量产生随机数的场景下，性能会较低。这时可以使用"-Djava.security.egd=file:/dev/./urandom"加快随机数产生过程。 以产生uuid的时候使用nextBytes产生随机数为入口，xSecureRandom的代码逻辑。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
public static UUID randomUUID() { SecureRandom ng =Holder.numberGenerator; byte[] randomBytes = newbyte[16]; ng.nextBytes(randomBytes); randomBytes[6] &= 0x0f; /* clear version */ randomBytes[6] |=0x40; /* set to version 4 */ randomBytes[8] &= 0x3f; /* clear variant */ randomBytes[8] |=0x80; /* set to IETF variant */ return newUUID(randomBytes); } |
使用了SecureRandom.next*的方法。 在使用SecureRandom产生下一个随机数的时候调用nextLong或者nextBytes，最终会调用SecureRandom的nextBytes。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
public long nextLong() { // it's okay that the bottom wordremains signed. return ((long)(next(32)) << 32)+ next(32); } final protected int next(int numBits) { int numBytes = (numBits+7)/8; byte b[] = new byte[numBytes]; int next = 0; nextBytes(b); for (int i = 0; i < numBytes; i++) next = (next << 8)+ (b[i] & 0xFF); return next >>> (numBytes*8 -numBits); } |
而nextBytes是一个同步的方法，在多线程使用时，可能会产生性能瓶颈。
|
1 2 3 4 5 |
synchronized public void nextBytes(byte[] bytes) { secureRandomSpi.engineNextBytes(bytes); } |
secureRandomSpi被初始化为sun.security.provider.SecureRandom secureRandomSpi是SecureRandom.NativePRNG的一个实例。 使用jvm参数-Djava.security.debug=all ，可以打印securityprovider列表，从中可以看出，SecureRandom.NativePRNG由sun.security.provider.NativePRNG提供服务。 Provider: Set SUN provider property[SecureRandom.NativePRNG/sun.security.provider.NativePRNG] 分析openjdk的源码，NativePRNG.engineNextBytes调用了NativePRNG.RandomIO.ensureBufferValid，而ensureBufferValid直接从urandom读取数据：
|
1 2 3 4 5 6 7 8 9 |
private void ensureBufferValid() throws IOException { ... readFully(urandomIn, urandomBuffer); ... } |
通过测试可以发现，hotspot需要使用配置项"-Djava.security.egd=file:/dev/./urandom"才能从urandom读取数据，这里openjdk做了优化，直接从urandom读取数据。 /dev/random在产生大量随机数的时候比/dev/urandom慢，所以，建议在大量使用随机数的时候，将随机数发生器指定为/dev/./urandom。 转自：https://blog.51cto.com/leo01/1795447 from:https://blog.csdn.net/wangooo/article/details/109139129
View Details一:最基本的Dockerfile构建Springboot项目 在pom同目录下新建Dockerfile
|
1 2 3 4 |
FROM openjdk:8-jdk-alpine VOLUME /tmp COPY target/*.jar app.jar ENTRYPOINT ["java","-jar","/app.jar"] |
将Springboot使用Maven打包，在终端中传参进去，进行构建Images。
|
1 2 3 |
docker build --build-arg=target/*.jar -t demo1/app . #构建完成后启动容器 docker run -p 8080:8080 demo1/app |
给Springboot启动时候传环境变量或者shell参数
|
1 2 3 4 5 |
FROM openjdk:8-jdk-alpine VOLUME /tmp ARG JAR_FILE COPY ${JAR_FILE} app.jar ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app.jar ${0} ${@}"] |
指定JVM参数和shell参数
|
1 |
docker run -p 9000:9000 -e "JAVA_OPTS=-Ddebug -Xmx128m" demo1/app --server.port=9000 |
二：使用Idea可视化管理docker， 构建Springboot容器 这个在我另外一篇文章有讲到，都比较简单，有啥问题请留言。 三：使用Maven插件自动化构建Image https://github.com/spotify/dockerfile-maven ，能力强的可以直接去看README.md。 简单介绍一下这个插件做啥用的 通过pom配置docker构建Image过程，参数等 。 封装了自动化build，push，run等Maven命令 。 * 需要依赖Dockerfile，Dockerfile与pom.xml位于同一个目录下。 在pom.xml同目录下创建Dockerfile
|
1 2 3 4 |
FROM openjdk:8-jre ENTRYPOINT ["/usr/bin/java", "-jar", "/usr/share/myservice/app.jar"] ARG JAR_FILE ADD target/${JAR_FILE} /usr/share/myservice/app.jar |
在pom中添加
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<plugin> <groupId>com.spotify</groupId> <artifactId>dockerfile-maven-plugin</artifactId> <version>1.4.13</version> <executions> <execution> <id>default</id> <goals> <goal>build</goal> <goal>push</goal> </goals> </execution> </executions> <configuration> <!--你需要配置的地方--> <!--指定仓库名/镜像名--> <repository>myrep/${project.artifactId}</repository> <!--指定tag --> <tag>${project.version}</tag> <buildArgs> <!--指定参数jar--> <JAR_FILE>${project.build.finalName}.jar</JAR_FILE> </buildArgs> </configuration> </plugin> |
最后在Idea Maven插件Plugins点击docker:build即可。或者输入命令
|
1 |
mvn com.spotify:dockerfile-maven-plugin:build |
四:使用Google的Maven插件进行容器管理(重头戏) Google开源项目Jib，对比上面那个插件Jib的Start数为7.8k，dockerfile-maven 为2.4k。 maven 插件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<plugin> <groupId>com.google.cloud.tools</groupId> <artifactId>jib-maven-plugin</artifactId> <version>1.6.0</version> <configuration> <!--配置基本镜像--> <from> <image>openjdk:8-jdk-alpine</image> </from> <!--配置最终推送的地址，仓库名，镜像名--> <to> <image>registry.hub.docker.com/maoduntt/test</image> </to> </configuration> <!--绑定到maven lifecicle--> <executions> <execution> <phase>package</phase> <goals> <goal>build</goal> </goals> </execution> </executions> </plugin> |
配置maven docker hub账户和密码,在maven settings.xml中添加
|
1 2 3 4 5 |
<server> <id>registry.hub.docker.com</id> <username>你的dockerhub用户名</username> <password>你的dockerhub密码</password> </server> |
在idea maven插件中点击或者maven命令 mvn compile jib:buildTar 可以看到推送远程成功，Jib不需要写Dockerfile只需要你在插件中定义构建类型，所以使用时请多参考github的文档。最后现在也有这种开源的容器云平台，可以去了解下。 from:https://zhuanlan.zhihu.com/p/89161347
View Details环境： 1、代码编写工具：IDEA 2、打包：maven 3、docker 4、linux 7、JDK1.8 8、Xshell 9、Xftp 第一步：使用idea创建简单的springboot项目 第二步：设置项目生成jar包(两种方式) 1、修改pom文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>ordinary</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>ordinary</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.6.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <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-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> |
2、或者在生成项目的时候 可以选择jar和war 第三步：使用maven 生成包 (使用idea不用命令 直接界面操作就可以(如果Maven设置没问题 直接就可以生成 包 log会提示生成后的文件目录)) 第四步：docker概念 1、docker：最早是dotCloud公司出品的一套容器管理工具，但后来Docker慢慢火起来了，连公司名字都从dotCloud改成Docker。 2、dockerfile：它是Docker镜像的描述文件，可以理解成火箭发射的A、B、C、D……的步骤。 3、docker镜像：通过Dockerfile做出来的，包含操作系统基础文件和软件运行环境，它使用分层的存储方式。 4、docker容器：是运行起来的镜像，简单理解，Docker镜像相当于程序，容器相当于进程。 第四步：dockerfile指令 Dockerfile由多条指令组成，每条指令在编译镜像时执行相应的程序完成某些功能，由指令+参数组成，以逗号分隔，#作为注释起始符，虽说指令不区分大小写，但是一般指令使用大些，参数使用小写 第五步：dockerfile文件例子(我只是简单将springboot项目生成docker镜像没有什么多余配置) TODO：有一点需要注意的地方就是dockerfile文件没有任何后缀
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Pull base image FROM java:8 MAINTAINER yihj "yihj@yinghaikeji.com" VOLUME /tmp # 添加 ADD ordinary.jar app.jar RUN bash -c 'touch /app.jar' # Define default command. ENTRYPOINT ["java","-Dspring.profiles.active=online","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] #设置时区 RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone |
第六步：将dockerfile文件和生成好的jar 使用ftp工具上传到linux服务器 随便找个文件夹 放进去 jar和dockerfile在同级目录下 第七步：使用 docker build -t ordinary:v1.0 . TODO： 1、 最后面的这个 . 代表在当前目录下面寻找 dockerfile 文件 2、ordinary 镜像名字 3、v1.0版本 第八步：查看镜像及启动 1、使用docker images 来查看生成的镜像 2、使用docker create 来创建容器 docker run 来创建并且运行容器 3、也可以使用docker logs 容器名 --tail 100 -f 来查看项目启动日志 看项目是否启动 3、如果上面步骤一切正常 可以直接调用IP加端口来访问项目 通过Docker run命令定义Spring Profile 可以将spring profile作为环境变量传递给docker run命令，使用 -e 标记。 例如 -e “SPRING_PROFILES_ACTIVE=dev”会将dev profile传递给Docker容器 docker run -d -p 8080:8080 -e "SPRING_PROFILES_ACTIVE=dev" […]
View Details1.创建springboot项目 创建springboot项目
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.eangulee.demo.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; @Controller public class HelloController { @RequestMapping("/") @ResponseBody public String hello() { return "Hello, SpringBoot With Docker"; } } |
2.打包springboot项目为jar包 3. 编写Dockerfile文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Docker image for springboot file run # VERSION 0.0.1 # Author: eangulee # 基础镜像使用java FROM java:8 # 作者 MAINTAINER eangulee <eangulee@gmail.com> # VOLUME 指定了临时文件目录为/tmp。 # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp VOLUME /tmp # 将jar包添加到容器中并更名为app.jar ADD demo-0.0.1-SNAPSHOT.jar app.jar # 运行jar包 RUN bash -c 'touch /app.jar' ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] |
解释下这个配置文件： VOLUME 指定了临时文件目录为/tmp。其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp。该步骤是可选的，如果涉及到文件系统的应用就很有必要了。/tmp目录用来持久化到 Docker 数据文件夹，因为 Spring Boot 使用的内嵌 Tomcat 容器默认使用/tmp作为工作目录 项目的 jar 文件作为 “app.jar” 添加到容器的 ENTRYPOINT 执行项目 app.jar。为了缩短 Tomcat 启动时间，添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source 如果是第一次打包，它会自动下载java 8的镜像作为基础镜像，以后再制作镜像的时候就不会再下载了。 4. 部署文件 在服务器新建一个docker文件夹，将maven打包好的jar包和Dockerfile文件复制到服务器的docker文件夹下 docker文件夹 5. 制作镜像 执行下面命令， 看好，最后面有个"."点！
|
1 |
docker build -t springbootdemo4docker . |
-t 参数是指定此镜像的tag名 制作完成后通过docker images命令查看我们制作的镜像 6.启动容器
|
1 2 3 |
[root@localhost docker]# docker run -d -p 8080:8085 springbootdemo4docker -d参数是让容器后台运行 -p 是做端口映射，此时将服务器中的8080端口映射到容器中的8085(项目中端口配置的是8085)端口 |
7. 访问网站 直接浏览器访问： http://你的服务器ip地址:8080/ 好了，下一步就是学习springboot+mysql+redis如何在docker上如何部署了。 作者：雄关漫道从头越 链接：https://www.jianshu.com/p/397929dbc27d 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details缘由 我们在使用spring boot开发的服务中，一般会选择打包成单体的fatjar来发布服务，这在传统的部署方式下是非常方便的，但是当我们选择使用docker这种容器化的方式来部署应用的时候，却有一点点的不便之处，因为这个单体的jar一般都比较大，每次镜像push到仓库和从仓库拉取都需要比较长的时间。 原因是什么了？ docker的一大特色就是镜像的存储是分层的，参考下面这张官图 我们在Dockerfile中的每一个指令会对应到镜像的每一层，docker在更新镜像时，只会推送变更过的层，当它计算出来这一层的摘要和之前的版本一致时，会复用上一次打包镜像时的缓存，会极大的提高打包镜像以及镜像push/pull操作的速度。 那么问题来了，当我们springboot打包出来的单体jar的时候，每次编译这个jar都会发生变化，对应的存储层也会发生变化，push和pull操作时都需要重新推送，而且这个jar一般都不小，一个典型的应用会在100M左右，对应用部署和发布的速度会有比较大的影响。 稍作思考，很容易就能发现这个肥大的jar文件里面，大部分其实都是固定不变的各种依赖库，我们真正每次编译会变化的业务代码部分其实很小很小，可能也就只有几百KB，只要能将这两部分分离，变成docker镜像中的两层，一定能极大的提升镜像发布的速度 牛刀小试 首先拿来动手尝试的是一个springboot admin的项目，项目的结构是这样的： 使用最常见的打包方式：
|
1 2 3 4 |
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> |
会生成一个32M的jar文件，优化之前的Dockerfile非常简单：
|
1 2 3 4 5 6 7 8 |
FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp COPY target/*.jar ./app.jar CMD ["/bin/bash", "-c", "java -jar -server app.jar"] EXPOSE 8080 |
可以看到这种方式在构建v2版本的镜像时，会重新copy整个完整的jar 如果要拆开这个单体的jar，有两种方式，一是修改mvn打包的配置，将lib包放在独立的文件夹下，在这里我们考虑到项目众多，尽量减少修改，选择了在Docker打包镜像时，解压打包出来的jar包，将其中的内容分开来copy，修改后的Dockerfile如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#采用docker的分阶段构建方式，第一阶段负责解压jar包 FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp WORKDIR /target ADD target/*.jar app.jar RUN jar xf app.jar #这里分别copy解压后的内容 FROM openjdk:11.0.5-stretch VOLUME /tmp WORKDIR /app COPY --from=builder target/BOOT-INF/lib ./lib COPY --from=builder target/org/ ./org COPY --from=builder target/META-INF/ ./META-INF COPY --from=builder target/BOOT-INF/classes ./classes CMD ["/bin/bash", "-c", "java -cp .:./classes/:./lib/* -server org.springframework.boot.loader.JarLauncher"] EXPOSE 8080 |
看看修改后的效果： 在copy lib目录时，是直接using cache的。来看看push的时候效果对比 首先是优化前的push： 可以看到在push v2的时候还是会push一个33MB的层，虽然其实我们一行代码没有修改。 然后是优化后的： 可以看到这一次仅仅只推送了一个13KB的层，推送的速度快了非常多，同理也可以想象的到，我们在拉取镜像更新版本时速度会快很多。 路遇荆棘 在针对springboot-admin这个最简单的项目的优化取得很好的效果之后，就开始准备照搬到其他的项目中，没想到同样的方式怎么折腾都无效，分离之后的lib目录依然会每次需要全量重新push。出问题的项目结构大概是这样的： 一个常见的多模块mvn项目，有common，domain，rest-client，rest-server 这4个子模块，其中rest-server会依赖common和domain这两个子模块，打包出来的jar是在rest-server这个模块中。 究竟是什么鬼了？ 终得正果 苦苦思索一番之后，lib目录既然不能复用上一次的cache，那一定是因为里面的内容有变化，遂将jar包解压，进到lib目录，真凶果然在此： 项目自身的3个子模块在每次编译的时候也会做为jar包放到lib目录下，这3个jar包每次编译都会有变化，所以导致这一层的cache失效。 找到问题之后，解决的思路就很简单了，将这种jar单独copy到一个目录下即可，修改后的Dockerfile如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
FROM openjdk:11.0.5-stretch as builder RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime RUN echo 'Asia/Shanghai' >/etc/timezone VOLUME /tmp WORKDIR /target ADD target/*.jar app.jar RUN jar xf app.jar #创建一个snapshot目录，把snapshot的jar复制过去 RUN mkdir BOOT-INF/snapshot RUN mv BOOT-INF/lib/*SNAPSHOT.jar BOOT-INF/snapshot/ FROM openjdk:11.0.5-stretch VOLUME /tmp WORKDIR /app COPY --from=builder target/BOOT-INF/lib ./lib COPY --from=builder target/org/ ./org COPY --from=builder target/META-INF/ ./META-INF #单独复制snapshot这一层 COPY --from=builder target/BOOT-INF/snapshot ./snapshot COPY --from=builder target/BOOT-INF/classes ./classes CMD ["/bin/bash", "-c", "java -cp .:./classes/:./lib/*:./snapshot/* -server org.springframework.boot.loader.JarLauncher"] EXPOSE 8089 |
这样修改之后效果就和上面单模块的项目一样了，至此，基本完成了springboot项目的docker镜像优化，在jenkins的流水线上可以将原来镜像push的时间从1分钟以上优化到10s左右 未来之路 在整个优化的过程中，发现springboot2.3 M1版本已经有针对性的优化方案，增加了LAYERED_JAR的打包格式，未来可期。 具体可参考下文： www.jdon.com/53738 注： 本文中举例的两个项目案例，可在github上找到：github.com/yishh/sprin… 作者：thor_lee 链接：https://juejin.cn/post/6844904119338008583 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details遇到的问题： 公司java项目按老的方式打包出来一个fat jar，100MB, 推送到腾讯云镜像仓库很慢，8分钟。。。走的是公网，专线暂时还没配置好 以前是内网harbor，速度还不明显。 归根究底，一次推送100MB是个不合理的事情 思路： 了解spring boot打包，期望将依赖的libs 和 业务代码拆分 优化dockerfile，充分利用缓存 解决问题： 先修改spring-boot-maven-plugin，只打包业务代码。网上有些是配置exclude，我试了，恶心到了。。那么多包挨个找
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <!--<mainClass>cn.qg.clotho.Bootstrap</mainClass>--> <layout>ZIP</layout> <!--<executable>true</executable>--> <includes> <include> <groupId>${project.groupId}</groupId> <artifactId>${project.artifactId}</artifactId> </include> </includes> </configuration> </plugin> |
新增maven-dependency-plugin，将依赖移到libs目录下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <type>jar</type> <includeTypes>jar</includeTypes> <includeScope>runtime</includeScope> <outputDirectory>${project.build.directory}/libs</outputDirectory> </configuration> </execution> </executions> </plugin> |
优化dockerfile 参考 https://medium.com/@nieldw/caching-maven-dependencies-in-a-docker-build-dca6ca7ad612 ，牛逼
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
FROM mvn3.5 as builder WORKDIR /build COPY pom.xml . RUN mvn dependency:go-offline COPY src/ /build/src/ RUN mvn package FROM jdk1.8 EXPOSE 80 CMD exec java -Dloader.path="/home/libs/" -jar /home/app.jar COPY --from=builder /build/target/*.jar /home/app.jar COPY --from=builder /build/target/libs /home/libs/ |
搞定。最终代码变化每次推送也就1MB多 启动命令 java -Dloader.path="libs/" -jar app.jar 作者：小猋_a8f1 链接：https://www.jianshu.com/p/32456eea0488 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
View Details