精华内容
下载资源
问答
  • Maven工具类jar包

    2018-11-27 14:48:21
    maven项目jar包,包括Spring+SpringMVC+redis等所需的jar包
  • 支持idea maven项目自动打jar包工具类,方便快捷!!!
  • maven项目中批量导入jar包,使用的是python代码工具类,自己编写的,其中只需要把这个py文件放到jar包的同一个目录下,双击这个py文件即可批量安装,并且生成一个out.xml文件,这个文件复制到pom.xml中即可
  • maven项目编译jar包

    2018-06-29 11:43:58
    通过maven项目中的pom文件进行编译jar包。资源包包括maven3 和编译所需工具
  • 比较常用的Jar包maven比较常用的Jar包不用从中央仓库下载。节省时间
  • maven工具类jar包

    2018-10-30 17:47:33
    项目中经常有比较多的工具类方法,每次使用的时候都是要打开多个项目去找对应的工具方法,或者去网上搜索,太费事,不如自己整个jar包,导入到maven库,即能重复使用,又避免了复制代码。(导jar包里面有个坑,也...

    在项目中经常有比较多的工具类方法,每次使用的时候都是要打开多个项目去找对应的工具方法,或者去网上搜索,太费事,不如自己整个jar包,导入到maven库,即能重复使用,又避免了复制代码。(导jar包里面有个坑,也可能是因为我菜,没有很快找到解决方法)

    1.new project
    2.之后如图

    3.指定groupId 和artifactId以及版本 next
    4.指定项目名称以及存储位置。
    pom 文件

    <?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.abc</groupId>
        <artifactId>framework</artifactId>
        <version>0.0.1</version>
        <packaging>jar</packaging>
    
        <name>framework-auto</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-autoconfigure</artifactId>
            </dependency>-->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <configuration>
                        <archive>
                            <manifest>
                                <addClasspath>true</addClasspath>
                                <useUniqueVersions>false</useUniqueVersions>
                                <classpathPrefix>lib/</classpathPrefix>
                                <mainClass>入口类package.有main方法的类</mainClass>
                            </manifest>
                            <manifestEntries>
                                <version>0.0.1</version>
                            </manifestEntries>
                        </archive>
                    </configuration>
                </plugin>
            	</plugins>
             </build>
    </project>
    

    之后是入口类:

    public class Main {
        public static void main(String[] args) {
            System.out.println("hello jar");
        }
    }
    

    然后是工具类,因为多数项目都是spring boot类型的就是使用注解写了一个例子,并从配置中取值。

    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    
    import java.net.Inet4Address;
    import java.net.InetAddress;
    import java.net.NetworkInterface;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.Map;
    
    @ConfigurationProperties(prefix = "sms")
    @Configuration
    public class SmsSendUtil {
    
        private static final Logger logger = LoggerFactory.getLogger(SmsSendUtil.class);
    
        private String appKey;
    
        public String getAppKey() {
            return appKey;
        }
    
        public void setAppKey(String appKey) {
            this.appKey = appKey;
        }
    
        /**
         * 获取主机ip
         * @return
         * @throws Exception
         */
        public String getIpAddress() throws Exception{
            if (StringUtils.isBlank(appKey)){
                throw new Exception("没有配置sms.appKey");
            }
            Enumeration allNetInterfaces = NetworkInterface.getNetworkInterfaces();
            while (allNetInterfaces.hasMoreElements()){
                NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
    //            System.out.println(netInterface.getName());
                Enumeration addresses = netInterface.getInetAddresses();
                InetAddress ip = null;
                while (addresses.hasMoreElements()){
                    ip = (InetAddress) addresses.nextElement();
                    if (ip != null && ip instanceof Inet4Address){
                        //剔除 127.0.0.1 和作为网关的.1 地址
                        if (!ip.getHostAddress().startsWith("127") && !ip.getHostAddress().endsWith(".1")){
                            return ip.getHostAddress();
                        }
                    }
                }
            }
            return "";
        }
    
    }
    

    之后是(双击666)
    在这里插入图片描述

    最后执行mvn install 命令,把生成的jar导入到本地库中。

    引用时在pom文件中加入

    <dependency>
        <groupId>com.abc</groupId>
        <artifactId>framework</artifactId>
        <version>0.0.1</version>
    </dependency>
    

    测试类:

    @RestController
    @RequestMapping("/test")
    public class TestContrller {
    
    
        @Resource
        private CoreProperties coreProperties;
        @Resource
        private SmsSendUtil smsSendUtil;
    
    
        @RequestMapping(value = {"/",""})
        public String hellTask() throws Exception {
            String userName = coreProperties.getAppKey();
            System.out.println("========================================");
            String ipAddress = smsSendUtil.getIpAddress();
            return "hello " + userName + "ip" + ipAddress;
        }
    
    }
    

    application.properties

    sms.appKey=ajlfjafl
    

    (主要的坑在pom文件,导出了好几次都是没有依赖包,调用工具类方法时,直接报类找不到异常)

    展开全文
  • 免费maven项目用到的json的jar包。什么不懂的在下面留言问我,反正我时间多,亲测可用,我说这些就是为了凑够100个字
  • 现在开发基本都是使用springboot项目,打包直接使用springboot自带的插件就可以了,有时候需要普通的maven项目,默认package命令成的jar包只包含项目的class文件,不包括其他依赖的jar包,因为需要通过第三方...

    前言

    现在开发基本都是使用springboot项目,打包直接使用springboot自带的插件就可以了,有时候需要打普通的maven项目,默认package命令打成的jar包只包含项目的class文件,不包括其他依赖的jar包,因为需要通过第三方插件来完成带依赖包的可执行的jar包。

    参考链接

    Maven构建可执行的jar包(包含依赖jar包)之maven-assembly-plugin介绍
    maven打包常用的几个插件

    方式一

    通过maven-dependency-plugin插件和maven-jar-plugin来组合,maven-jar-plugin其实是maven项目自带的,在pom文件里面不依赖也是可以的,但是我需要修改一些其他属性,比如把lib添加到addClasspath下面,classpathPrefix设置前缀,mainClass方法指定运行的主方法,这样打包之后在jar里面的MANIFEST.MF里面就会有自动把lib包下面的依赖包自动添加进去,然后把可执行的jar包和lib文件夹放在同一个目录下面就可以自动读取到lib里面的jar包了,要想在同目录下面生成lib目录,就需要依靠第二个插件maven-dependency-plugin,这个插件就是把maven项目在pom文件里面依赖的jar包全部放到指定的目录下面去,比如这里的例子就是把依赖包全部输出到${project.build.directory}/lib,其中的${project.build.directory}是maven环境自带的内置变量。
    在这里插入图片描述
    最后打包之后就是这样的。
    在这里插入图片描述

    <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>2.10</version>
                    <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-jar-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <addClasspath>true</addClasspath>
                                <classpathPrefix>lib</classpathPrefix>
                                <mainClass>com.xx.base.Syn</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
    

    方式二

    maven-assembly-plugin插件直接把所有的jar包解压之后打成一个大的jar包,但是这样可能会存在类冲突,小项目还能玩玩,大项目估计不行,虽然可以通过排除的方式剔除相关的class文件,但是总感觉很麻烦,可以试试。

     <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>3.1.0</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>com.xx.base.Syn</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    

    打成jar包之后是这样的,所有依赖包的class文件都被解压放到一起了
    在这里插入图片描述

    方式三

    maven-shade-plugin这个插件和第二个插件感觉没啥两样。

    <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.3</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <transformers>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <!--指定main方法-->
                                        <mainClass>com.xx.base.Syn</mainClass>
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
    

    总结

    试下来感觉方法一比较好。

    展开全文
  • BeanUtils工具类Jar包

    2018-12-28 20:17:12
    commons-beanutils-1.8.3.jar commons-logging-1.1.1.jar
  • 使用maven项目打jar包

    万次阅读 2016-05-02 22:29:53
    <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/maven-v4_0_0.xsd

     

    <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/maven-v4_0_0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    
    	<parent>
    		<groupId>wusc.edu.common</groupId>
    		<artifactId>edu-common-parent</artifactId>
    		<version>1.0-SNAPSHOT</version>
    		<relativePath>../edu-common-parent</relativePath>
    	</parent>
    
    
    	<groupId>wusc.edu.service</groupId>
    	<artifactId>edu-service-user</artifactId>
    	<version>${edu-service-user.version}</version>
    	<packaging>jar</packaging>
    
    
    	<name>edu-service-user</name>
    	<url>http://maven.apache.org</url>
    
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<log4j.leve>debug</log4j.leve>
    		<log4j.ale>debug</log4j.ale>
    	</properties>
    
    
    	<build>
    		<finalName>edu-service-user</finalName>
    
    
    		<resources>
    		        <!-- 把src/main/resources下的包括xml和properties的文件复制到target/classes下 -->
    			<resource>
    				<targetPath>${project.build.directory}/classes</targetPath>
    				<directory>src/main/resources</directory>
    				<filtering>true</filtering>
    				<includes>
    					<include>**/*.xml</include>
    					<include>**/*.properties</include>
    				</includes>
    			</resource>
    
    
    			<!-- 把src/main/resources/spring下的spring-context.xml
    			文件复制到target/classes/META-INF/spring下 -->
    			<resource>
    				<targetPath>${project.build.directory}/classes/META-INF/spring</targetPath>
    				<directory>src/main/resources/spring</directory>
    				<filtering>true</filtering>
    				<includes>
    					<include>spring-context.xml</include>
    				</includes>
    			</resource>
    		</resources>
    
    
    		<pluginManagement>
    			 <!--这个插件没看懂  似乎和eclipse与mavan生命周期冲突相关  -->
    			<plugins>
    				<plugin>
    					<groupId>org.eclipse.m2e</groupId>
    					<artifactId>lifecycle-mapping</artifactId>
    					<version>1.0.0</version>
    					<configuration>
    						<lifecycleMappingMetadata>
    							<pluginExecutions>
    								<pluginExecution>
    									<pluginExecutionFilter>
    										<groupId>org.apache.maven.plugins</groupId>
    										<artifactId>maven-dependency-plugin</artifactId>
    										<versionRange>[2.0,)</versionRange>
    										<goals>
    											<goal>copy-dependencies</goal>
    										</goals>
    									</pluginExecutionFilter>
    									<action>
    										<ignore />
    									</action>
    								</pluginExecution>
    							</pluginExecutions>
    						</lifecycleMappingMetadata>
    					</configuration>
    				</plugin>
    			</plugins>
    		</pluginManagement>
    		<plugins>
    			 <!--打jar包范围是rarget/classes  启动类是 com.alibaba.dubbo.container.Main  -->
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-jar-plugin</artifactId>
    
    
    				<configuration>
    					<classesDirectory>target/classes</classesDirectory>
    					<archive>
    						<manifest>
    							<!-- 不记录版本号 -->
    							<useUniqueVersions>false</useUniqueVersions>
    
    
    							<addClasspath>true</addClasspath> 
    							<classpathPrefix>lib/</classpathPrefix>
    							<mainClass>com.alibaba.dubbo.container.Main</mainClass>
    						</manifest>
    						<manifestEntries>
    							<Class-Paht>.</Class-Paht>
    						</manifestEntries>
    					</archive>
    				</configuration>
    			</plugin>
    
    
    			<!--打jar包 项目本身的依赖包放在lib文件夹下
    			(lib与生成的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>
    							<type>jar</type>
    							<includeTypes>jar</includeTypes>
    							<useUninqeVersions>false</useUninqeVersions>
    							<outputDirectory>
    								${project.build.directory}/lib
    							</outputDirectory>
    						</configuration>
    					</execution>
    
    
    				</executions>
    			</plugin>
    		</plugins>
    
    
    
    
    
    
    	</build>
    
    
    	<dependencies>
    
    
    		<!-- dubbo 需要的jar start -->
    		<dependency>
    			<groupId>org.jboss.netty</groupId>
    			<artifactId>netty</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>dubbo</artifactId>
    			<exclusions>
    				<exclusion>
    					<groupId>org.springframework</groupId>
    					<artifactId>spring</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    
    
    	</dependencies>
    
    
    </project>


     


    第二种方式

    <pre name="code" class="html"><plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-shade-plugin</artifactId>  
        <version>1.2.1</version>  
        <executions>  
            <execution>  
                <phase>package</phase>  
                <goals>  
                    <goal>shade</goal>  
                </goals>  
                <configuration>  
                    <transformers>  
                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
                            <mainClass>com.juvenxu.mvnbook.helloworld.HelloWorld</mainClass>  
                        </transformer>  
                    </transformers>  
                </configuration>  
            </execution>  
        </executions>  
    </plugin>  

    运行mvn install 后 会在target下生成两个jar包

     

    original-xxx-0.0.1-snapshot.jar 这里面只有我们自己写的java代码的class文件

    xxx-0.0.1-snapshot.jar 这里面我们依赖的jar包(会抽出里面的class文件)会和我们的代码放在一块

    如下:


    toyprogram里面放的是我们自己写的java代码的class文件

    spring就放在org里面

     

     

    还有一种方式

     

    <plugin>  
                <artifactId>maven-assembly-plugin</artifactId>  
                <configuration>  
                    <appendAssemblyId>false</appendAssemblyId>  
                    <descriptorRefs>  
                        <descriptorRef>jar-with-dependencies</descriptorRef>  
                    </descriptorRefs>  
                    <archive>  
                        <manifest>  
                            <mainClass>abc.ef.sdf</mainClass>  
                        </manifest>  
                    </archive>  
                </configuration>  
                <executions>  
                    <execution>  
                        <id>make-assembly</id>  
                        <phase>package</phase>  
                        <goals>  
                            <goal>assembly</goal>  
                        </goals>  
                    </execution>  
                </executions>  
    </plugin>  


    然后在pom文件上右键 run as->maven assembly:assembly
    之后在pom的同级目录里会生成你所需要的jar

     

    不知道怎么回事,我的myeclipse里没有maven assembly:assembly

    不过可以这样run build... 然后

     

     

    参考资料

    http://www.blogjava.net/qileilove/articles/410887.html

    http://www.cnblogs.com/justinzhang/p/4983633.html

    展开全文
  • maven打包可执行的jar包-包含依赖jar

    千次阅读 2020-12-30 15:54:20
    maven打包可执行的jar包:1. 首先确保编辑器里maven环境正常2. 运行打包的jar文件3. 测试添加依赖后打包。4. 注意cmd命令传入中文参数乱码 1. 首先确保编辑器里maven环境正常 我这里已经有现成的maven环境和工具类了...

    1. 首先确保编辑器里maven环境正常

    我这里已经有现成的maven环境和工具类了,这里先使用myeclipse先测试一下maven打包,不包含任何依赖,只包含一个类,里面定义main函数。

    public class TestJarApplication{
    
    	public static void main(String[] args) {
    		for (int i = 0; i < args.length; i++) {
    			System.out.println(args[i]);
    		}
    		System.out.println("Hello World!!!!!");
    	}
    }
    

    pom文件内容为:

    <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.lin</groupId>
      <artifactId>test-maven-01</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      
        <!-- 指定maven编译方式为jdk1.8版本 -->
    	<profiles>
    		<profile>
    			<activation>
    				<activeByDefault>true</activeByDefault>
    				<jdk>1.8</jdk>
    			</activation>
    			<properties>
    				<maven.compiler.source>1.8</maven.compiler.source>
    				<maven.compiler.target>1.8</maven.compiler.target>
    				<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    			</properties>
    		</profile>
    	</profiles>
      
    	<build>
            <plugins>
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                        <archive>
                            <manifest>
                                <mainClass>com.lin.TestJarApplication</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>
    

    这里使用maven-assembly-plugin打jar包配置文件(含主类设置),并且如果pom文件里面包含依赖,可将依赖一块打入jar包里面,可在外部直接使用java -jar XXX.jar 运行。

    之后右键项目名,使用run as --> maven install

    [INFO] Scanning for projects...
    [INFO]                                                                         
    [INFO] ------------------------------------------------------------------------
    [INFO] Building test-maven-01 0.0.1-SNAPSHOT
    [INFO] ------------------------------------------------------------------------
    [INFO] 
    [INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ test-maven-01 ---
    [WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
    [INFO] Copying 0 resource
    [INFO] 
    [INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ test-maven-01 ---
    [INFO] Nothing to compile - all classes are up to date
    [INFO] 
    [INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ test-maven-01 ---
    [WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
    [INFO] Copying 0 resource
    [INFO] 
    [INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ test-maven-01 ---
    [INFO] Nothing to compile - all classes are up to date
    [INFO] 
    [INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ test-maven-01 ---
    [INFO] 
    [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ test-maven-01 ---
    [INFO] 
    [INFO] --- maven-assembly-plugin:2.2-beta-5:single (default) @ test-maven-01 ---
    [INFO] Building jar: D:\MyEclipse-WorkSpace\test-maven-01\target\test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar
    [INFO] 
    [INFO] --- maven-install-plugin:2.4:install (default-install) @ test-maven-01 ---
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\target\test-maven-01-0.0.1-SNAPSHOT.jar to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT.jar
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\pom.xml to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT.pom
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\target\test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 1.957 s
    [INFO] Finished at: 2020-12-30T15:10:06+08:00
    [INFO] Final Memory: 12M/232M
    [INFO] ------------------------------------------------------------------------
    
    

    BUILD SUCCESS 表示maven打包成功。
    此时,项目的target文件夹下会生成两个jar包,一个是只包含项目编译后的class文件的test-maven-01-0.0.1-SNAPSHOT.jar,一个是带有依赖的test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar
    在这里插入图片描述
    从文件名上也可以区分出来,目前由于还没有依赖,所以这俩jar里面的内容是一样的,可以分别解压看下。

    2. 运行打包的jar文件

    接着来运行一下打包的jar,看下是否正常。
    test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar拷贝到新的文件夹E:\jar\test-jar下。
    打开cmd命令,切换到E:\jar\test-jar执行java -jar test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar 正常会输出Hello World !,由于main函数里面添加了输出启动命令的参数,可在命令后面添加动态参数,可以传入jar里面运行。
    在这里插入图片描述

    3. 测试添加依赖后打包。

    由于这次编写工具jar是为了处理excel文件的,这里就加了poi和easyExcel的依赖。

    完整的pom文件内容为:

    <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.lin</groupId>
    	<artifactId>test-maven-01</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    
    	<dependencies>
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>easyexcel</artifactId>
    			<version>2.2.6</version>
    			<!-- <version>1.0.4</version> -->
    		</dependency>
    
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>1.2.12</version>
    		</dependency>
    
    		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.11</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.apache.poi</groupId>
    			<artifactId>poi</artifactId>
    			<version>3.10-FINAL</version>
    		</dependency>
    	</dependencies>
    
    	<!-- 指定maven编译方式为jdk1.8版本 -->
    	<profiles>
    		<profile>
    			<activation>
    				<activeByDefault>true</activeByDefault>
    				<jdk>1.8</jdk>
    			</activation>
    			<properties>
    				<maven.compiler.source>1.8</maven.compiler.source>
    				<maven.compiler.target>1.8</maven.compiler.target>
    				<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    			</properties>
    		</profile>
    	</profiles>
    
    	<build>
    		<plugins>
    			<plugin>
    				<artifactId>maven-assembly-plugin</artifactId>
    				<executions>
    					<execution>
    						<phase>package</phase>
    						<goals>
    							<goal>single</goal>
    						</goals>
    					</execution>
    				</executions>
    				<configuration>
    					<descriptorRefs>
    						<descriptorRef>jar-with-dependencies</descriptorRef>
    					</descriptorRefs>
    					<archive>
    						<manifest>
    							<!-- 这里定义程序运行的入口 -->
    							<mainClass>com.lin.TestJarApplication</mainClass>
    						</manifest>
    					</archive>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    </project>
    

    再次使用maven install,则可以看到控制台在编译结束后,会将依赖打入jar包里面。
    在这里插入图片描述
    最后是:

    [INFO] META-INF/LICENSE.txt already added, skipping
    [INFO] META-INF/NOTICE.txt already added, skipping
    [INFO] 
    [INFO] --- maven-install-plugin:2.4:install (default-install) @ test-maven-01 ---
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\target\test-maven-01-0.0.1-SNAPSHOT.jar to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT.jar
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\pom.xml to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT.pom
    [INFO] Installing D:\MyEclipse-WorkSpace\test-maven-01\target\test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar to D:\maven\LocalMavenRepository\com\lin\test-maven-01\0.0.1-SNAPSHOT\test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 14.721 s
    [INFO] Finished at: 2020-12-30T15:25:21+08:00
    [INFO] Final Memory: 31M/762M
    [INFO] ------------------------------------------------------------------------
    

    对比下两次打包后,jar文件的大小,差别就很明显了。
    在这里插入图片描述
    用好压打开两个jar对比:
    在这里插入图片描述
    此时才算完整的将工具打包完成。

    工具有了,但是执行的时候,每次都要输入一串命令,还是不太方便,那就来个bat脚本执行。

    在jar包同一文件夹下新建run.bat文件,内容如下:

    @echo off
    
    java -jar test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.jar E:/jar/bat-jar/GA-kqtj.xls
    
    pause
    

    这里@echo off表示不将命令输出到屏幕上
    java -jar是我们执行jar的命令。
    pause 是运行结束不自动关闭窗口。

    双击运行 run.bat,即可自动运行工具类,同时输出动态参数。
    在这里插入图片描述

    4. Unable to access jarfile test-maven-01-0.0.1-SNAPSHOT-jar-with-dependencies.

    java -jar 命令行中jar的路径有误时,会提示此异常。如果没有写绝对路径,则默认会从当前命令行所在文件夹查找该jar文件,如果jar文件路径不存在,则抛出异常。

    这时只需要检查运行当前jar的命令或者脚本,是否使用了相对路径,并且相对路径是否正确。

    5. 注意cmd命令传入中文参数乱码

    但是此时还有一个问题,就是cmd命令行传入的参数中包含中文时,在main函数中取到的就是乱码了,搜了下发现网上有人说在批处理命令里面添加chcp 65001,发现用了之后不好使。最后还是直接在main方法里面,对输入的参数重新UTF-8编码:arg.getBytes(),"utf-8"),然后就可以正常显示了。

    	public static void main(String[] args) {
    		String arg = "";
    		for (int i = 0; i < args.length; i++) {
    			arg = args[i];
    			try {
    				System.out.println(new String(arg.getBytes(),"utf-8"));
    			} catch (UnsupportedEncodingException e) {
    				e.printStackTrace();
    			}
    		}
    		System.out.println("Hello World !");
    	}
    

    在这里插入图片描述

    展开全文
  • JSONObject对象相关的jar包依赖,一共有6个;还有maven环境下管理的jar包
  • 这里我们了来说说 将maven 项目打包成一个 jar包工具类用 首先就是点开File 然后点击 Project Structure... 进去后直接点击Artifacts ,然后点击 “+” 号 如图操作 然后出现以下画面,点击OK就可以了。 ...
  • maven项目打包jar给其他项目pom引用和外部引用 在现实开发过程中,很多代码需要被重复...第一步 创建maven项目,完成工具类打包jar 我这里用的工具idea,其他方式创建maven项目也一样。 这里我们选择maven-archety...
  • idea把工具类打Jar包

    万次阅读 2018-09-25 18:47:27
    转载于: ...一、生成不带Manifest文件的Jar(不可以直接执行Jar) 1,首先打开Project Structure(Command+;)然后选择左边的Artifacts,再点上方的“+”号,来新建一个Artifact(按照Maven的说...
  • 将自己的写的工具类项目右键导出jar文件保存到自己设置的目录中 打开cmd命令框输入并执行一下内容 mvn install:install-file -DgroupId=...
  • excel工具类jar包

    2018-09-17 14:00:58
    excel工具类jar包maven依赖,用于对excel的读写操作
  • 最近做了个微信支付,我决定将其jar包方便以后再用, ** 第一步:点击箭头所指按钮,或者点到项目名上按F12都行 第二步: 第三步:自定义jar的名字 第四步:勾选箭头指向的选项,然后点击绿色加号,选择...
  • 自定义jar包较多时导入到maven本地仓库不方便,此工具类可以自动将jar包导入到maven本地仓库并自动生成dependency,用的是java语言
  • 今天为了让一些第三方引用的类跳过代码检测,减少代码量将一些工具类和非业务代码大道jar包中,并在项目中引用 1、打开项目 project structure 2、新建要打包的内容 自己指定名字 3、选择要打包内容目录 ...
  • 项目中需要临时在maven中导入一个本地的jar,开始是在maven中这样配置的:&lt;dependency&gt; &lt;groupId&gt;com.dtdream.dthink&lt;/groupId&gt; &lt;artifactId&gt;uim-mock-...
  • 提供了非常多实用的功能,包括了智能代码助手、代码自动提示、代码重构、各种插件等,当然也集成了maven,正常情况下,我们创建maven项目时,相关的jar包会自动导入,当然我们也可以通过IDEA右侧的maven工具来实现...
  • maven项目中批量导入jar包

    千次阅读 2020-03-23 17:51:21
    maven项目中批量导入jar包,使用的是python代码工具类,自己编写的,其中只需要把这个py文件放到jar包的同一个目录下,双击这个py文件即可批量安装,并且自动生成一个out.xml文件,这个文...
  • [Maven]Maven构建可执行的jar包(包含依赖jar包)-----------------------------------------------------------------原创博文,如需转载请注明出处!博主:疲惫的豆豆链接:...
  • IDEA+Maven install可运行jar包一、用途二、配置Maven编译插件1、新建mavan项目2、引入maven配置三、注意事项 一、用途 简单直接的想法就是想通过出来的jar能够直接java -jar 运行,主要是想做一些小的工具运行...
  • 代码里的注释是肯定有的,只不过其他项目依赖jar包的时候由于下载不到源码,所以注释也显示不了,只能看下反编译的代码,或者两个项目切换着看注释,很是麻烦。 因此就研究了下怎么把源码也一起发布到maven仓库里。...
  • 工程采用IDEA作为开发工具,通过spring-boot-maven-plugin插件进行打包。在与工程相应的pom.xml文件添加了该插件之后,当运行“mvn package”进行打包时,会打包成一个可以直接运行的 jar文件,使用“java -jar”...
  • Maven工程生成源码包jar包

    千次阅读 2019-05-16 11:27:58
    有时候开发一个公共jar包给别人引用,当别人打开包中的的时候,默认情况下是IDE工具反编译出来的.class文件,中的注释什么的都看不到,此时IDE工具会提示你可以Download sources,但是如果你打包的时候没有同时...
  • 之前前几周遇到开发过程中遇到这样一种这样的问题,不知道大家有没有遇到过,就是我在spring boot中使用mave将项目打包成jar包部署到linux服务器上后,当我运行一个接口时,居然报错了,这里我贴出来给大家看下,如...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,616
精华内容 28,646
关键字:

maven工具类项目打jar包