调用jar包外配置文件

合集下载

urlclassloader调用jar包的方法

文章标题：深度探析URLClassLoader调用jar包的方法1. 背景介绍URLClassLoader是Java中的一种类加载器，它可以加载指定的URL 中的类文件，包括本地文件系统、网络文件系统等。

而jar包是Java 中用于打包和部署类文件的标准格式。

在实际开发中，我们经常会使用URLClassLoader来调用jar包中的类文件。

本文将针对URLClassLoader调用jar包的方法进行深度探讨，帮助读者全面、深入地理解这一主题。

2. URLClassLoader的基本原理URLClassLoader是Java中的一种ClassLoader，它可以从指定的URL加载类文件。

在调用jar包时，我们可以通过创建URLClassLoader实例，并通过addURL()方法将jar包的URL添加到ClassLoader的搜索路径中，从而实现对jar包中类文件的加载。

这种方式使得我们可以在运行时动态加载外部的jar包，极大地提高了程序的灵活性和可扩展性。

3. URLClassLoader调用jar包的步骤（1）创建URLClassLoader实例：首先需要创建URLClassLoader实例，通过指定URLClassLoader的搜索路径来确保可以加载到jar包中的类文件。

（2）添加jar包的URL：使用addURL()方法将jar包的URL添加到ClassLoader的搜索路径中，以便ClassLoader可以加载到jar包中的类文件。

（3）加载并调用类文件：通过ClassLoader的loadClass()方法加载指定的类文件，然后可以通过反射机制调用类中的方法或创建类的实例。

4. URLClassLoader调用jar包的注意事项在使用URLClassLoader调用jar包时，需要注意以下几点：（1）确保jar包的URL是有效的，并且可以被ClassLoader正确地加载到。

（2）避免破坏双亲委派模型：在Java的类加载机制中，ClassLoader 是通过双亲委派模型来加载类的，因此需要注意不要破坏这一模型。

cmd调用jar方法

cmd调用jar方法摘要：1.CMD调用JAR文件的基本方法2.如何运行Java程序3.常见问题及解决方案正文：CMD调用JAR文件是一种常见的操作方式，尤其在Windows操作系统中。

下面将详细介绍CMD调用JAR文件的方法以及相关实用技巧。

一、CMD调用JAR文件的基本方法要使用CMD命令调用JAR文件，需要知道JAR文件的完整路径。

假设JAR文件名为“example.jar”，存放在目录“C:example”中，可以使用以下命令：```java -jar C:exampleexample.jar```此外，还可以使用“cd”命令切换到JAR文件所在目录，然后再调用JAR 文件：```cd C:examplejava -jar example.jar```二、如何运行Java程序要运行Java程序，除了使用JAR文件外，还可以使用Java源代码。

首先，需要将Java源代码编译成JAR文件，然后使用以下命令运行：```java -jar filename.jar```其中，“filename”为JAR文件的名称。

三、常见问题及解决方案1.权限问题：在某些情况下，可能无法直接运行JAR文件。

此时，可以尝试使用“runas”命令，以管理员身份运行CMD：```runas /user:admin cmd```然后，在CMD中调用JAR文件。

2.路径问题：如果JAR文件不在系统路径中，需要手动指定完整路径。

可以使用“set”命令设置环境变量，以便在后续命令中引用：```set PATH=C:examplebin;%PATH%```然后，再次调用JAR文件。

3.版本问题：如果遇到Java版本不兼容的问题，可以尝试升级Java版本或使用对应版本的JAR文件。

总之，CMD调用JAR文件是一种简单实用的方法，只需掌握基本命令和注意事项，即可轻松实现。

在实际操作过程中，遇到问题要善于分析原因，寻找解决方案。

调用jar包方法

调用jar包方法
1.添加jar包：将jar包文件添加到项目的classpath中，通常是在IDE的项目设置中添加。

2.导入类：在需要使用类的代码文件中导入类，例如Java中使用import关键字。

3.创建对象：使用new操作符创建类的对象，例如Java中使用new关键字。

4.调用方法：在创建对象之后，可以使用对象调用类的方法，例如Java中使用"."符号调用方法。

例如，我们可以调用Apache的commons-lang3库中的StringUtils类中的方法：
1.添加jar包：将commons-lang3-3.10.jar文件添加到项目的classpath中。

2.导入类：在需要使用类的Java代码文件中添加import
ng3.StringUtils;语句。

3.创建对象：StringUtils类中的方法为静态方法，可以直接调用，无需创建对象。

4.调用方法：使用StringUtils类中的静态方法对字符串进行操作，例如
StringUtils.capitalize("hello")会将字符串“hello”的首字母大写。

