SpringBoot分离打Jar包的两种配置方式

2024-08-28 21:39:17

方式一：基于maven-jar-plugin

此方式基于这个小伙伴的配置改的：https://www.jb51.net/article/188606.htm

注意

这种方式打包出来的Jar基于插件提供的类加载器启动：org.springframework.boot.loader.PropertiesLauncher
所有依赖包(包括systemScope)，会通过插件 maven-dependency-plugin 自动复制到 lib 目录
所有资源文件，会通过插件 maven-resources-plugin 自动复制到 config 目录
此方式打包后，需要指定参数启动 -Dloader.path=lib路径,config路径
打包完后部署需要的文件清单：（在 target/ 目录下都可以看到）
- config/**：所有resources下的资源文件
- lib/**：所有lib包，包括本地依赖
- xxx.jar：应用Jar
运行：java -Dloader.path=lib,config -Dspring.profiles.active=dev -jar main.jar

简略版配置

<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">
	<properties>
		<!--依赖输出目录-->
		<lib-path>lib</lib-path>
		<!--配置文件输出目录-->
		<config-path>config</config-path>
		<!--jar包名称-->
		<final-name>xxx</final-name>
		<!--指定启动类-->
		<main-class>org.jeecg.JeecgSystemApplication</main-class>
	</properties>

	<build>
		<!--项目名称-->
		<finalName>${final-name}</finalName>
		<plugins>
			<!--定义项目的编译环境-->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!--maven的测试用例插件，建议跳过。-->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
			<!--这个是springboot的默认编译插件，他默认会把所有的文件打包成一个jar-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
			<!-- 打自定义的JAR包 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<configuration>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<!-- MANIFEST.MF 中 Class-Path 加入前缀 -->
							<classpathPrefix>${lib-path}/</classpathPrefix>
							<!-- jar包不包含唯一版本标识 -->
							<useUniqueVersions>false</useUniqueVersions>
							<!--指定入口类 -->
							<mainClass>${main-class}</mainClass>
						</manifest>
						<manifestEntries>
							<!--MANIFEST.MF 中 Class-Path 加入资源文件目录 -->
							<!--本地依赖，多个需要使用空格隔开-->
							<Class-Path>./${config-path}/ lib/zwdd-1.2.0.jar lib/spire-10.jar</Class-Path>
						</manifestEntries>
					</archive>
					<outputDirectory>${project.build.directory}</outputDirectory>
				</configuration>
			</plugin>
			<!-- 该插件的作用是用于复制依赖的jar包到指定的文件夹里 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/${lib-path}/</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
			<!-- 该插件的作用是用于复制指定的文件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<executions>
					<!-- 复制配置文件 -->
					<execution>
						<id>copy-resources</id>
						<phase>package</phase>
						<goals>
							<goal>copy-resources</goal>
						</goals>
						<configuration>
							<resources>
								<!--复制资源文件到外部，注意这里先不做filtering处理，防止某些静态文件损坏-->
								<resource>
									<filtering>false</filtering>
									<directory>src/main/resources</directory>
									<includes>
										<include>**/*</include>
									</includes>
								</resource>
								<!--仅针对yml配置文件filtering处理(占位符@@等)-->
								<resource>
									<filtering>true</filtering>
									<directory>src/main/resources</directory>
									<includes>
										<include>*.yml</include>
									</includes>
								</resource>
							</resources>
							<outputDirectory>${project.build.directory}/${config-path}</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
		<resources>
			<!--包含java类路径下的资源文件(mybatis的xml等)-->
			<resource>
				<directory>src/main/java</directory>
				<filtering>false</filtering>
				<includes>
					<include>**/*.xml</include>
					<include>**/*.json</include>
					<include>**/*.ftl</include>
				</includes>
			</resource>
			<!--排除jar包内的所有resources配置文件-->
			<resource>
				<directory>src/main/resources</directory>
				<filtering>false</filtering>
				<excludes>
					<exclude>**/*</exclude>
				</excludes>
			</resource>
			<!--注: 为了能在IDEA中跑起来，需要将所有yml配置文件打进jar包，filtering必须开启(处理占位符等操作)-->
			<resource>
				<directory>src/main/resources</directory>
				<filtering>true</filtering>
				<includes>
					<include>*.yml</include>
				</includes>
			</resource>
		</resources>
	</build>
