详解Java 包扫描实现和应用(Jar篇)

如果你曾经使用过 spring, 那你已经配过 包扫描路径吧，那包扫描是怎么实现的呢？让我们自己写个包扫描

上篇文章中介绍了使用 file 遍历的方式去进行包扫描，这篇主要补充一下jar包的扫描方式，在我们的项目中一般都会去依赖一些其他jar 包，

比如添加 guava 依赖

<dependency>
  <groupid>com.google.guava</groupid>
  <artifactid>guava</artifactid>
  <version>28.2-jre</version>
</dependency>

我们再次运行上次的测试用例

@test
public void testgetpackageallclasses() throws ioexception, classnotfoundexception {
  classscanner scanner = new classscanner("com.google.common.cache", true, null, null);
  set<class<?>> packageallclasses = scanner.doscanallclasses();
  packageallclasses.foreach(it -> {
    system.out.println(it.getname());
  });
}

什么都没有输出

依赖的 jar

基于java 的反射机制，我们很容易根据 class 去创建一个实例对象，但如果我们根本不知道某个包下有多少对象时，我们应该怎么做呢？

在使用spring框架时，会根据包扫描路径来找到所有的 class, 并将其实例化后存入容器中。

在我们的项目中也会遇到这样的场景，比如某个包为 org.example.plugins, 这个里面放着所有的插件，为了不每次增减插件都要手动修改代码，我们可能会想到用扫描的方式去动态获知 org.example.plugins 到底有多少 class, 当然应用场景很有很多

思路

既然知道是采用了 jar , 那我们使用遍历 jar 的方式去处理一下

jarfile jar = ((jarurlconnection) url.openconnection()).getjarfile();
// 遍历jar包中的元素
enumeration<jarentry> entries = jar.entries();

while (entries.hasmoreelements()) {
 jarentry entry = entries.nextelement();
 string name = entry.getname();
}

这里获取的name 格式为 com/google/common/cache/cache.class 是不是和上篇的文件路径很像呀, 这里可以通过对 name 进行操作获取包名和 class

// 获取包名
string jarpackagename = name.substring(0, name.lastindexof('/')).replace("/", ".");

// 获取 class 路径, 这样就能通过类加载进行加载了
string classname = name.replace('/', '.');
classname = classname.substring(0, classname.length() - 6);

完整代码

private void doscanpackageclassesbyjar(string basepackage, url url, set<class<?>> classes)
  throws ioexception, classnotfoundexception {
 // 包名
 string packagename = basepackage;
 // 获取文件路径
 string basepackagefilepath = packagename.replace('.', '/');
 // 转为jar包
 jarfile jar = ((jarurlconnection) url.openconnection()).getjarfile();
 // 遍历jar包中的元素
 enumeration<jarentry> entries = jar.entries();
 while (entries.hasmoreelements()) {
  jarentry entry = entries.nextelement();
  string name = entry.getname();
  // 如果路径不一致，或者是目录，则继续
  if (!name.startswith(basepackagefilepath) || entry.isdirectory()) {
   continue;
  }
  // 判断是否递归搜索子包
  if (!recursive && name.lastindexof('/') != basepackagefilepath.length()) {
   continue;
  }

  if (packagepredicate != null) {
   string jarpackagename = name.substring(0, name.lastindexof('/')).replace("/", ".");
   if (!packagepredicate.test(jarpackagename)) {
    continue;
   }
  }

  // 判定是否符合过滤条件
  string classname = name.replace('/', '.');
  classname = classname.substring(0, classname.length() - 6);
  // 用当前线程的类加载器加载类
  class<?> loadclass = thread.currentthread().getcontextclassloader().loadclass(classname);
  if (classpredicate == null || classpredicate.test(loadclass)) {
   classes.add(loadclass);
  }

 }
}

在结合上篇中 file 扫描方式就是完成的代码了

整合后代码

package org.example;

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.function.predicate;
import java.util.jar.jarentry;
import java.util.jar.jarfile;

/**
 * class 扫描器
 *
 * @author zhangyunan
 */
public class classscanner {

 private final string basepackage;
 private final boolean recursive;
 private final predicate<string> packagepredicate;
 private final predicate<class> classpredicate;


 /**
  * instantiates a new class scanner.
  *
  * @param basepackage   the base package
  * @param recursive    是否递归扫描
  * @param packagepredicate the package predicate
  * @param classpredicate  the class predicate
  */
 public classscanner(string basepackage, boolean recursive, predicate<string> packagepredicate,
  predicate<class> classpredicate) {
  this.basepackage = basepackage;
  this.recursive = recursive;
  this.packagepredicate = packagepredicate;
  this.classpredicate = classpredicate;
 }