调用jar包的方法

调用jar包的方法一、引言在Java开发中，我们经常会使用到jar包，它是一种Java的二进制文件格式，可以将多个类文件打包成一个文件，方便我们进行代码的管理和复用。

本文将介绍如何在Java中调用jar包的方法。

二、了解jar包1. jar包的结构一个jar包由以下几部分组成：- META-INF目录：存放MANIFEST.MF文件。

- com目录：存放Java类文件。

- 其他资源文件：如图片、配置文件等。

2. 创建jar包可以使用Eclipse或者命令行工具来创建jar包。

使用Eclipse创建jar包：- 在项目上右键选择Export。

- 选择Java -> JAR file。

- 选择要导出的项目和输出路径。

- 配置选项并导出。

使用命令行工具创建jar包：- 打开命令行窗口，并进入要打包的目录。

- 输入以下命令：`jar cvf jarName.jar files`（其中files为要打包的文件）。

三、调用jar包1. 使用classpathclasspath是指JVM在执行Java程序时搜索class文件和资源文件所需的路径。

我们可以通过设置classpath来让JVM找到需要调用的jar包。

设置classpath有以下几种方式：- 在命令行中使用-cp或-classpath参数设置。

- 在系统环境变量中设置。

- 在代码中通过System.setProperty()方法设置。

例如，在Windows系统下，我们可以在命令行中输入以下命令：```java -cp jarName.jar;yourClassPath yourMainClass```其中，jarName.jar为要调用的jar包名，yourClassPath为自定义的classpath路径，yourMainClass为要执行的主类。

2. 使用import语句我们可以在代码中使用import语句来引入jar包中的类。

例如：```javaimport com.example.MyClass;```其中，com.example为jar包中MyClass类所在的包名。

java读JAR包里的配置文件

