本方法支持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 编码

java利用反射获取某个包下的所有获取对象属性、方法、并实例化
发布时间：2018-11-01 15:23,
浏览次数：2457
, 标签：
java
首先贴上用到的jar包，当然也可以通过递归file.list获取类的路径名称。
maven导入jar包：
org.reflections
reflections0.9.11
com.google.guavaguava
21.0
一、用reflections的方式
public static List clazzLis=new ArrayList(); Reflections
reflections=new Reflections("testsunmet.imp.*"); //比如可以获取有Pay注解的class
Set> classes=reflections.getTypesAnnotatedWith(Pay.class);
for(Class> cl:classes){ Pay pay=cl.getAnnotation(Pay.class);
clazzList.add(cl.getCanonicalName())//使用list把获取到的class路径装起来 } }
二、使用递归file.list的方式
List clzList=new ArrayList<>(); private void scanPackages(String
packageName){ //获取指定包的完整路径 String
packagesUrl=this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.",
"/")).getFile(); File scanFile=new File(packagesUrl); String[]
filenameList=scanFile.list(); for(String filename:filenameList){ File file=new
File(scanFile,filename); if(file.isDirectory()){
scanPackages(packageName+"."+filename); }else{ if(filename.indexOf(".class")>0)
clzList.add(packageName+"."+filename.replace(".class","")); } } }
个人推荐使用reflections。
1.使用
//使用class.forName获取对象 如Class clazz=Class.forName("xxxx.class");
//clazz.newInstance()使用创建对象
//使用clazz.isAnnotationPresent(xxx.class)判断是否式某种注解上的对象 //获取注解上的值
clazz.getAnnotation(xxx.class) //设置属性值 Field[]
declaredFields=clazz2.newInstance().getClass().getDeclaredFields(); for(Field
field:declaredFields){ field.setAccessible(true);//使可以set私有属性的值
//这只是测试，如果真正使用，注意set的值对应上 field.set(clazz2.newInstance(), "test"); } //获取方法
Method[] methods=clazz.newInstance().getClass().getMethods(); //执行对象中的方法
methods.invoke(执行对象,方法参数)

首先贴上用到的jar包，当然也可以通过递归file.list获取类的路径名称。

maven导入jar包：

<dependency>
            <groupId>org.reflections</groupId>
            <artifactId>reflections</artifactId>
            <version>0.9.11</version>
        </dependency>
        
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>

一、用reflections的方式

      public static List<String> clazzLis=new ArrayList<String>();
		
		
			Reflections reflections=new Reflections("testsunmet.imp.*");
			//比如可以获取有Pay注解的class
			Set<Class<?>> classes=reflections.getTypesAnnotatedWith(Pay.class);

			for(Class<?> cl:classes){
				Pay pay=cl.getAnnotation(Pay.class);
				clazzList.add(cl.getCanonicalName())//使用list把获取到的class路径装起来
			}
		}

二、使用递归file.list的方式

List<String> clzList=new ArrayList<>();
		
		private void scanPackages(String packageName){
			//获取指定包的完整路径
			String packagesUrl=this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/")).getFile();
			File scanFile=new File(packagesUrl);
			String[] filenameList=scanFile.list();
			
			for(String filename:filenameList){
				File file=new File(scanFile,filename);
				if(file.isDirectory()){
					scanPackages(packageName+"."+filename);
				}else{
					if(filename.indexOf(".class")>0)
						clzList.add(packageName+"."+filename.replace(".class",""));
				}
			}
		}

个人推荐使用reflections。

 

1.使用

//使用class.forName获取对象 如Class clazz=Class.forName("xxxx.class");

//clazz.newInstance()使用创建对象


//使用clazz.isAnnotationPresent(xxx.class)判断是否式某种注解上的对象


//获取注解上的值 clazz.getAnnotation(xxx.class)


//设置属性值
Field[] declaredFields=clazz2.newInstance().getClass().getDeclaredFields();
			for(Field field:declaredFields){
				field.setAccessible(true);//使可以set私有属性的值
                //这只是测试，如果真正使用，注意set的值对应上
				field.set(clazz2.newInstance(), "test");
			}

//获取方法

Method[] methods=clazz.newInstance().getClass().getMethods();



//执行对象中的方法

methods.invoke(执行对象,方法参数)


 

首先贴上用到的jar包，当然也可以通过递归file.list获取类的路径名称。
maven导入jar包：
org.reflections
reflections
0.9.11
com.google.guava
guava
21.0
一、用reflections的方式
public static List clazzLis=new ArrayList();
Reflections reflections=new Reflections("testsunmet.imp.*");
//比如可以获取有Pay注解的class
Set> classes=reflections.getTypesAnnotatedWith(Pay.class);
for(Class> cl:classes){
Pay pay=cl.getAnnotation(Pay.class);
clazzList.add(cl.getCanonicalName())//使用list把获取到的class路径装起来
}
}
二、使用递归file.list的方式
List clzList=new ArrayList<>();
private void scanPackages(String packageName){
//获取指定包的完整路径
String packagesUrl=this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/")).getFile();
File scanFile=new File(packagesUrl);
String[] filenameList=scanFile.list();
for(String filename:filenameList){
File file=new File(scanFile,filename);
if(file.isDirectory()){
scanPackages(packageName+"."+filename);
}else{
if(filename.indexOf(".class")>0)
clzList.add(packageName+"."+filename.replace(".class",""));
}
}
}
个人推荐使用reflections。
1.使用
//使用class.forName获取对象 如Class clazz=Class.forName("xxxx.class");
//clazz.newInstance()使用创建对象
//使用clazz.isAnnotationPresent(xxx.class)判断是否式某种注解上的对象
//获取注解上的值 clazz.getAnnotation(xxx.class)
//设置属性值
Field[] declaredFields=clazz2.newInstance().getClass().getDeclaredFields();
for(Field field:declaredFields){
field.setAccessible(true);//使可以set私有属性的值
//这只是测试，如果真正使用，注意set的值对应上
field.set(clazz2.newInstance(), "test");
}
//获取方法
Method[] methods=clazz.newInstance().getClass().getMethods();
//执行对象中的方法
methods.invoke(执行对象,方法参数)