</project>

完整配置(带部分注释)

<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">
	<parent>
		<groupId>org.jeecgframework.boot</groupId>
		<artifactId>jeecg-boot-parent</artifactId>
		<version>2.4.0</version>
	</parent>
	<modelVersion>4.0.0</modelVersion>
	<artifactId>jeecg-boot-module-system</artifactId>
	<repositories>
		<repository>
			<id>aliyun</id>
			<name>aliyun Repository</name>
			<url>http://maven.aliyun.com/nexus/content/groups/public</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>
	<dependencies>
		<dependency>
			<groupId>com.spire</groupId>
			<artifactId>spire</artifactId>
			<version>10</version>
			<scope>system</scope>
			<systemPath>${project.basedir}/../lib/Spire.Doc.jar</systemPath>
		</dependency>
		<dependency>
			<groupId>com.zwdd.api</groupId>
			<artifactId>zwdd</artifactId>
			<version>1.2.0</version>
			<scope>system</scope>
			<systemPath>${project.basedir}/../lib/zwdd-sdk-java-1.2.0.jar</systemPath>
		</dependency>
	</dependencies>

	<properties>
		<!--依赖输出目录-->
		<lib-path>lib</lib-path>
		<!--springboot默认打包输出目录-->
		<jar-path>jar</jar-path>
		<!--配置文件输出目录-->
		<config-path>config</config-path>
		<!--jar包名称-->
		<final-name>xxx</final-name>
		<!--指定启动类-->
		<main-class>org.jeecg.JeecgSystemApplication</main-class>
	</properties>

	<build>
		<!--项目名称-->
		<finalName>${final-name}</finalName>
		<plugins>
			<!--定义项目的编译环境-->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!--maven的测试用例插件，建议跳过。-->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<configuration>
					<skip>true</skip>
				</configuration>
			</plugin>
			<!--这个是springboot的默认编译插件，他默认会把所有的文件打包成一个jar，注意这里打包出来不会包含systemScope的jar包，有需要的话得在最后的resources里配置-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<!--这里仅展示插件作用，直接跳过此插件-->
					<skip>true</skip>
					<mainClass>${main-class}</mainClass>
					<fork>true</fork>
					<addResources>true</addResources>
					<!--指定激活的配置文件application-xxx.yml-->
					<profiles>${profile.name}</profiles>
					<outputDirectory>${project.build.directory}/${jar-path}</outputDirectory>
				</configuration>
			</plugin>
			<!-- 打自定义的JAR包 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-jar-plugin</artifactId>
				<configuration>
					<!-- 不打包资源文件（配置文件和依赖包分开），这里配置的资源排除，仅在*.xml这类文件通配符筛选生效，因此不在这里处理 -->
					<excludes>
						<!--这种文件方式匹配可以生效-->
						<!--<exclude>*.yml</exclude>-->
						<!--下面这种方式配置是无效的，见：https://stackoverflow.com/questions/4113697/in-maven-how-to-exclude-resources-from-the-generated-jar-->
						<!--上述问题链接中有此描述：<exclude>src/test/resources/**</exclude> doesn't work. Exclude will be applied on jar final path and should be <exclude>*.properties</exclude>-->
						<!--<exclude>src/main/resources/**</exclude>-->
					</excludes>
					<archive>
						<manifest>
							<addClasspath>true</addClasspath>
							<!-- MANIFEST.MF 中 Class-Path 加入前缀 -->
							<classpathPrefix>${lib-path}/</classpathPrefix>
							<!-- jar包不包含唯一版本标识 -->
							<useUniqueVersions>false</useUniqueVersions>
							<!--指定入口类 -->
							<mainClass>${main-class}</mainClass>
						</manifest>
						<manifestEntries>
							<!--MANIFEST.MF 中 Class-Path 加入资源文件目录 -->
							<!--本地依赖，多个需要使用空格隔开-->
							<Class-Path>./${config-path}/ lib/zwdd-1.2.0.jar lib/spire-10.jar</Class-Path>
						</manifestEntries>
					</archive>
					<outputDirectory>${project.build.directory}</outputDirectory>
				</configuration>
			</plugin>
			<!-- 该插件的作用是用于复制依赖的jar包到指定的文件夹里 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<!--这里可以手动添加构建id，但默认是全打包就不需要了-->
							<!--<includeArtifactIds>xxxx</includeArtifactIds>-->
							<!--默认包含所有scope，因此本地的依赖也正常复制-->
							<!--<includeScope>system</includeScope>-->
							<outputDirectory>${project.build.directory}/${lib-path}/</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
			<!-- 该插件的作用是用于复制指定的文件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<executions>
					<!-- 复制配置文件 -->
					<execution>
						<id>copy-resources</id>
						<phase>package</phase>
						<goals>
							<goal>copy-resources</goal>
						</goals>
						<configuration>
							<resources>
								<!--复制资源文件到外部，注意这里先不做filtering处理，防止某些静态文件损坏-->
								<resource>
									<filtering>false</filtering>
									<directory>src/main/resources</directory>
									<includes>
										<!--<include>*.yml</include>-->
										<!--把所有resources目录下的资源文件复制出来-->
										<include>**/*</include>
									</includes>
								</resource>
								<!--仅针对yml配置文件filtering处理(占位符@@等)-->
								<resource>
									<filtering>true</filtering>
									<directory>src/main/resources</directory>
									<includes>
										<include>*.yml</include>
									</includes>
								</resource>
							</resources>
							<outputDirectory>${project.build.directory}/${config-path}</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
		<!--手动处理资源文件，这里的操作都是针对最终打出的jar包内部文件的进行引入、筛选、过滤等等，默认文件都打进jar包内部的根路径下，因此前面的插件[maven-jar-plugin]中需要配置相对路径-->
		<!--具体路径在这里: /project/build/plugins/[maven-jar-plugin]/configuration/archive/manifestEntries/Class-Path 添加classpath:. (注意和其它配置以空格分开)-->
		<resources>
			<!--包含java类路径下的资源文件(mybatis的xml等)-->
			<resource>
				<directory>src/main/java</directory>
				<filtering>false</filtering>
				<includes>
					<include>**/*.xml</include>
					<include>**/*.json</include>
					<include>**/*.ftl</include>
				</includes>
			</resource>
			<!--排除jar包内的所有resources配置文件-->
			<resource>
				<directory>src/main/resources</directory>
				<!--filtering会做处理配置文件@@占位符等操作，但是不排除某些文件的话可能导致压缩损坏-->
				<filtering>false</filtering>
				<excludes>
					<exclude>**/*</exclude>
				</excludes>
			</resource>
			<!--注: 上述配置已经能够正常分离所有配置、外部依赖、工程代码，启动命令：java -jar xxx.jar-->
			<!--注: 但是工程打包后，你会发现IDEA上跑不起来(target/classes目录下没有配置文件)-->
			<!--注: 这里尝试过在IDEA启动app时指定JVM参数(但是没有用,谁研究过可以说下): -Dloader.path=lib,config-->
			<!--注: 为了能在IDEA中跑起来，需要将所有yml配置文件打进jar包，filtering必须开启(处理占位符等操作)-->
			<resource>
				<directory>src/main/resources</directory>
				<filtering>true</filtering>
				<includes>
					<include>*.yml</include>
				</includes>
			</resource>
			<!--本地依赖打进jar包,这个配置是配合spring-boot-maven-plugin插件使用的-->
			<!--<resource>-->
			<!--	<directory>../lib/crack</directory>-->
			<!--	<targetPath>BOOT-INF/lib/</targetPath>-->
			<!--	<includes><include>**/*.jar</include></includes>-->
			<!--</resource>-->
			<!--<resource>-->
			<!--	<directory>../lib</directory>-->
			<!--	<targetPath>BOOT-INF/lib/</targetPath>-->
			<!--	<includes><include>*.jar</include></includes>-->
			<!--</resource>-->
		</resources>
	</build>
</project>

方式二：基于spring-boot-maven-plugin

注意

这种方式打包出来的Jar基于插件提供的类加载器启动：org.springframework.boot.loader.PropertiesLauncher
所有依赖包(包括systemScope)，会通过插件 maven-dependency-plugin 自动复制到 lib 目录
所有资源文件，会通过插件 maven-resources-plugin 自动复制到 config 目录
此方式打包后，需要指定参数启动 -Dloader.path=lib路径,config路径
打包完后部署需要的文件清单：（在 target/ 目录下都可以看到）
- config/**：所有resources下的资源文件
- lib/**：所有lib包，包括本地依赖
- xxx.jar：应用Jar
运行：java -Dloader.path=lib,config -Dspring.profiles.active=dev -jar main.jar

配置参考

<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">

	<build>
		<finalName>main</finalName>
		<plugins>
			<!--该插件的作用是指定编译配置、做预处理，如Lombok、mapstruct等框架需要预处理代码-->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
					<annotationProcessorPaths>
						<path>
							<groupId>org.mapstruct</groupId>
							<artifactId>mapstruct-processor</artifactId>
							<version>1.4.1.Final</version>
						</path>
						<path>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
							<version>1.18.12</version>
						</path>
					</annotationProcessorPaths>
				</configuration>
			</plugin>
			<!--该插件的作用是打包spring-boot的jar包-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<!--入口其实会自动配置-->
					<mainClass>org.jeecg.JeecgSystemApplication</mainClass>
					<!--不排除的话，systemScope的依赖包会自动被此插件打包进xxx.jar\BOOT-INF\lib，和外部依赖产生冲突 -->
					<includeSystemScope>false</includeSystemScope>
					<skip>false</skip>
					<!--分离Jar包-->
					<layout>ZIP</layout>
					<includes>
						<include>
							<groupId>nothing</groupId>
							<artifactId>nothing</artifactId>
						</include>
					</includes>
				</configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- 该插件的作用是复制依赖的jar包到指定的文件夹里 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<executions>
					<execution>
						<id>copy-dependencies</id>
						<phase>package</phase>
						<goals>
							<goal>copy-dependencies</goal>
						</goals>
						<configuration>
							<outputDirectory>${project.build.directory}/lib/</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
			<!-- 该插件的作用是复制指定的文件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<executions>
					<!-- 复制配置文件 -->
					<execution>
						<id>copy-resources</id>
						<phase>package</phase>
						<goals>
							<goal>copy-resources</goal>
						</goals>
						<configuration>
							<resources>
								<!--复制资源文件到外部，注意这里先不做filtering处理，防止某些静态文件损坏-->
								<resource>
									<filtering>false</filtering>
									<directory>src/main/resources</directory>
									<includes>
										<include>**/*</include>
									</includes>
								</resource>
								<!--仅针对配置文件filtering处理(占位符@@等)-->
								<resource>
									<directory>src/main/resources</directory>
									<filtering>true</filtering>
									<includes>
										<include>*.xml</include>
										<include>*.yml</include>
										<include>*.properties</include>
									</includes>
								</resource>
							</resources>
							<outputDirectory>${project.build.directory}/config</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
		<resources>
			<!--打包java路径下的静态文件-->
			<resource>
				<directory>src/main/java</directory>
				<filtering>false</filtering>
				<includes>
					<include>**/*.xml</include>
					<include>**/*.json</include>
					<include>**/*.ftl</include>
				</includes>
			</resource>
			<!--注: 为了能在IDEA中跑起来，需要将所有yml配置文件打进jar包，filtering必须开启(处理占位符等操作)-->
			<resource>
				<directory>src/main/resources</directory>
				<filtering>true</filtering>
				<includes>
					<include>*.yml</include>
          <include>*.txt</include>
				</includes>
			</resource>
		</resources>
	</build>
</project>

附录：参考链接

SpringBoot项目分离打包
maven-jar-plugin插件对scope="system"依赖的处理
https://docs.spring.io/spring-boot/docs/current/maven-plugin/reference/htmlsingle/
https://www.kancloud.cn/zhangdaiscott/jeecg-boot/3043463
Springboot jar包外指定配置文件及原理
Spring Boot之application.properites的failed to convert java.lang.String to java.lang.Integer问题解决
Maven maven-dependency-plugin包含本地依赖包
Spring Boot 分离资源文件打包
https://blog.csdn.net/weixin_40461281/article/details/115905734
https://www.jianshu.com/p/0277b6a17892

到此这篇关于SpringBoot分离打Jar包的两种方式的文章就介绍到这了,更多相关SpringBoot打Jar包内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

关于Springboot打成JAR包后读取外部配置文件的问题

Springboot的默认配置文件为:application.properties或者是application.yml 如果这两个配置文件都存在,不冲突的话,就互相补充.冲突的话,则properties优先级高. 当我们使用IDEA创建出一个Springboot项目上时,配置文件默认出现在classpath(也就是项目里的resources)目录下. Springboot的application.properties配置文件的加载路径优先级(从高到低): 工程根目录:./config/ 工程根目
使用Springboot 打jar包实现分离依赖lib和配置

目录打jar包实现分离依赖lib和配置操作步骤 Springboot中jar包分离(分离lib包) jar包分离介绍 jar包分离实施步骤小结一下打jar包实现分离依赖lib和配置为了业务需要配置文件和jar分离,便于使用者修改配置信息,在网上找了很久,最终找到一个简单有效的方法. 操作步骤打开project工程的pom.xml文件,将下列配置粘贴到pom文件中: <properties> <java.version>1.8</java.version> &
maven springboot如何将jar包打包到指定目录

目录如何将jar包打包到指定目录 1.目的 2.修改pom 3.修改启动脚本 jar包外指定配置文件及原理解决方案运行原理如何将jar包打包到指定目录今天分享一下springboot将jar包打包到指定目录下. 由于之前上线都是一个打包到一个jar,由于服务多了,1个包100多M,哪怕是小版本上线都需要重新上传jar包. 1.目的将不常用的比如spring,druid等不常用打包到lib目录,这样每次上线不需要上传这些.第三方或者常改动的还打包到本身的jar包内,每次上线都会新打包
springboot打包实现项目JAR包和依赖JAR包分离

目录写在前面的默认的maven配置解决方案 assembly配置 maven中的配置最终打包后的效果写在前面的当我们使用spring boot写项目时,一般都会遇到一个问题,那就是spring boot打包时,会将自己写的代码和项目的所有依赖文件打成一个可执行的jar包. 通常我们的项目都是运行在服务器上的,当项目更新时,每次都要向服务器上传这个包.如果项目的依赖包很多,那么这个文件就会非常大. 大文件上传不仅浪费带宽,有时候网络不稳定,传输一半断网,又要重新上传,非常麻烦. 默认的
使用SpringBoot打jar包并部署到Tomcat详细步骤

详细步骤首先在pom.xml文件中做一些修改: 之前打war包需要修改打包方式,这次不需要了,因为默认就是 jar 包指定最终打成jar包的名称手动指定 resources 文件夹编译打包的路径添加SpringBoot内嵌Tomcat解析jsp的依赖(仅仅是为这个实例而添加) <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/PO
springboot项目打包成jar包的图文教程

目录一.为什么打包二.如何打包 (1)使用IDEA进行打包 (2)使用maven进行打包三.运行jar包四.注意一.为什么打包项目开发完毕后会将前后端应用打包,然后部署到服务器上运行.Java Web应用在Spring Boot之前,通常是打包成war包,结合Tomcat来完成部署.而对于SpringBoot,官方的建议是将Spring Boot应用打包成一个fat jar(SpringBoot默认打包方式),即项目的依赖jar包也会被包含在Spring Boot项目的jar包当中,
SpringBoot分离打Jar包的两种配置方式

目录方式一:基于maven-jar-plugin 方式二:基于spring-boot-maven-plugin 附录:参考链接 SpringBoot分离打Jar包的两种方式方式一:基于maven-jar-plugin 此方式基于这个小伙伴的配置改的:https://www.jb51.net/article/188606.htm 注意这种方式打包出来的Jar基于插件提供的类加载器启动:org.springframework.boot.loader.PropertiesLauncher 所有依
超详细介绍idea中java程序打jar包的两种方式

java程序打成的jar包有两种类型,一种是可直接执行的runnable jar文件,另一种是包含多个主类,运行时需要指定主类全类名的jar包,下面我们细说在idea中两种jar包的打包方法及执行jar包时的命令. 第一种: 含多个主类的jar包打包方法及运行命令在写好我们要打jar包的java程序后,点击idea右上角如图所示位置先选择Artifacts,再点击加号点击Empty新建一个新的jar包如图,设置jar包名称,jar包打好后所在的路径,以及添加工程编译文件点击OK后,会回到
idea+maven打jar包的两种方式

两种打jar包的方法: jar包工程是maven下的quickstart工程需要jar的是maven下的webapp工程(我这里是这样的 ) 一.普通jar包的打包方式: 在我们的idea工程界面,点击右上角的project structure 然后在project setting里面选择Artifacts,点击加号,选择jar,给个包名,然后apply 回到我们的工程界面,选择菜单栏中的build,下拉菜单中的build artifacts 如果是第一次打包就build,不是就rebuild
详细总结IDEA中打jar包的两种方式

一.前言在讲这两种方式之前,我们先来说明一下什么是java中的jar文件 jar (Java Archive File),翻译过来就是java的档案文件,它其实也类似于我们windows下的zip文件,唯一的区别就是在 JAR 文件的内容中,包含了一个 META-INF/MANIFEST.MF 文件,这个文件是在生成 JAR 文件的时候自动创建的,包含了JAR包的描述信息.主类的全类名等信息. 二.不使用Maven直接打Jar包 1.File -->Project Structure -->
IDEA中打jar包的两种方式

在讲这两种方式之前,我们先来说明一下什么是java中的jar文件 jar (Java Archive File),翻译过来就是java的档案文件,它其实也类似于我们windows下的zip文件,唯一的区别就是在 JAR 文件的内容中,包含了一个 META-INF/MANIFEST.MF 文件,这个文件是在生成 JAR 文件的时候自动创建的,包含了JAR包的描述信息.主类的全类名等信息. 一:不使用Maven直接打Jar包. 1.File -->Project Structure -->Arti
详解idea+maven打jar包的两种方式

两种打jar包的方法: jar包工程是maven下的quickstart工程需要jar的是maven下的webapp工程(我这里是这样的 ) 一.普通jar包的打包方式: 在我们的idea工程界面,点击右上角的project structure 然后在project setting里面选择Artifacts,点击加号,选择jar,给个包名,然后apply 回到我们的工程界面,选择菜单栏中的build,下拉菜单中的build artifacts 如果是第一次打包就build,不是就rebuild
spring aop两种配置方式

第一种:注解配置AOP 注解配置AOP(使用 AspectJ 类库实现的),大致分为三步: 1. 使用注解@Aspect来定义一个切面,在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around). 2. 开发需要被拦截的类. 3. 将切面配置到xml中,当然,我们也可以使用自动扫描Bean的方式.这样的话,那就交由Spring AoP容器管理. 另外需要引用 aspectJ 的 jar 包:
AOP之事务管理<aop:advisor>的两种配置方式

目录 AOP事务管理<aop:advisor>两种配置方式方式一方式二 hibernate事务配置Aop aop:advisor模式 AOP事务管理<aop:advisor>两种配置方式方式一 @transactionManagerbean.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.o
详解springboot之jackson的两种配置方式

springboot 针对jackson是自动化配置的,如果需要修改,有两种方式: 方式一:通过application.yml 配置属性说明:## spring.jackson.date-format指定日期格式,比如yyyy-MM-dd HH:mm:ss,或者具体的格式化类的全限定名 spring.jackson.deserialization是否开启Jackson的反序列化 spring.jackson.generator是否开启json的generators. spring.jackson
springboot扫描引入jar包的service等组件方式

在pom中引入对应的依赖,如果引入的三方jar包跟该项目Application所在包目录包含被依赖jar包目录, 即下面的情况: 像上面这种包组织的话,是不需要额外加入任何配置的(前提是依赖jar包相应组件一定要有@Component等注解修饰),因为springboot项目默认扫描目录就是Application所在目录及子目录,但是这种情况仅限于单个项目安排,项目大了就不一定满足了, 这时可以通过下面的方式引入扫描路径: 或者通过@ComponentScan注解也可以,需要注意的是不要忘了扫描

SpringBoot分离打Jar包的两种配置方式

目录

方式一：基于maven-jar-plugin

方式二：基于spring-boot-maven-plugin

附录：参考链接

相关推荐

随机推荐