private static String getXmlContent()throws IOException {Reader f = newInputStreamReader(QueryWeather.class.getClass().getResourceAsStream("/weather/we ather.xml"));BufferedReader fb = new BufferedReader(f);StringBuffer sb = new StringBuffer(“”);String s = "";while((s = fb.readLine()) != null) {sb = sb.append(s);}return sb.toString();}package com.read;import java.io.*;public class Resource {public void getResource() throws IOException{//返回读取指定资源的输入流InputStream is=this.getClass().getResourceAsStream("/struts-default.xml"); BufferedReader br=new BufferedReader(new InputStreamReader(is));String s="";while((s=br.readLine())!=null)System.out.println(s);}}这个类是jar包中的类,同时jar根下还有个struts-default.xml文件。

ClassLoader classloader = Thread.currentThread().getContextClassLoader(); InputStream is = classloader.getResourceAsStream("com/xxx/xxxx/yourfile.xml");一般情况下properties文件都是在工程内使用的，如果application打成jar包之后，修改properties文件后就需要重新打jar，很麻烦。

调用jar包外配置文件

项目中，经常把一部分功能独立出来，做一个java project，然后打成jar包供其他项目引用。

这时候，如果jar包中需要读取配置文件信息，则很少把该配置打进jar包，因为它不方便修改，更多都是采用jar包读取外部配置文件。

案例：项目工程名：auth -- 很明显，做鉴权使用的项目配置文件：init.properties log4j.properties项目引用jar包：lib/servlet-api.jarlib/log4j-1.2.15.jarlib/commons-collections-3.1.jarlib/commons-logging-1.0.4.jarlib/commons-pool.jarlib/ojdbc14.jar读取配置文件示例：目录结构如下：解决方案I：自定义manifest.mf 文件解释：Manifest-Version: 1.0 版本号，没啥特殊含义，但一定要有；Class-Path: 所有引用的jar包注意：每个“：”后面都要加空格，Class-Path中每个jar包间也加空格最后一行为空行截图如下：b.通过Eclipse 到处jar包右键项目工程----Export -- 选择Java下JAR File，下一步件外部读取），选择导出jar包的位置；注意：右侧的.classpath这些都不要选中，只把src下的java文件打包。

下一步下一步：选中自定义的manifest.mf文件，完成测试：新建项目，导入刚刚生成的jar包和jar需要的所有包（把jar包所在工程lib下所有引用jar拿过来），在src下写入配置文件,目录结构如下：测试：测试结果：这就是方案1，总结：自定义manifest.mf 文件，配置清楚jar所需要的所有lib。

当其他系统引用该jar时，相当于把包拉到系统中（jar的内容相当于系统自定义的），它读取的配置文件就是从系统的classpath下读取。

java 引用外部配置文件的方法

java 引用外部配置文件的方法Java作为一种广泛应用的编程语言，经常需要引用外部配置文件来获取程序的设置参数。

本文将介绍几种常用的方法来实现这个目的。

一、使用Properties类Properties类是Java提供的一个用于处理配置文件的工具类，它可以读取和写入配置文件的键值对。

使用Properties类引用外部配置文件的步骤如下：1. 创建一个Properties对象。

2. 使用load()方法读取配置文件，将配置文件的内容加载到Properties对象中。

3. 使用getProperty()方法根据键名获取配置项的值。

下面是一个示例代码：```javaimport java.io.FileInputStream;import java.io.IOException;import java.util.Properties;public class ConfigReader {public static void main(String[] args) {Properties properties = new Properties();try {FileInputStream fis = newFileInputStream("config.properties");properties.load(fis);fis.close();} catch (IOException e) {e.printStackTrace();}String url = properties.getProperty("url");String username = properties.getProperty("username"); String password = properties.getProperty("password"); System.out.println("url: " + url);System.out.println("username: " + username);System.out.println("password: " + password);}}```在这个例子中，我们使用了一个名为config.properties的配置文件，其中包含了url、username和password三个配置项的值。

springboot 打jar包,配置文件在 jar包外面,的 pom. xml 配置, 修改配置文件,不需要重新打jar包

mvn clean package -Dmaven.test.skip=true -Plinux_prod<build><finalName>xxx</finalName><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><version>2.2</version><configuration><failOnMissingWebXml>false</failOnMissingWebXml><overlays><overlay><groupId>com.hjz</groupId><artifactId>cas</artifactId><excludes><exclude>WEB-INF/lib</exclude></excludes></overlay></overlays></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.6.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding><compilerArguments><extdirs>${project.basedir}/src/main/webapp/WEB-INF/lib</extdirs> </compilerArguments></configuration></plugin></plugins></build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><configuration><executable>true</executable></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-jar-plugin</artifactId><configuration><excludes><exclude>*.properties</exclude><exclude>*.yml</exclude></excludes><archive><manifestEntries><Class-Path>conf/</Class-Path></manifestEntries></archive></configuration></plugin><plugin><artifactId>maven-resources-plugin</artifactId><executions><execution><id>copy-xmls</id><phase>process-sources</phase><goals><goal>copy-resources</goal></goals><configuration><outputDirectory>${basedir}/target/conf</outputDirectory><resources><resource><directory>${basedir}/src/main/resources</directory><includes><include>*/*</include><include>*</include><exclude>ChangeLog.md</exclude></includes></resource></resources></configuration></execution></executions></plugin><plugin><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding><compilerArguments><extdirs>lib</extdirs></compilerArguments></configuration></plugin></plugins>1.<build>2.<plugins>3.<plugin>4.<groupId>org.apache.maven.plugins</groupId>5.<artifactId>maven-war-plugin</artifactId>6.<version>2.1.1</version>7.<configuration>8.<webXml>WebContent\WEB-INF\web.xml</webXml>9.</configuration>10.</plugin>11.</plugins>12.</build>1.<build>2.<plugins>3.<plugin>4.<groupId>org.apache.maven.plugins</groupId>5.<artifactId>maven-war-plugin</artifactId>6.<version>2.1.1</version>7.<configuration>8.9.<webXml>WebRoot\WEB-INF\web.xml</webXml>10.11.<warSourceDirectory>WebRoot</warSourceDirectory>12.</configuration>13.</plugin>14.</plugins>15.</build>分隔符<build><plugins><plugin><groupId>org.mybatis.generator</groupId><artifactId>mybatis-generator-maven-plugin</artifactId><version>1.3.2</version><configuration><verbose>true</verbose><overwrite>true</overwrite></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.6.1</version><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding><compilerArgs><arg>-extdirs</arg><arg>${project.basedir}/lib</arg></compilerArgs></configuration></plugin><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><version>2.1.1</version><configuration><webXml>web\WEB-INF\web.xml</webXml><warSourceDirectory>web</warSourceDirectory><webResources><resource><directory>lib/</directory><targetPath>WEB-INF/lib</targetPath><includes><include>**/*.jar</include></includes></resource></webResources></configuration></plugin></plugins><resources><resource><directory>src/main/java</directory><includes><include>**/*.xml</include></includes></resource><resource><directory>src/main/resources</directory><includes><include>*</include><include>*/*</include></includes></resource></resources></build>。

Java命令行启动jar包更改默认端口以及配置文件的几种方式

Java命令⾏启动jar包更改默认端⼝以及配置⽂件的⼏种⽅式1. java -jar xxx.jar --server.port=80812. java -jar xxx.jar --spring.profiles.active=dev*这种⽅式，你打的jar包⾥得有application-dev.properties或application-dev.yml这类资源⽂件3. java -jar xxx.jar --spring.config.location=D:\Java\application.properties或 java -jar xxx.jar --spring.config.location=D:\Java\application.yml*指定加载某个资源⽂件，也可以使⽤相对路径4. java -jar xxx.jar --spring.config.location=D:\Java\application.properties -Dserver.port=8081 -Dserver.address=127.0.0.1*扩展，你加载的指定配置⽂件⾥的有server.port和server.address配置项例如：我⼯程⾥有mapper\xxx.xml数据库CRUD接⼝映射⽂件，我编译后的⽬录⽂件其实是在target\classes\mapper\xxx.xml当我使⽤指定资源配置⽂件启动的时候，由于我指定的配置⽂件⾥配置的 mapper-locations: classpath:mapper/*.xml是这样的加载路径，调试运⾏时没问题，但是在编译后的⽬标⽬录⾥启动时，就会因为路径不对⽽导致启动失败。

如果我这样启java -jar xxx.jar --spring.config.location=.\classes\application.yml下⾯⼀定会报mybatis-plus相关的⼀些错误，例如找不到映射⽂件之类的那，如果我这样启java -jar xxx.jar --spring.config.location=.\classes\application.yml -Dmybatis-plus.mapper-locations=.\classes\mapper就能正常加载资源配置⽂件并启动成功，其他配置项的加载道理也⼀样。

java读取外部配置文件的方法

java读取外部配置文件的方法在Java中，您可以使用多种方法来读取外部配置文件，这有助于将应用程序配置信息从代码中分离，使得配置更加灵活。

以下是一些常见的方法：1.使用`Properties`类：可以使用Java的`Properties`类来读取键值对形式的配置文件，通常是`.properties`文件。

例如：```javaimport java.io.FileInputStream;import java.io.IOException;import java.util.Properties;public class ConfigReader{public static void main(String[]args){Properties properties=new Properties();try(FileInputStream fileInputStream=newFileInputStream("config.properties")){properties.load(fileInputStream);String value=properties.getProperty("key");System.out.println("Value:"+value);}catch(IOException e){e.printStackTrace();}}}```2.使用`ResourceBundle`类：如果您的配置文件在类路径中，可以使用`ResourceBundle`类来读取配置信息。

这对于国际化和本地化也很有用。

```javaimport java.util.ResourceBundle;public class ConfigReader{public static void main(String[]args){ResourceBundle bundle=ResourceBundle.getBundle("config");String value=bundle.getString("key");System.out.println("Value:"+value);}}```3.使用第三方库：除了标准Java库，您还可以使用第三方库，如Apache Commons Configuration或Typesafe Config，来更灵活地处理配置文件。

SpringBoot把配置文件和日志文件放到jar外部

SpringBoot把配置⽂件和⽇志⽂件放到jar外部如果不想使⽤默认的application.properties，⽽想将属性⽂件放到jar包外⾯，可以使⽤如下两种⽅法：只能设置全路径。

因为Java -jar运⾏jar包时，⽆法指定classpath（⽆论通过参数还是环境变量，设置的classpath都会被覆盖）。

⽅法1：命令⾏传参指定spring.config.locationjava -jar -Dspring.config.location=D:\zTest\config\config1.properties springbootrestdemo-0.0.1-SNAPSHOT.jar还可以⽤spring.config.location指定路径，这样会在这个路径中去寻找application-{profile}.properties。

还可以⽤spring.config.location指定路径，然后⽤指定配置⽂件名字。

可以⽤逗号隔开，指定多个路径和名字⽅法2：使⽤@PropertySource注解。

@SpringBootApplication@PropertySource(value={"file:D:/zTest/config/config1.properties"})public class SpringbootrestdemoApplication {public static void main(String[] args) {SpringApplication.run(SpringbootrestdemoApplication.class, args);}}下⾯看下Spring Boot 配置⽂件和⽇志⽂件放到jar之外1.设置打包jar的时候排除⽂件<resources><resource><directory>src/main/resources</directory><excludes><exclude>*.properties</exclude><exclude>logback.xml</exclude></excludes></resource></resources>2.启动的时候传⼊参数指定位置java -jar xxx.jar --spring.config.location=D:\springconfig\ --logging.config=D:\springconfig\logback.xmlspringboot 默认找配置⽂件的位置如下// Note the order is from least to most specific (last one wins)private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:总结以上所述是⼩编给⼤家介绍的Spring Boot 把配置⽂件和⽇志⽂件放到jar外部，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。

springbootjar包外置配置文件的解决方法

springbootjar包外置配置⽂件的解决⽅法为什么要搞个解决⽅案呢？按照⽹上教程，spring boot项⽬中，配置⽂件有优先级，其中，放在根⽬录下的config⽂件夹中优先级最⾼；根⽬录下次之；然后是resources/config/；resources/下优先级最低。

⽽加载顺序刚好反过来，resources/下最先加载，⽽/config/最后加载。

然后在命令⾏⽅式下，指定⼀下这个配置⽂件的路径，就可以了，云云。

也许事实就是如此的吧，但我试来试去，总不成功，系统死活都要读resources/下，这个优先级最低的配置⽂件。

这对于⽤ jar包⽅式运⾏的项⽬来说，就很痛苦了。

每次部署的时候，都要将⾥⾯的配置⽂件替换，⾮常繁琐。

我不知道为什么我的JAR包⽤不了外置配置⽂件，也许是代码⾥含有@PropertySource(value = "classpath:myconfig.properties",encoding = "UTF-8")这样的语句；⼜或许是含有@Scheduled(cron = "${ins.ship-interval}")这样的语句。

说起来也是⼼累，搞不清这⾥⾯的加载顺序。

⼀时之间没法解决，所以先换⼀种⽅式，每次运⾏系统前，⽤jar命令，将相应的配置⽂件替换jar包⾥的。

命令如下：#将当前⽬录下 BOOT-INF/classes/application.properties 替换 jar包⾥ BOOT-INF/classes/application.properties#这个命令也是醉了，为啥源⽂件与⽬标⽂件路径要⼀致呢，可能是为了简单吧jar uf spider-0.0.1-SNAPSHOT.jar BOOT-INF/classes/application.properties#好了，可以放⼼运⾏了java -jar spider-0.0.1-SNAPSHOT.jar简单粗暴，但还可以⽤。

linux命令中jar的用法

在Linux中，可以使用jar命令来操作JAR包。

以下是jar命令的一些常见用法：1.
解压JAR包：使用以下命令解压JAR包到当前目录：
2.
shell复制代码
jar xvf xxx.jar
其中，xxx.jar是要解压的JAR包的文件名。

2. 压缩文件为JAR包：使用以下命令将当前目录下的文件压缩为JAR包：
shell复制代码
jar cvf0M xxx.jar ./
其中，xxx.jar是要生成的JAR包的文件名。

选项-0M表示只存储不压缩，并且不生成清单文件。

3. 添加文件到JAR包：使用以下命令将指定的文件添加到JAR包中：
shell复制代码
jar uf xxx.jar file.txt
其中，xxx.jar是要添加文件的JAR包的文件名，file.txt是要添加的文件。

4. 添加目录及其内容到JAR包：使用以下命令将指定的目录及其内容全部添加到JAR
包中：
shell复制代码
jar uf xxx.jar aa
其中，xxx.jar是要添加目录的JAR包的文件名，aa是要添加的目录。

以上是jar命令的一些常见用法，可以通过运行jar --help或man jar来获取更多关于jar命令的帮助信息。

java 获取外部jar 包的方法

java 获取外部jar 包的方法实现Java程序中使用外部jar包的方法是非常常见且重要的技能。

使用外部jar包可以大大提高开发效率，使得开发者能够重用他人或自己开发的代码库。

本文将一步一步回答“java获取外部jar包的方法”的主题，并提供具体实例。

第一步：下载外部jar包要使用外部jar包，首先需要从可靠的源下载所需的jar文件。

可以通过直接从开发者的官方网站下载，或通过Maven 或Gradle 这样的构建工具从Maven 存储库中获取。

以使用Apache Commons Lang 作为示例，可以在官方网站上下载jar 文件或使用Maven 添加以下依赖项：xml<dependency><groupId>org.apachemons</groupId><artifactId>commons-lang3</artifactId><version>3.12.0</version></dependency>在Maven 项目中，只需将此依赖项添加到项目的pom.xml 文件中，并执行`mvn clean install` 命令以获取外部jar 包。

第二步：将外部jar包添加到类路径中一旦jar包下载完成，需要将其添加到类路径中，以便在程序中引用。

1. 在IDE 中使用外部jar包：对于大多数现代IDE，如IntelliJ IDEA、Eclipse 或NetBeans，可以通过以下几种方式添加外部jar包：- 将jar文件直接拖放到项目的依赖文件夹中。

- 通过项目的构建路径或模块设置添加外部jar包。

- 在IDE的Maven项目中，通过在pom.xml文件中声明外部jar包的依赖项。

2. 在命令行中使用外部jar包：如果不使用IDE 或希望通过命令行编译和运行程序，可以使用`-classpath` 或`-cp` 参数指定外部jar包的位置。

jar包引用原理

jar包引用原理
当我们需要在项目中使用某个jar包时，首先需要将该jar包引入到项目中。

这样，项目就可以在编译和运行时通过classpath找到并加载该jar包。

在项目中引用jar包的原理如下：
1. 找到需要引用jar包的项目，在项目的构建路径下（如lib
目录）放置该jar包文件。

2. 在项目的构建配置文件中（如pom.xml或build.gradle）添加对该jar包的引用，告诉构建工具在构建项目时要将该jar
包包含进去。

3. 在项目中的源代码中使用import语句导入需要使用的类或方法。

在编译时，构建工具会将项目的源代码和引用的jar包一起编译成可执行文件。

在运行时，项目会将编译后的文件和所需的jar包一起部署到运行环境中。

当项目运行时，classpath会包括项目的目录和引用的jar包的路径，使得项目可以找到并加载所需的jar包。

需要注意的是，jar包可能依赖其他的jar包。

在引用一个jar 包时，如果该jar包依赖其他的jar包，项目也需要将这些依赖的jar包一同引入并配置。

否则，在编译或运行时会出现找不到相关类或方法的错误。

jmeter引入外部jar包的方法

在测试过程中，经常遇到需要引用外部jar包进行数据操作的场景，那么如何引入外部jar包呢？
这里主要有3种引入外部jar包的方法：
方法一、在测试计划处添加外部jar包到ClassPath：
选择测试计划，在测试计划属性设置‘添加目录或jar包到ClassPath'，点击’浏览‘按钮添加jar包；
也可对手动添加的jar包进行删除/清除处理；
方法二、直接将需要引用的jar包放到jmeter的lib或lib/ext目录下，然后重启jmeter
方法三、设置插件依赖路径，此时需要在jmeter.properties中添加依赖jar包的路径jmeter.properties文件在bin目录下，我创建了一个依赖目录dependencies与bin 目录同级，将需要引用到的jar包放到dependencies目录下
进入到bin目录下，打开并编辑jmeter.properties文件，添加依赖包路径为：
plugin_dependency_paths=../dependencies;（这个路径为参照jmeter.properties文件的相对路径）
总结：
方法一可移植性是最弱的，方法二污染了jmeter原有jar包结构，方法三是最推荐的！。

application.properties多环境配置文件、jar包外部配置文件、配置项加。。。

application.properties多环境配置⽂件、jar包外部配置⽂件、配置项加。

⼀、简介spring boot项⽬application.properties⽂件存放及使⽤介绍⼆、⽅法⼀多环境配置⽂件我们⼀般都会有多个应⽤环境，开发环境、测试环境、⽣产环境，各个环境的配置会略有不同，我可以根据这个创建多份配置⽂件，由主配置⽂件来控制读取那个⼦配置创建spring boot项⽬后可以同时创建多个.properties⽂件，只要符合它要求的格式即可格式：application-{profile}.properties；{profile}是变量⽤于⾃定义配置⽂件名称分别创建三个应⽤环境的配置和⼀个主配置1、application.properties 主配置（以下是配置内容，这⾥的dev就是其他配置⽂件的标识名dev、test、prod）# 具体使⽤那个配置⽂件的标识名称（格式：application-{profile}.properties；{profile}是变量⽤于⾃定义配置⽂件名称）spring.profiles.active=dev2、application-dev.properties 开发环境（以下是配置内容）=tyh-demo-prop# 开发环境端⼝server.port=100013、application-test.properties 测试环境（以下是配置内容）=tyh-demo-prop# 测试环境端⼝server.port=100024、application-prod.properties ⽣产环境（以下是配置内容）=tyh-demo-prop# ⽣产环境端⼝server.port=10003更改主配置中的spring.profiles.active=dev这个参数就可以切换不同⼦配置⽂件了由于此⽅法.properties⽂件依然在jar中，我们修改时并不⽅便，⽽且太多信息暴露在开发中容易泄露，所以结合⽅法⼆进⾏使⽤三、⽅法⼆jar包外部配置⽂件我们在开发完成发布⽣产环境时往往都会修改⼀下配置⽂件的相关内容，⽽默认.properties配置⽂件会被封装到jar包中修改起来不⽅便，所以spring boot给了⼏个读取配置⽂件的位置，我们可以通过这个⽅式去从jar包外部修改配置⽂件⼀般我们会将.properties放在resources⽂件夹内spring boot会按以下顺序去寻找配置⽂件1、“当前⽬录”的/config⽂件夹下2、“当前⽬录”下3、classpath的/config⽂件夹下4、classpath下以下是图例解释：当找到配置⽂件后将不会再继续寻找，也就说该⽂件优先级以下的配置⽂件将不会被读取，找到即停⽌“当前⽬录”指的是我们打成可执⾏jar包后，⼀般会⽤bat⽂件来启动，这个当前⽬录指的就是bat⽂件的⽬录我们常规存放的位置就是优先级最低的位置，所以我们只需要再单独拷贝⼀份配置⽂件，放在bat的“当前⽬录”即可四、配置项加密我们的application.properties⽂件中会有很多敏感信息，如：数据库连接、缓存服务器连接等等，这些⽤户名密码都应该是外部不可见的，所以最好将其加密后存储我们使⽤jasypt来进⾏加解密，⾸先先建⽴项⽬，我搭建了spring boot项⽬1、添加pom.xml信息<dependency><groupId>com.github.ulisesbocchio</groupId><artifactId>jasypt-spring-boot-starter</artifactId><version>2.1.0</version></dependency>2、在application.properties⽂件中增加配置项，需要jasypt来解密的密⽂需要⽤“ENC(......)”括起来=tyh-demo-propserver.port=10001# 配置⽂件项加解密密码，此处注释，⽽放在代码中（放在代码中使加密密钥和密⽂分开）#jasypt.encryptor.password=112233# 模拟数据库连接帐号密码ername=ENC(nm3F96GtUIwZUHzsP0Mp1A==)spring.datasource.password=ENC(lmn7lAlePy1hZu505WO0xQ==)3、程序启动类，默认jasypt的密钥是放在配置⽂件中但这样会导致密⽂和密钥都在配置⽂件中，所以我把密钥放在程序中@SpringBootApplicationpublic class App {public static void main(String[] args) {//设置配置⽂件项加密密钥（放在这⾥使加密密钥和密⽂分开）System.setProperty("jasypt.encryptor.password", "112233");SpringApplication.run(App.class, args);}}4、使⽤注解的⽅式来注⼊配置⽂件中的配置项import org.springframework.beans.factory.annotation.Value;import ponent;@Componentpublic class SysConfig {@Value("${ername}")private String dbUsername;@Value("${spring.datasource.password}")private String dbPassword;//⾃⼰⽣成get set⽅法}5、编写controller及action来调⽤⼀下import com.tyh.demo.prop.config.SysConfig;import org.jasypt.encryption.StringEncryptor;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controller@RequestMapping("/test")public class TestController {@AutowiredStringEncryptor encryptor;@ResponseBody@RequestMapping("/index")public String index() {return encryptor.encrypt("taiyonghai");}@AutowiredSysConfig sysConfig;@ResponseBody@RequestMapping("/getConfig")public SysConfig getConfig() {//spring boot⾃动注⼊就会将密⽂解密return sysConfig;}}由于其使⽤的是PBEWithMD5AndDES加密⽅式，所以每次加密出来的结果都不⼀样，所以很适合对数据进⾏加密运⾏后，可以看到⾃动解密的配置项五、配置项注⼊静态static与⾮静态属性我们有很多编码需求需要使⽤.properties⽂件中⾃定义的配置项，传统使⽤Properties对象来操作，类似如下代码，这种⽅式太过灵活我们不想使⽤的配置项可能也会被提取出来，⽽且当我们不想使⽤jar包内的配置⽂件，⽽是利⽤优先级使⽤外部的，这种直接读取的⽅式就很不⽅便，所以推荐使⽤@Value的⽅式来使⽤public class SysConfigUtil {private static Properties props;static {try {// TODO：读取⽤户配置Resource resource = new ClassPathResource("/application.properties");props = PropertiesLoaderUtils.loadProperties(resource);} catch (IOException e) {e.printStackTrace();}}public static String getProperty(String key) {return props == null ? null : props.getProperty(key);}｝还是刚才的项⽬，使⽤@Value来注⼊想让程序使⽤的配置项，⽽不想让程序使⽤的就不注⼊，这样来使配置项可控1、我们在.properties⽂件中增加两个⾃定义配置项=tyh-demo-propserver.port=10001# 配置⽂件项加解密密码，此处注释，⽽放在代码中（放在代码中使加密密钥和密⽂分开）#jasypt.encryptor.password=112233# 模拟数据库连接帐号密码ername=ENC(nm3F96GtUIwZUHzsP0Mp1A==)spring.datasource.password=ENC(lmn7lAlePy1hZu505WO0xQ==)# 模拟其他⾃定义配置项#tyh.url.web.admin=tyh.url.web.agent=2、@Value注⼊可以给静态属性也可以给⾮静态属性，具体根据使⽤场景⾃⾏决定，如果配置项可能不存在也可以设置默认值，避免程序⽆法启动@Componentpublic class SysConfig {@Value("${ername}")private String dbUsername;@Value("${spring.datasource.password}")private String dbPassword;/*⾮静态属性注⼊（注⼊属性）*///@Value的参数代表配置项的key，如果没有启动会报错，加上“:”为其设置默认值即可解决冒号后⾯的就是默认值内容，也可以直接:冒号后⾯空⽩就是空 @Value("${tyh.url.web.admin:}")private String urlAdmin;//###⾃⼰创建get/set⽅法###/*静态属性注⼊（注⼊set()⽅法）*///使⽤@Component把当前类当作组件启动时注⼊该静态属性值，静态属性注⼊set()⽅法public static String urlAgent;@Value("${tyh.url.web.agent:}")private void setUrlAgent(String urlAgent) {SysConfig.urlAgent = urlAgent;}}3、使⽤时⾮静态属性使⽤Autowired注⼊，静态属性直接取值//⾮静态属性注⼊取值（必须使⽤Autowired注⼊）@AutowiredSysConfig sysConfig;public void test() {//静态属性注⼊取值（直接获取）String str = SysConfig.urlAgent;}推荐使⽤@Value来注⼊配置项进⾏使⽤，便与后续接⼊Apollo等配置管理中⼼进⾏配置统⼀管理。

SpringBoot的jar包引用外部properties文件

网络错误421请刷新页面重试持续报错ห้องสมุดไป่ตู้尝试更换浏览器或网络环境
SpringBoot的 jar包引用外部 properties文件
场景是这样的：
使用SpringBoot打包时，配置文件application.properties默认会打包在jar里面，这样如果需要修改的话必须修改了文件并重新压包，比较麻烦
java -jar bootdemo-0.0.1-SNAPSHOT.jar --spring.config.location= /opt/config/test.properties //此时test.properties在绝对目录/opt/config；这种路径可以统一管理配置文件
在网上查看有几种引用外部配置文件的方法，有的放到class目录，有的说是在META里面配置文件路径，但相对来说都不如在启动jar包时将 properties文件路径作为参数传入灵活，如下所示：
java -jar bootdemo-0.0.1-SNAPSHOT.jar --spring.config.location=./test.properties //此时test.properties和jar是同级目录

jar包使用

jar包使⽤JAR包是Java中所特有⼀种压缩⽂档,其实⼤家就可以把它理解为.zip包。

当然也是有区别的,JAR包中有⼀个META-INF\MANIFEST.MF⽂件,当你找成JAR包时,它会⾃动⽣成。

JAR包是由JDK安装⽬录\bin\jar.exe命令⽣成的，当我们安装好JDK，设置好path路径，就可以正常使⽤jar.exe命令，它会⽤lib\tool.jar⼯具包中的类。

这些细节就不⽤管它了。

⼀. jar命令选项：jar命令格式：jar {c t x u f }[ v m e 0 M i ][-C ⽬录]⽂件名...其中{ctxu}这四个选项必须选其⼀。

[v f m e 0 M i ]是可选选项，⽂件名也是必须的。

-c 创建⼀个jar包-t 显⽰jar中的内容列表-x 解压jar包-u 添加⽂件到jar包中-f 指定jar包的⽂件名-v ⽣成详细的报造，并输出⾄标准设备-m 指定manifest.mf⽂件.(manifest.mf⽂件中可以对jar包及其中的内容作⼀些⼀设置)-0 产⽣jar包时不对其中的内容进⾏压缩处理-M 不产⽣所有⽂件的清单⽂件(Manifest.mf)。

这个参数与忽略掉-m参数的设置-i 为指定的jar⽂件创建索引⽂件-C 表⽰转到相应的⽬录下执⾏jar命令,相当于cd到那个⽬录，然后不带-C执⾏jar命令⼆. jar使⽤范例：(1)创建jar包$ jar cf hello.jar hello 利⽤test⽬录⽣成hello.jar包,如hello.jar存在,则覆盖(2)创建并显⽰打包过程$ jar cvf hello.jar hello 利⽤hello⽬录创建hello.jar包,并显⽰创建过程例：E:\>jar cvf hello.jar hello标明清单(manifest)增加：hello/(读⼊= 0) (写出= 0)(存储了 0%)增加：hello/TestServlet2.class(读⼊= 1497) (写出= 818)(压缩了 45%)增加：hello/HelloServlet.class(读⼊= 1344) (写出= 736)(压缩了 45%)增加：hello/TestServlet1.class(读⼊= 2037) (写出= 1118)(压缩了 45%)(3)显⽰jar包$ jar tvf hello.jar 查看hello.jar包的内容指定的jar包必须真实存在，否则会发⽣FileNoutFoundException。