精华内容
下载资源
问答
  • 一个web项目做成jar包给另一个web项目使用,但是另一个项目引用该jar的时候出现问题,tomcat可以启动,但是网页访问报404,如果把jar去掉,项目是正常的,做成jar包的项目本身没有问题,现在是做成jar的时候有问题...
  • 最近在研究maven,但是一直有个问题困扰着我,怎么把两个Maven项目打成一个jar包,求告知
  • 在大约一个月前,我的leader收到了一个来自之前项目人员的求助,也就是一个项目加了新的jar包后,要运行的类还是默认使用之前jar包中的类,因为怕程序出问题,所以不能删除,因为当时比较忙,也就没有理会,草草的...

    项目存在两个有相同类的jar包会发生什么

    首先不会炸,我也自己试验了一下,如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    看图有点枯燥么,上代码!!!

    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		TestUse t = new TestUse();
    		t.say();
    	}
    
    }
    

    这代码应该不是很烧脑,也就是我调用了一下jar包的方法,会是什么结果呢,我当时也好奇,可是结果没啥有意思的,唉,如下:

    这是第一个jar包
    

    一个月前确实不知道为什么,只能大概想到这个结果是不确定的,但是代码怎么能有不确定性呢!
    首先呢,我们自己写的类,或是jarbao中的类都是由AppClassLoader加载的(系统类加载器),光说无评是不行的,如下
    在这里插入图片描述
    类加载器加载的过程或许很高级,但是类加载器去找到要加载的类的时候我猜测也无非就是遍历加载路径下的文件(纯属猜测),所以在第一次找到这个类的时候,也就加载了该类,不会再去寻找还有没有,这就和jdk无关了,你要是非搞这种有歧义的事情,jvm才不会管你,你自己玩去吧,哈哈,所以结果就是因为jvm不关心。
    ps:本例需要使用之前博客的自定义类加载器,点击这里跳转查看

    正题

    相信大家如果看了之前的博客的类加载器,会发现那个加载器只能去加载本地单纯的文件,并不支持加载jar包中的文件,所以修改了一点点,单纯的为了这个修改的,所以比较潦草。

    private byte[] loadClassData(String name) {
            InputStream is = null;
            byte[] data = null;
            ByteArrayOutputStream baos = null;
            try {
                name = name.replace(".", "\\");
                try {
                	is = new FileInputStream(new File(this.path + name + this.fileExtension));
    			} catch (Exception e) {
    				// 如果path是jar包的路径,那么上述方法不能加载成功,抛出异常后执行此处的方法。
    				JarFile jar = new JarFile(this.path);
    				//
    				is = jar.getInputStream(jar.getEntry(name.replace("\\", "/") + this.fileExtension));
    			}
                
                baos = new ByteArrayOutputStream();
                int ch = 0;
                while (-1 != (ch = is.read())) {
                    baos.write(ch);
                }
                data = baos.toByteArray();
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                try {
                    is.close();
                    baos.close();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            return data;
        }
    

    只修改了这一个方法,具体修改的也就是:

    try {
                	is = new FileInputStream(new File(this.path + name + this.fileExtension));
    			} catch (Exception e) {
    				// 如果path是jar包的路径,那么上述方法不能加载成功,抛出异常后执行此处的方法。
    				JarFile jar = new JarFile(this.path);
    				//
    				is = jar.getInputStream(jar.getEntry(name.replace("\\", "/") + this.fileExtension));
    			}
    

    如果不是要加载的路径实在jar包中,按照之前所写的那么路径的名字可能像C:/file/xwb/me.jar/com/wenbin/TestUse.class这不报错天理难容啊,所以就捕获并按照jar的方式去取一下class文件。如果不了解类加载器,CSDN中也有许多好的文章。
    怎么同时加载两个类

    package com.xu.test;
    
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.util.Enumeration;
    
    import com.xu.classloader.MyClassLoader;
    
    public class Main {
    	public static void main(String[] args) throws Exception {
    		ClassLoader classloader = Thread.currentThread().getContextClassLoader();
    		//以及下面两种方式都可以获取AppCLassLoader,用这个显得高级 0.0
    		//classloader = Main.class.getClassLoader();
    		//classloader = ClassLoader.getSystemClassLoader();
    		
    		// 获取所有TestUse得到路径
    		Enumeration<URL> urls = classloader.getResources("com/wenbin/TestUse.class");
    		while (urls.hasMoreElements()) {
    			URL url = (URL) urls.nextElement();
    			String fullPath = url.getPath();
    			String[] strs = fullPath.split("!");
    			// 获取文件的路径以及文件名
    			String path = strs[0].replace("file:/","");
    			String fileName = strs[1].substring(1).replace(".class", "").replace("/", ".");
    			// 如果这里不设置自定义加载器的父加载器为null,根据双亲委托机制就是由AppClassLoader加载该类,因为我们的path下有这个类的jar包
    			// 那么在第一次加载之后就会存在com.wenbin.TestUse的Class,那么第二次再去加载时已经存在这个Class,所以就不再次加载,也就是我们
    			// 所做的一切都是徒劳的,把加载器的父加载器值设置为空以后,由本身去加载,按照上一个博客所说,两个加载器的命名空间不同,所以是不
    			// 可见的,所以这两个相同包名类名的类,会分为两次加载。
    			// MyClassLoader loader = new MyClassLoader("loader");
    			MyClassLoader loader = new MyClassLoader(null,"loader");
    			loader.setPath(path);
    			Class<?> clazz = loader.loadClass(fileName);
    
    			// JDK1.8及之前的是clazz.newInstance();
    			Object obj = clazz.getDeclaredConstructor().newInstance();
    			Method method = clazz.getMethod("say", null);
    			method.invoke(obj, null);
    			
    		}
    	}
    }
    
    

    结果

    这是第一个jar包
    这是第二个jar包
    

    代码大致的过程我也写到了注释中,很简单,获取路径什么的看一眼就知道咋回事了也就不多说了,重点在这里重新说一下:

    MyClassLoader loader = new MyClassLoader("loader");																			
    MyClassLoader loader = new MyClassLoader(null,"loader");
    

    第一行也就是把AppClassLoader作为自定义类加载器的父加载器根据双亲委托机制,自己不加载委托给父加载器加载,那么问题就来了,在我们的项目中是存在jar包的,所以AppClassLoader会进行加载,因为有两个类所以循环两次,在第二次加载的时候,因为已经加载过相同包名类名的类,那么就不会再一次,而是直接拿过来通过反射实例对象,所以不管你多少次,都是加载的同一个Class。双亲委托机制就不要去CSDN到处找了,挺累的,我上面提到的博客中就有,欢迎点击。所以我把父加载器赋值为空,那么父加载器没有能力去加载这个类,也就有我们自定义加载器,去指定的jar包中,找指定的类。这时候可能会问,为什么自定义类加载器就能加载同包名同类名的类
    说到这里,欢迎大家点击这篇博客命名空间也正是命名空间的作用两个自定义类加载器是彼此不可见的,所以就可以加载多次。哇,好累哈,终于完事了,说的可能不是很仔细,所以需要大家多了解一些类加载器的东西就可以啦,我们改日见,休息啦~。
    对啦再说一句,回到一开始,我们leader朋友的这个问题怎么解决,当然通过简单残暴IF就可以。代码如下:

    package com.xu.test;
    
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.util.Enumeration;
    
    import com.xu.classloader.MyClassLoader;
    
    public class Main {
    	public static void main(String[] args) throws Exception {
    		ClassLoader classloader = Thread.currentThread().getContextClassLoader();
    		//以及下面两种方式都可以获取AppCLassLoader,用这个显得高级 0.0
    		//classloader = Main.class.getClassLoader();
    		//classloader = ClassLoader.getSystemClassLoader();
    		
    		// 获取所有TestUse得到路径
    		Enumeration<URL> urls = classloader.getResources("com/wenbin/TestUse.class");
    		while (urls.hasMoreElements()) {
    			URL url = (URL) urls.nextElement();
    			String fullPath = url.getPath();
    			String[] strs = fullPath.split("!");
    			// 获取文件的路径以及文件名
    			String path = strs[0].replace("file:/","");
    			String fileName = strs[1].substring(1).replace(".class", "").replace("/", ".");
    			// 如果这里不设置自定义加载器的父加载器为null,根据双亲委托机制就是由AppClassLoader加载该类,因为我们的path下有这个类的jar包
    			// 那么在第一次加载之后就会存在com.wenbin.TestUse的Class,那么第二次再去加载时已经存在这个Class,所以就不再次加载,也就是我们
    			// 所做的一切都是徒劳的,把加载器的父加载器值设置为空以后,由本身去加载,按照上一个博客所说,两个加载器的命名空间不同,所以是不
    			// 可见的,所以这两个相同包名类名的类,会分为两次加载。
    			// MyClassLoader loader = new MyClassLoader("loader");
    			// 重点																							
    			MyClassLoader loader = new MyClassLoader(null,"loader");
    			loader.setPath(path);
    			if(path.contains("me2.jar")) {
    			Class<?> clazz = loader.loadClass(fileName);
    
    			// JDK1.8及之前的是clazz.newInstance();
    			Object obj = clazz.getDeclaredConstructor().newInstance();
    			Method method = clazz.getMethod("say", null);
    			method.invoke(obj, null);
    			}
    		}
    	}
    }
    
    

    结果

    这是第二个jar包
    

    so,see you。。。

    展开全文
  • 一个maven项目中有多个类有main方法,打出多个jar包使这些jar包有不同的主函数 解决 方式一:通过多个pom文件打包 比如再写一个pom2.xml,使用命令 mvn install -f pom2.xml 指定pom文件进行打包 方式二:通过...

    需求

    一个maven项目中有多个类有main方法,一次打出多个jar包使这些jar包有不同的主函数

    解决

    方式一:通过多个pom文件打包

    比如再写一个pom2.xml,使用命令 mvn install -f pom2.xml 指定pom文件进行打包

    方式二:通过maven-assembly-plugin

    案例:

    <plugin>
    	<artifactId>maven-assembly-plugin</artifactId>
    	<executions>
    		<execution>
    			<id>jar1</id>
    			<configuration>
    				<finalName>jar1</finalName>
    				<archive>
    					<manifest>
    						<mainClass>com.test.Test</mainClass>
    					</manifest>
    				</archive>
    				<descriptorRefs>
    					<descriptorRef>jar-with-dependencies</descriptorRef>
    				</descriptorRefs>
    			</configuration>
    			<phase>install</phase>
    			<goals>
    				<goal>assembly</goal>
    			</goals>
    		</execution>
    		<execution>
    			<id>jar2</id>
    			<configuration>
    				<finalName>jar2</finalName>
    				<archive>
    					<manifest>
    						<mainClass>com.test.Test2</mainClass>
    					</manifest>
    				</archive>
    				<descriptorRefs>
    					<descriptorRef>jar-with-dependencies</descriptorRef>
    				</descriptorRefs>
    			</configuration>
    			<phase>install</phase>
    			<goals>
    				<goal>assembly</goal>
    			</goals>
    		</execution>
    	</executions>
    </plugin>

    扩展

    方式二中可以打出两个jar包,名称为 jar1-jar-with-dependencies.jar 和 jar2-jar-with-dependencies.jar,这里后缀是自动加上的,怎么才能修改jar包的名称呢?

    使用maven-antrun-plugin这个插件,通过move命令修改名称

    详见 maven打完jar包之后将jar包放到指定位置总结 中的方式三

    展开全文
  • 有时候我们一个项目会依赖于另一个项目的类库和资源,如下图项目pds-prrs依赖于pds-fw和pds-srv中的类和包 想要在pds-prrs中引入其他两个项目的方法为:  右键->build path->configure build path->project选项卡->....

    有时候我们一个项目会依赖于另一个项目的类库和资源,如下图项目study依赖于studyCore项目和studyCore中的jar包

    想要在study中引入这个项目的方法为:

     右键Properties->Java Build Path->->Projects选项卡,点击Add,将studyCore项目加入即可

    如下图:



    不过值得注意的是,即使这样,只能保证编译正确,运行依然可能会出错,比如说我们在测试的总是碰到找不到com.ibm.db2.jcc.DB2Driver这个class,原因是因为这里我们study还依赖了studyCore项目lib文件夹里面的db2jcc4.jar,虽然我们在Libraries里面已经添加了依赖,但是eclipse并没有帮我们打包进study这个项目里面,那么怎么办呢?需要在Deployment Assembly里面也添加一下,如下图:


    这样运行的时候就没问题了。




    展开全文
  • 今天又学了一招使用Maven为一个项目生成多个Jar包,或者说将某一个目录打成一个jar包。 原文地址 虽然在Java平台下,各种构建工具如Maven、Gradle、SBT已经得到了较为广泛地运用,同时Maven约定的模块目录结构也...

    今天又学了一招使用Maven为一个项目生成多个Jar包,或者说将某一个目录打成一个jar包。

    原文地址

    虽然在Java平台下,各种构建工具如Maven、Gradle、SBT已经得到了较为广泛地运用,同时Maven约定的模块目录结构也得到了业界的认可,成为了Java平台下项目结构的事实标准。但我们总无法避免与各种遗留系统或老系统打交道。在没有Maven的时代,是Ant统治的时代,它因为提供了较为灵活的编写Task的功能,而忽略了制定一套看似呆板,实则有效的标准模板。于是,在不同的企业,不同的Java项目,出现了各种各样奇怪的目录结构与打包要求。拖着这些沉重的历史包袱,我们自然希望彻底革命,把那些看不顺眼的东西全部改造,让整个项目焕然一新。这是好事儿,所谓长痛不如短痛,一下子把问题肿瘤给割了,痛快!可是现实总有那么一些阻力会让我们缩手缩脚,我们不能挥起革命的利刃一阵乱砍,这弄不好会砍伤自己的手。于是乎,我们需要做战略性的撤退。退一步海阔天空嘛。

    我面对的就是这样一个软件系统。这个Java开发的软件系统一直没有依赖管理,仅仅编写了Ant任务用于发布打包。我们的任务是渐进地引入Maven,并在从Build到deploy的整个生命周期中,逐步替换Ant,与持续集成搭配起来。这个系统的多数模块都划分了服务端与客户端。然而不巧的是,各个模块的服务端和客户端都集中在一个模块中。同时,这个项目的目录结构并非标准的Maven结构,如下图所示。因此,还需要自定义Source与TestSource的目录结构。在原来的Ant任务中,是将它们打包成了两个Jar包。现在,我们需要在Maven中同样做到这一点。

    分析这个目录结构,无非是在打包时,对文件进行include或exclude。我查阅到Maven的一位开发者Tim O’Brien写的一篇博客 Sonatype的博客 ,详细介绍了具体的做法。当然,在博客中,他一再强调了这种做法的不可取,建议在项目模块上做出好的分解,保证一个Module对应一个Jar包。这篇博客介绍了两种做法,一个是在Profile中定义,一个则是在build中定义,使用的插件皆为maven-jar-plugin。对于我要解决的问题,可以考虑选择使用第二种做法,因为它只需要执行一条mvn package命令就能同时得到Server和Client的Jar包。具体的做法就是在插件的配置中,include各自的文件夹即可。配置如下:

        <groupId>com.test.maven</groupId>
        <artifactId>testmaven</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <build>
            <sourceDirectory>src</sourceDirectory>
            <testSourceDirectory>testSrc</testSourceDirectory>
    
            <plugins>
                <plugin>
                    <artifactId>maven-jar-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>server</id>
                            <goals><goal>jar</goal></goals>
                            <phase>package</phase>
                            <configuration>
                                <classifier>server</classifier>
                                <includes>
                                    <include>**/server/**</include>
                                </includes>
                            </configuration>
                        </execution>
                        <execution>
                            <id>client</id>
                            <goals><goal>jar</goal></goals>
                            <phase>package</phase>
                            <configuration>
                                <classifier>client</classifier>
                                <includes>
                                    <include>**/client/**</include>
                                </includes>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    

    通过这样的配置,运行mvn package可以生成三个包,其中testmaven-1.0-SNAPSHOT.jar同时包含了服务端和客户端的类;而服务端和客户端对应的Jar则为testmaven-1.0-SNAPSHOT-server.jar和testmaven-1.0-SNAPSHOT-client.jar。

    在前面的配置中,我们并没有为server和client包定义自己的坐标,而是沿用了统一的一个。这就意味着依赖这个包的其他Module,可能无法通过Dependency来精确定位Server或Client。这对于部署来说,是没有问题的,但却无法进行依赖管理;除非在依赖的时候,去依赖整个大的模块。

    要保证依赖管理,就意味着需要为server和client分别指定各自的坐标。看来需要另辟蹊径。其实,Maven是支持在一个项目中建立多个子模块的。我们可以考虑在项目中引入两个子模块,分别对应server和client,并在这两个子模块中建立自己的pom.xml文件。这在本质上是与Maven多模块支持是相同的,唯一不同的是代码结构。而且这种新建模块并没有影响原有的目录结构,对于遗留系统而言,还是可以接受的。因此,我们建立了如下图所示的模块结构:

    在新的结构中,除了原有模块外,我还引入了另外两个新的模块server和client,它们除了拥有自己的pom.xml文件,没有其他任何内容。而在原有模块下,同样定义了一个pom.xml文件,它将作为整个项目的parent。定义如下:

        <groupId>com.test.maven</groupId>
        <artifactId>testmaven</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>pom</packaging>
    
        <modules>
            <module>server</module>
            <module>client</module>
        </modules>
    

    这里定义的坐标是整个项目的坐标,同时指定了packaging的类型为pom。在这个pom.xml文件中还包括了两个子模块,其中的值应该与模块的名称对应。接下来配置server模块的pom.xml:

        <parent>
            <groupId>com.test.maven</groupId>
            <artifactId>testmaven</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <artifactId>testmaven-server</artifactId>
    
        <build>
            <sourceDirectory>../src</sourceDirectory>
            <testSourceDirectory>../testSrc</testSourceDirectory>
    
            <plugins>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <configuration>
                        <includes>
                            <include>**/server/**</include>
                        </includes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    首先声明了parent指向了主模块的坐标。接下来,声明当前模块的artifact id为testmaven-server。这就为server指定了独立的坐标。一旦部署后,在maven的Repository中会得到这样的文件:com/test/maven/testmaven-server/1.0-SNAPSHOT/testmaven-server-1.0-SNAPSHOT.jar。我们就可以在依赖中这样声明:

        <dependencies>
            <dependency>
                <groupId>com.test.maven</groupId>
                <artifactId>testmaven-server</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    

    运行mvn package,oops……竟然出现问题了。什么问题呢?单元测试无法通过。报告的错误为:

    Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:testCompile (default-testCompile) on project testmaven-server: Compilation failure: Compilation failure:
    [ERROR] /Users/twer/learn/testmaven/testSrc/com/test/maven/client/HelloMavenTest.java:[11,9] cannot find symbol
    [ERROR] symbol  : class HelloMaven
    [ERROR] location: class com.test.maven.client.HelloMavenTest

    仔细分析,原来是在执行编译server包时,报告无法编译client包对应的测试类。怎么会在编译server包时,去编译client包对应的测试呢?仔细观察我们的pom.xml文件,在maven-compiler-plugin插件中,我们配置了对server文件的引入,这就意味着在编译server包时,不会引入client文件夹下的所有文件(当然在这里就是Java类文件)。但是,我们并没有在test-compile阶段排除client对应的测试文件。这就导致client的测试无法找到对应的实现类。找到根源,问题就好解决了,显然我们需要在test-compile阶段排除client文件夹。所以,server模块下正确的pom.xml配置为:

        <parent>
            <groupId>com.test.maven</groupId>
            <artifactId>testmaven</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <artifactId>testmaven-server</artifactId>
    
        <build>
            <sourceDirectory>../src</sourceDirectory>
            <testSourceDirectory>../testSrc</testSourceDirectory>
    
            <plugins>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>
                    <configuration>
                        <includes>
                            <include>**/server/**</include>
                        </includes>
                    </configuration>
                    <executions>
                        <execution>
                            <id>default-testCompile</id>
                            <phase>test-compile</phase>
                            <configuration>
                                <testExcludes>
                                    <exclude>**/client/**</exclude>
                                </testExcludes>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    

    注意:我在IntelliJ配置execution下的configuration节时,碰到一个问题,那就是针对testExcludes配置节没有智能提示。由于其他maven配置节在正确情况下都有智能提示,因而让我产生错误,认为这个配置项不支持testExcludes,这让我纠结了好半天。

    对于client模块而言,如法炮制,只是包含以及过滤的文件夹反转了一个个儿而已。当我们进行install甚至deploy时,在repository下的test/maven文件夹中,看到了三个文件夹,如图所示:

    其中的testmaven/1.0-SNAPSHOT文件夹下并没有jar包,因为它对应的配置为主模块的配置,也就是parent配置。在这个配置中,我们将packaging的类型设置为pom了。


    展开全文
  • 1.创建两个项目Import(用于导入和调用jar包的print方法) ,Export (用于导出jar包声明一个print方法,打印一句“倒入成功”) 2.将Export包打包并导出(在项目上点击右键,选择Export,选择java目录下的JAR ...
  • 1.被引用的项目在“Android”选项里设置“Is Library”打钩 2.引用项在“Android”选项里设置“add"被引用项 3.android Dependencies会显示引用项目,依赖项目 Android Private Libraries:表示放在libs里面的jar...
  • 一个电脑安装两个jdk版本

    万次阅读 多人点赞 2016-12-13 10:53:56
    场景:公司项目使用的jdk为1.7,最近不是很忙,找到一个爬虫系统学习。该系统使用到了jdk1.8的特性,所以I need 俩版本,开整!!! 1 . 准备两个版本的jdk我的两个jdk路径为: D:\jdk1.7.0_80 D:\Program ...
  • 错误 如下图所示,httpclient与httpcore存在不同的版本,导致用到该jar的功能模块报错,主要的错误是,不能够识别...为什么删除这个版本的,主要是根据模块的jar需要用到哪一版本(当时是由于用阿里云的OSS) 【...
  • 现在是有一个项目引入了两个library,要将这个项目打成jar包,放到另外一个项目使用
  • 现在将A项目打成一个jar包导入B项目。B项目调用A项目的service层方法。如何保证能调用并执行。是否需要先加载A项目的数据源再调用A项目的service方法? 例如B项目中要调用A.jar的方法去执行扣费操作,把扣费...
  • 当依赖多个项目时,很多额外的jar都会依赖进来,可能会因版本不一样导致jar包冲突,例如Hibernate跟servlet的包冲突,或者其他情况的情况。如果是使用的maven管理jar,则非常好解决,使用maven dependency的...
  • 一个jar包不同版本冲突解决方法

    万次阅读 2016-11-21 17:15:12
    一个项目里面同一个jar包一般不能有两个版本的 不然可能会出现jar包冲突的情况常见报错有这三个: 1、java.lang.ClassNotFoundException(找不到类) 2、java.lang.NoSuchMethodError(找不到具体方法) 3、java.lang...
  • 查看方式 第种方式:使用MANIFEST.MF文件里的Class-Path ...Class-Path含义:执行这个jar包所依赖的第三方Jar包的ClassPath ,class loader会依据这个路径来搜索class。 第二种方式:使用mvn dependency:tre...
  • 一个maven项目打多个可执行Jar文件

    千次阅读 2015-11-09 11:23:56
    使用maven-jar-plugin插件可以将一个maven项目按照需求打出多个可执行的jar文件。 pom关键配置如下所示: <groupId>org.apache.maven.plugins <artifactId>maven-jar-plugin <executions>
  • 今天用IDEA,需要导入一个Jar包,因为以前都是用eclipse的,所以对这个idea还不怎么上手,连打个Jar包都是谷歌了一下。但是发现网上谷歌到的做法一般都是去File –> Project Structure中去设置,有没有如同eclipse...
  • 修改项目android的jar版本

    千次阅读 2012-02-23 09:49:09
    所以我们需要将我们已经开发好的应用程序换上低版本的android jar包重新编译一个APK, 那么如何简单的在高版本的工程中直接修改呢:  1、打开default.properties文件,在工程的根目录下,将target=android-8...
  • 两个jar包下相同包名类名引入冲突

    万次阅读 2018-11-03 18:06:27
    有时候引入的jar包中的... 有一个项目下需要用到OpenCV和javacv,但是javacv中已经包含了另一个版本的的openCV,这与我们需要的OpenCV版本不一致, 但是编译和运行的时候程序引入的是我们不需要的版本 1.查看mave...
  • docker实现多个jar部署在一个容器中 因为项目中,需要运行多个容器,刚开始将每一个服务部署在一个单独的容器中,这样可以很轻松的实现自动部署,...这样,公司只要申请台云服务器,不但可以将一个微服务项目,...
  • 一个工程并存jar包不同版本

    千次阅读 2010-12-16 19:50:18
    (1)eclipse工程中会存在.classpath文件,里面类似下面加载jar包情况 &lt;classpathentry kind="lib" path="...(2)如果需要同时使用一个jar的不同版本,比如HttpClient2和HttpCl...
  • 今天突然想到一个问题:如果整个项目中用的是jdk1.7,那么通过maven依赖的jar包,它们使用的jdk版本是什么呢? 于是我随意打开了项目中的一个类,点进了这个类中引用的slf4j的jar包里,发现jar包中的META-INF文件夹...
  • 但是多个项目完全可能引用了相同的jar,如何使多项目共享这个jar呢?项目发布时经常由于jar冲突造成很多问题,如果使打出的包精确指定所需要的jar版本呢?如何不放到%TOMCAT_HOME%/webapps目录,而把war放到特定的...
  • 但是在实际的情况中往往会有重复依赖的问题,比如创建的工程A,依赖了b-1.0.jar,而b-1.0.jar又依赖了d-1.0.jar(这我们本身是不能直接看到的),同时我们自己的工程又依赖了d-2.1.jar,或者工程A依赖了c-1.0.jar...
  • 使用Maven为一个工程生成多个jar

    千次阅读 2020-02-25 22:04:07
    有时候我们需要在一个java工程内执行打包命令能生成多个jar包,每个jar包的具体内容都与具体实现类相绑定,这样的好处就是方便。比如我们项目中对外提供了插件扩展,第三方使用者只需要实现我们的插件接口,然后打成...
  • 项目中除了pom.xml依赖之外,有时还依赖了其他jar包,如图: 依赖的方式如下: 点击Project Structure进行项目设置,在Modules中Dependencies标签中点击+号 添加lib下...这样的话项目中就可以使用lib中依赖的jar...
  • docker实现多个jar部署在一个容器中 在之前的文章中介绍了如何在docker中部署多个实例,这篇文章讲演化后的第二版本的docker部署多jar包。 Dockerfile centos7+java环境 FROM centos:7 MAINTAINER linwenyao WORKDIR...
  • 导入Jar包是如何次选中多个jar

    千次阅读 2018-06-14 15:22:49
    复制jar包之后,还要讲jar包导入到libraries中 怎么次选中多个jar包呢? 很简单 shift+鼠标左键

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 301,866
精华内容 120,746
关键字:

一个项目使用两个版本的jar