 /**
  * do scan all classes set.
  *
  * @return the set
  * @throws ioexception      the io exception
  * @throws classnotfoundexception the class not found exception
  */
 public set<class<?>> doscanallclasses() throws ioexception, classnotfoundexception {

  set<class<?>> classes = new linkedhashset<class<?>>();

  string packagename = basepackage;

  // 如果最后一个字符是“.”，则去掉
  if (packagename.endswith(".")) {
   packagename = packagename.substring(0, packagename.lastindexof('.'));
  }

  // 将包名中的“.”换成系统文件夹的“/”
  string basepackagefilepath = packagename.replace('.', '/');

  enumeration<url> resources = thread.currentthread().getcontextclassloader().getresources(basepackagefilepath);
  while (resources.hasmoreelements()) {
   url resource = resources.nextelement();
   string protocol = resource.getprotocol();
   if ("file".equals(protocol)) {
    string filepath = urldecoder.decode(resource.getfile(), "utf-8");
    // 扫描文件夹中的包和类
    doscanpackageclassesbyfile(classes, packagename, filepath);
   } else if ("jar".equals(protocol)) {
    doscanpackageclassesbyjar(packagename, resource, classes);
   }
  }

  return classes;
 }

 private void doscanpackageclassesbyjar(string basepackage, url url, set<class<?>> classes)
  throws ioexception, classnotfoundexception {
  // 包名
  string packagename = basepackage;
  // 获取文件路径
  string basepackagefilepath = packagename.replace('.', '/');
  // 转为jar包
  jarfile jar = ((jarurlconnection) url.openconnection()).getjarfile();
  // 遍历jar包中的元素
  enumeration<jarentry> entries = jar.entries();
  while (entries.hasmoreelements()) {
   jarentry entry = entries.nextelement();
   string name = entry.getname();
   // 如果路径不一致，或者是目录，则继续
   if (!name.startswith(basepackagefilepath) || entry.isdirectory()) {
    continue;
   }
   // 判断是否递归搜索子包
   if (!recursive && name.lastindexof('/') != basepackagefilepath.length()) {
    continue;
   }

   if (packagepredicate != null) {
    string jarpackagename = name.substring(0, name.lastindexof('/')).replace("/", ".");
    if (!packagepredicate.test(jarpackagename)) {
     continue;
    }
   }

   // 判定是否符合过滤条件
   string classname = name.replace('/', '.');
   classname = classname.substring(0, classname.length() - 6);
   // 用当前线程的类加载器加载类
   class<?> loadclass = thread.currentthread().getcontextclassloader().loadclass(classname);
   if (classpredicate == null || classpredicate.test(loadclass)) {
    classes.add(loadclass);
   }

  }
 }

 /**
  * 在文件夹中扫描包和类
  */
 private void doscanpackageclassesbyfile(set<class<?>> classes, string packagename, string packagepath)
  throws classnotfoundexception {
  // 转为文件
  file dir = new file(packagepath);
  if (!dir.exists() || !dir.isdirectory()) {
   return;
  }
  // 列出文件，进行过滤
  // 自定义文件过滤规则
  file[] dirfiles = dir.listfiles((filefilter) file -> {
   string filename = file.getname();

   if (file.isdirectory()) {
    if (!recursive) {
     return false;
    }

    if (packagepredicate != null) {
     return packagepredicate.test(packagename + "." + filename);
    }
    return true;
   }

   return filename.endswith(".class");
  });

  if (null == dirfiles) {
   return;
  }

  for (file file : dirfiles) {
   if (file.isdirectory()) {
    // 如果是目录，则递归
    doscanpackageclassesbyfile(classes, packagename + "." + file.getname(), file.getabsolutepath());
   } else {
    // 用当前类加载器加载 去除 filename 的 .class 6 位
    string classname = file.getname().substring(0, file.getname().length() - 6);
    class<?> loadclass = thread.currentthread().getcontextclassloader().loadclass(packagename + '.' + classname);
    if (classpredicate == null || classpredicate.test(loadclass)) {
     classes.add(loadclass);
    }
   }
  }
 }
}

到此这篇关于详解java 包扫描实现和应用(jar篇)的文章就介绍到这了,更多相关java 包扫描实现和应用内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！