精华内容
下载资源
问答
  • Java项目打包并处理依赖Jar 原创 2016年09月28日 20:10:54 标签:intellij idea /jar 240 Intellij Idea打包Java项目 打开模块设置 如下图所示,选中需要打包模块,右键点击,即会出现如下图所示内容,...

    Java项目打包并处理依赖Jar包
    原创 2016年09月28日 20:10:54 标签:intellij idea /jar 240
    Intellij Idea打包Java项目

    1. 打开模块设置

    如下图所示,选中需要打包的模块,右键点击,即会出现如下图所示的内容,点击Open Module Settings。

    这里写图片描述

    1. 创建Artifacts

    这里写图片描述

    1. 配置Jar包信息

    注意配置输出路径 Output directory;
    这里写图片描述

    1. 移动依赖Jar包到指定文件夹中并配置路径

    如下图所示,将项目依赖的Mysql驱动包移动到library文件夹中。方法是只需要在上右键点击创建文件夹,然后将第三方的Jar包拖动进入此文件夹即可。

    这里写图片描述

    并且点击图中马赛克部分的那个Jar文件在下方三个输入框中按照如下图配置到时模块生成的Jar包中的主类(包含Main方法的类)以及所依赖的第三方类库的地址。

    这里写图片描述

    在配置依赖Jar的路径时,需要特别注意,如下图所示,在指定的jar文件之前增加“library\”即刚才存放第三方Jar文件的新建目录的名称,如果在Linux中的IDE上操作,路径应改为“library/”;

    点击OK,退出配置部分。

    1. 生成自己的Jar文件

    在Intellij Idea的菜单栏中依次选择“Build -> Build Artifacts”选项,最后选择Rebuild操作,即可在上述指定的输出目录中发现本次生成的Jar文件。
    这里写图片描述
    6. 运行

    在命令行中跳转到输出目录中,以“java -jar 生成的jar包名称.jar”即可实现运行。

    展开全文
  • Java项目打包并处理依赖Jar,Intellij Idea打包Java项目 打开模块设置 如下图所示,选中需要打包模块,右键点击,即会出现如下图所示内容,点击Open Module Settings。 创建Artifacts 配置Jar信息,...

    Java项目打包并处理依赖Jar包,Intellij Idea打包Java项目

    打开模块设置
    如下图所示,选中需要打包的模块,右键点击,即会出现如下图所示的内容,点击Open Module Settings。

    创建Artifacts

    配置Jar包信息,注意配置输出路径 Output directory

    移动依赖Jar包到指定文件夹中并配置路径,如下图所示,将项目依赖的Mysql驱动包移动到library文件夹中。方法是只需要在上右键点击创建文件夹,然后将第三方的Jar包拖动进入此文件夹即可。

    按照下图配置生成的Jar包中的主类(包含Main方法的类)以及所依赖的第三方类库的地址

    注意:在配置依赖Jar的路径时,需要特别注意,如下图所示,在指定的jar文件之前增加“library\”即刚才存放第三方Jar文件的新建目录的名称,如果在Linux中的IDE上操作,路径应改为“library/”。

    这一步也可以勾选上 include in project build,这样点击build project就会一同生成此jar包

    点击OK,退出配置部分。

    生成自己的Jar文件
    在Intellij Idea的菜单栏中依次选择“Build -> Build Artifacts”选项,最后选择Rebuild操作,即可在上述指定的输出目录中发现本次生成的Jar文件。 
     
    6. 运行

    在命令行中跳转到输出目录中,以“java -jar 生成的jar包名称.jar”即可实现运行。

    展开全文
  • java 获取某个的所有类名

    万次阅读 2017-07-07 14:51:18
    java 获取某个的所有类名 (中文路径)

    本方法支持class 模式和jar 包模式

    package com.yoke.util;
    
    import com.yoke.md5util.UrlDecode;
    import com.yoke.util.file.FileUtil;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.net.URL;
    import java.net.URLClassLoader;
    import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.List;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    /**
     * @author jiangzeyin
     * @date 2016-9-9
     */
    public class PackageUtil {
    
        /**
         * 获取某包下(包括该包的所有子包)所有类
         *
         * @param packageName 包名
         * @return 类的完整名称
         * @throws UnsupportedEncodingException
         */
        public static List<String> getClassName(String packageName) throws IOException {
            return getClassName(packageName, true);
        }
    
        /**
         * 获取某包下所有类
         *
         * @param packageName  包名
         * @param childPackage 是否遍历子包
         * @return 类的完整名称
         * @throws UnsupportedEncodingException
         */
        public static List<String> getClassName(String packageName, boolean childPackage) throws IOException {
            List<String> fileNames = new ArrayList<>();
            ClassLoader loader = Thread.currentThread().getContextClassLoader();
            String packagePath = packageName.replace(".", "/");
            Enumeration<URL> urls = loader.getResources(packagePath);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                if (url == null)
                    continue;
                String type = url.getProtocol();
                if (type.equals("file")) {
                    fileNames.addAll(getClassNameByFile(url.getPath(), childPackage));
                } else if (type.equals("jar")) {
                    fileNames.addAll(getClassNameByJar(url.getPath(), childPackage));
                }
            }
            fileNames.addAll(getClassNameByJars(((URLClassLoader) loader).getURLs(), packagePath, childPackage));
            return fileNames;
        }
    
        /**
         * 从项目文件获取某包下所有类
         *
         * @param filePath     文件路径
         *                     类名集合
         * @param childPackage 是否遍历子包
         * @return 类的完整名称
         * @throws UnsupportedEncodingException
         */
        private static List<String> getClassNameByFile(String filePath, boolean childPackage) throws UnsupportedEncodingException {
            List<String> myClassName = new ArrayList<>();
            filePath = UrlDecode.getURLDecode(filePath);
            File file = new File(filePath);
            File[] childFiles = file.listFiles();
            if (childFiles == null)
                return myClassName;
            for (File childFile : childFiles) {
                if (childFile.isDirectory()) {
                    if (childPackage) {
                        myClassName.addAll(getClassNameByFile(childFile.getPath(), childPackage));
                    }
                } else {
                    String childFilePath = childFile.getPath();
                    childFilePath = FileUtil.clearPath(childFilePath);
                    if (childFilePath.endsWith(".class")) {
                        childFilePath = childFilePath.substring(childFilePath.indexOf("/classes/") + 9, childFilePath.lastIndexOf("."));
                        childFilePath = childFilePath.replace("/", ".");
                        myClassName.add(childFilePath);
                    }
                }
            }
            return myClassName;
        }
    
        /**
         * 从jar获取某包下所有类
         *
         * @param jarPath      jar文件路径
         * @param childPackage 是否遍历子包
         * @return 类的完整名称
         * @throws UnsupportedEncodingException
         */
        private static List<String> getClassNameByJar(String jarPath, boolean childPackage) throws UnsupportedEncodingException {
            List<String> myClassName = new ArrayList<String>();
            String[] jarInfo = jarPath.split("!");
            String jarFilePath = jarInfo[0].substring(jarInfo[0].indexOf("/"));
            jarFilePath = UrlDecode.getURLDecode(jarFilePath);
            String packagePath = jarInfo[1].substring(1);
            try {
                JarFile jarFile = new JarFile(jarFilePath);
                Enumeration<JarEntry> entrys = jarFile.entries();
                while (entrys.hasMoreElements()) {
                    JarEntry jarEntry = entrys.nextElement();
                    String entryName = jarEntry.getName();
                    if (entryName.endsWith(".class")) {
                        if (childPackage) {
                            if (entryName.startsWith(packagePath)) {
                                entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
                                myClassName.add(entryName);
                            }
                        } else {
                            int index = entryName.lastIndexOf("/");
                            String myPackagePath;
                            if (index != -1) {
                                myPackagePath = entryName.substring(0, index);
                            } else {
                                myPackagePath = entryName;
                            }
                            if (myPackagePath.equals(packagePath)) {
                                entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
                                myClassName.add(entryName);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                //SystemLog.Log(LogType.systemInfo, e.getMessage(), e);
            }
            return myClassName;
        }
    
        /**
         * 从所有jar中搜索该包,并获取该包下所有类
         *
         * @param urls         URL集合
         * @param packagePath  包路径
         * @param childPackage 是否遍历子包
         * @return 类的完整名称
         * @throws UnsupportedEncodingException
         */
        private static List<String> getClassNameByJars(URL[] urls, String packagePath, boolean childPackage) throws UnsupportedEncodingException {
            List<String> myClassName = new ArrayList<String>();
            if (urls != null) {
                for (int i = 0; i < urls.length; i++) {
                    URL url = urls[i];
                    String urlPath = url.getPath();
                    // 不必搜索classes文件夹
                    if (urlPath.endsWith("classes/")) {
                        continue;
                    }
                    String jarPath = urlPath + "!/" + packagePath;
                    myClassName.addAll(getClassNameByJar(jarPath, childPackage));
                }
            }
            return myClassName;
        }
    }

    本方法是本人在网上看到,拿来用后面发现如果class 所在路径中存在中文则不行,本方法修护了这个问题。

    关键代码是在 108行 对其路径进行url 编码

    展开全文
  • 前面做在mybatis通过注解自动创建更新表结构项目,其中在spring加载...所以就需要一个功能,通过名获取该的所有class,那么直接贴代码: package com.sunchenbin.store.utils; import java.io.File; import

    前面做的在mybatis通过注解自动创建更新表结构的项目,其中在spring加载完毕之后需要去获取所有实体类的class,用来获取实体类属性上的注解,进而分析表结构达到创建修改表结构的目的。

    所以就需要一个功能,通过包名获取该包下的所有class,那么直接贴代码:

    package com.sunchenbin.store.utils;
    
    import java.io.File;
    import java.io.FileFilter;
    import java.io.IOException;
    import java.net.JarURLConnection;
    import java.net.URL;
    import java.net.URLDecoder;
    import java.util.Enumeration;
    import java.util.LinkedHashSet;
    import java.util.Set;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    
    /**
     * 通过包名获取class
     *
     * @author sunchenbin
     * @version 2016年6月23日 下午5:55:18 
     */
    public class ClassTools{
    
        /**
         * 从包package中获取所有的Class
         * 
         * @param pack
         * @return
         */
        public static Set<Class<?>> getClasses(String pack){
    
            // 第一个class类的集合
            Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
            // 是否循环迭代
            boolean recursive = true;
            // 获取包的名字 并进行替换
            String packageName = pack;
            String packageDirName = packageName.replace('.', '/');
            // 定义一个枚举的集合 并进行循环来处理这个目录下的things
            Enumeration<URL> dirs;
            try{
                dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
                // 循环迭代下去
                while (dirs.hasMoreElements()){
                    // 获取下一个元素
                    URL url = dirs.nextElement();
                    // 得到协议的名称
                    String protocol = url.getProtocol();
                    // 如果是以文件的形式保存在服务器上
                    if ("file".equals(protocol)) {
                        System.err.println("file类型的扫描");
                        // 获取包的物理路径
                        String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                        // 以文件的方式扫描整个包下的文件 并添加到集合中
                        findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                    }else if ("jar".equals(protocol)) {
                        // 如果是jar包文件
                        // 定义一个JarFile
                        System.err.println("jar类型的扫描");
                        JarFile jar;
                        try{
                            // 获取jar
                            jar = ((JarURLConnection) url.openConnection()).getJarFile();
                            // 从此jar包 得到一个枚举类
                            Enumeration<JarEntry> entries = jar.entries();
                            // 同样的进行循环迭代
                            while (entries.hasMoreElements()){
                                // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                                JarEntry entry = entries.nextElement();
                                String name = entry.getName();
                                // 如果是以/开头的
                                if (name.charAt(0) == '/') {
                                    // 获取后面的字符串
                                    name = name.substring(1);
                                }
                                // 如果前半部分和定义的包名相同
                                if (name.startsWith(packageDirName)) {
                                    int idx = name.lastIndexOf('/');
                                    // 如果以"/"结尾 是一个包
                                    if (idx != -1) {
                                        // 获取包名 把"/"替换成"."
                                        packageName = name.substring(0, idx).replace('/', '.');
                                    }
                                    // 如果可以迭代下去 并且是一个包
                                    if ((idx != -1) || recursive) {
                                        // 如果是一个.class文件 而且不是目录
                                        if (name.endsWith(".class") && !entry.isDirectory()) {
                                            // 去掉后面的".class" 获取真正的类名
                                            String className = name.substring(packageName.length() + 1, name.length() - 6);
                                            try{
                                                // 添加到classes
                                                classes.add(Class.forName(packageName + '.' + className));
                                            }catch (ClassNotFoundException e){
                                                // log
                                                // .error("添加用户自定义视图类错误 找不到此类的.class文件");
                                                e.printStackTrace();
                                            }
                                        }
                                    }
                                }
                            }
                        }catch (IOException e){
                            // log.error("在扫描用户定义视图时从jar包获取文件出错");
                            e.printStackTrace();
                        }
                    }
                }
            }catch (IOException e){
                e.printStackTrace();
            }
    
            return classes;
        }
    
        /**
         * 以文件的形式来获取包下的所有Class
         * 
         * @param packageName
         * @param packagePath
         * @param recursive
         * @param classes
         */
        public static void findAndAddClassesInPackageByFile(
                String packageName,
                String packagePath,
                final boolean recursive,
                Set<Class<?>> classes){
            // 获取此包的目录 建立一个File
            File dir = new File(packagePath);
            // 如果不存在或者 也不是目录就直接返回
            if (!dir.exists() || !dir.isDirectory()) {
                // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
                return;
            }
            // 如果存在 就获取包下的所有文件 包括目录
            File[] dirfiles = dir.listFiles(new FileFilter(){
    
                // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
                public boolean accept(File file){
                    return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
                }
            });
            // 循环所有文件
            for (File file : dirfiles){
                // 如果是目录 则继续扫描
                if (file.isDirectory()) {
                    findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
                }else{
                    // 如果是java类文件 去掉后面的.class 只留下类名
                    String className = file.getName().substring(0, file.getName().length() - 6);
                    try{
                        // 添加到集合中去
                        // classes.add(Class.forName(packageName + '.' +
                        // className));
                        // 经过回复同学的提醒,这里用forName有一些不好,会触发static方法,没有使用classLoader的load干净
                        classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                    }catch (ClassNotFoundException e){
                        // log.error("添加用户自定义视图类错误 找不到此类的.class文件");
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    展开全文
  • Java获取的所有

    千次阅读 2019-05-27 10:17:58
    Java获取的所有类 package com.zhiyu.utils; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net....
  • 输出指定目录下所有的java文件名(包含子目录) package com.itheima_02; import java.io.File; /* * 需求:输出指定目录下所有的java文件名(包含子目录) */ public class RecurrenceTest { ...
  • Java 8 中所有的包列表及介绍

    千次阅读 2017-01-29 17:23:07
    本文列出了Java 8中所有的包,并且对每一个包的功能做了简要的说明,希望对你有所帮助。 —————————————————– Java平台,标准版第八版 API规范 java.applet 提供了需要创建一个小...
  • Java8中所有的包列表及介绍

    千次阅读 2018-02-22 23:03:11
    作为java语言使用者,我们可以感受到java语言带来优势(平台无关、面向对象、多线程、高效易扩展等),而且它有很多已经实现类库可以供我们直接使用,这些类库都是以jar包的形式提供,也可以成为java API,它为...
  • 翻译了一天,终于把翻译任务的“Java 8所有的包介绍”翻译完了,收获也是非常大,了解了Java8中所有包的作用,对Java8有了一个整体的了解,另外也是提高了自身的阅读能力。http://code.csdn.net/translations/97 这...
  • 1. 引三方 <!-- 反射框架 --> <dependency> <groupId>org.reflections</groupId> <artifactId>reflections</artifactId> <version>0.9.11</version> </...
  • 不管是在Spring还是Mybatis中,我们都需要配置一个路径进行扫描类对象。 在Spring中,我们需要配置路径,...现在,我参照spring部分源码,来写一个工具类扫描及子的所有类。 package com.company.ha...
  • Java 获取的所有

    千次阅读 2017-03-01 15:36:39
    import java.io.File; import java.io.IOException; import java.net.JarURLConnection; import java.net.URISyntaxException; import java.net.URL; import java.nio.file.Files; import java.
  • java获取某所有

    2020-06-21 13:23:57
    java 获取路径下的所有类 /** * 获取某所有类 * * @param packageName 名 * @param isRecursion 是否遍历子 * @return 类完整名称 */ public static Set<String> getClassName(String ...
  • kafka的java依赖

    千次下载 热门讨论 2015-10-18 21:58:29
    kafka的java依赖,包含kafka本地调用的所有jar
  • java 查找的所有类名

    千次阅读 2016-06-13 13:21:43
    package org.happy.utils;...import java.io.File; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import java.util.ja
  • Java获取或jar下面的所有class文件

    千次阅读 2018-07-23 22:34:05
    import java.io.File; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.net.URLDecoder; import java.util.*; import java.util.jar.JarEntry; import java.u...
  • Java获取某个的所有Class类对象

    千次阅读 2019-07-11 20:44:49
    废话不多说,直接上代码 package ... import org.apache.commons.lang3.StringUtils; import java.io.File; import java.io.FileFilter;...import java.io.IOException;...import java.net.Ja...
  • 1.遍历所有的类,实际就是先找到对应的文件路径,然后根据文件路径找到对应文件夹,然后对文件夹进行遍历 2. 类都是以*.class* 结尾,故只要找到文件夹下所有.class文件即可 3. 部分*$*.class为内部类或者...
  • java.lang: Java.langjava语言体系中其他所有类库基础,已经内嵌到java虚拟机中,而且以对象形式创建好了,所以,我们在使用java.lang时不需要再使用import将其导入,可以直接使用java.lang包中的所有类...
  • Myeclipse获取Java 工程的所有包名称

    万次阅读 2018-01-19 09:46:14
    1,打开工程2,打开Src 目录3,选择第一个4,按住 shift 选择 最后一个5, 右键点击 选择 copy(复制)6,打开记事本,粘贴即可
  • java通过名反射获取所有的类名

    千次阅读 2019-05-09 15:30:45
    在编程中,始终有一些需求,需要获得一个下面所有的类名,就是通过反射来实现: 方法如下: /** * 根据名获取下面所有的类名 * * @param pack * @return * @throws Exception */ public static Set...
  • Java所有工程导入jar

    千次阅读 2018-08-21 15:14:59
    导入别人的项目时,项目里面有很多个...后面直接找到一个办法,就是整个工作空间里导入一个依赖库,我们所有的工程依赖这个库就好了,直接方便。 第一步:建一个依赖库。Windows-----&gt;preferences 第二...
  • JAVA的包机制

    千次阅读 2015-03-10 14:09:41
    JAVA中文件的一种组织形式,例如:Windows操作系统的文件夹结构,在java当中,也相当于文件夹,实际上也起着这个作用,在开发比较大的java项目时,不可能只涉及到一个java文件,不可能把所有的代码都只写在
  • java.util.concurrent 下面的所有类 原子操作数类: java.util.concurrent.atomic.AtomicBoolean.class java.util.concurrent.atomic.AtomicInteger.class java.util.concurrent.atomic.AtomicIntegerArray.class ...
  • 比如有一个java文件,import了一些java文件,有没有自动化方法把所有相关的java都打到一个jar
  • java中jar命令打包一个文件夹下的所有文件

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,987
精华内容 17,594
关键字:

java所有的包

java 订阅