지정 한 가방 의 클래스 검색(jar 파일 의 클래스 포함)
13552 단어 Java
본문 영구 링크:[url=http://sjsky.iteye.com/blog/1061092]http://sjsky.iteye.com/blog/1061092[/url]
실 용적 인 처리 클래스 입 니 다.주로 실 현 된 기능 은 지정 한 가방 의 모든 종 류 를 자동 으로 스 캔 하 는 것 입 니 다.[color=red]는 내부 종 류 를 스 캔 할 지,재 귀적 으로 스 캔 할 지,사용자 정의 여과 규칙 등[/color]을 설정 할 수 있 습 니 다.다음은 기본 적 인 용법 과 코드 를 소개 합 니 다.
[color=blue][size=medium]1.방법 설명[/size][/color]
// ， 、
ClassPathScanHandler handler =new ClassPathScanHandler();
// ，
ClassPathScanHandler handler = new ClassPathScanHandler(true, true,
classFilters);
// ：org.apache.commons.io
Set> calssList = handler.getPackageAllClasses(
"org.apache.commons.io", true);
[color=blue][size=medium]2.매개 변수 설명[/size][/color]
[list]
[*]boolean excludeInner:[color=red]이 매개 변 수 는 내부 클래스 를 제외 할 지 여 부 를 표시 합 니 다.true->는 false->아니오,기본=true[/color]
[*]boolean checkInOrEx:[color=red]이 매개 변 수 는 필터 규칙 적용 상황 을 표시 합 니 다.true->규칙 에 맞 는 false 검색->규칙 에 맞 는 것 을 제외 하고 기본=true[/color]
[*]List classFilters:[color=red]필터 규칙 을 사용자 정의 합 니 다.null 이나 비어 있 으 면 모두 필터 하지 않 고 기본 값 은 null 입 니 다.필터 규칙 은 Xyz 또는 Xyz*또는*Xyz 또는*Xyz*등 유사 한 형식 으로 정의 할 수 있 습 니 다[/color]
[*]Set> getPackageAllClasses(String basePackage,boolean recursive);[color=red]매개 변수 basePackage:표지 스캐닝 의 기본 패키지;매개 변수:recursive:표지 가 스 캔 하위 패키지[/color]로 돌아 갈 지 여부
[/list]
[color=blue][size=medium]3.처리 코드[/size][/color]
ClassPathScanHandler.java
package michael.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.ArrayList;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.regex.Pattern;
import org.apache.log4j.Logger;
/**
* （ jar） class
* http://sjsky.iteye.com
* @author michael
*/
public class ClassPathScanHandler {
/**
* logger
*/
private static final Logger logger = Logger
.getLogger(ClassPathScanHandler.class);
/**
* true-> false->
*/
private boolean excludeInner = true;
/**
* true—> false->
*/
private boolean checkInOrEx = true;
/**
* null ，
*/
private List classFilters = null;
/**
* ， 、
*/
public ClassPathScanHandler() {
}
/**
* excludeInner: true-> false->
* checkInOrEx： true—> false->
* classFilters： ， null ，
* @param excludeInner
* @param checkInOrEx
* @param classFilters
*/
public ClassPathScanHandler(Boolean excludeInner, Boolean checkInOrEx,
List classFilters) {
this.excludeInner = excludeInner;
this.checkInOrEx = checkInOrEx;
this.classFilters = classFilters;
}
/**
*
* @param basePackage
* @param recursive
* @return Set
*/
public Set> getPackageAllClasses(String basePackage,
boolean recursive) {
Set> classes = new LinkedHashSet>();
String packageName = basePackage;
if (packageName.endsWith(".")) {
packageName = packageName
.substring(0, packageName.lastIndexOf('.'));
}
String package2Path = packageName.replace('.', '/');
Enumeration dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(
package2Path);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
logger.info(" file class ....");
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
doScanPackageClassesByFile(classes, packageName, filePath,
recursive);
} else if ("jar".equals(protocol)) {
logger.info(" jar ....");
doScanPackageClassesByJar(packageName, url, recursive,
classes);
}
}
} catch (IOException e) {
logger.error("IOException error:", e);
}
return classes;
}
/**
* jar Class
* @param basePackage eg：michael.utils.
* @param url
* @param recursive
* @param classes
*/
private void doScanPackageClassesByJar(String basePackage, URL url,
final boolean recursive, Set> classes) {
String packageName = basePackage;
String package2Path = packageName.replace('.', '/');
JarFile jar;
try {
jar = ((JarURLConnection) url.openConnection()).getJarFile();
Enumeration entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
String name = entry.getName();
if (!name.startsWith(package2Path) || entry.isDirectory()) {
continue;
}
//
if (!recursive
&& name.lastIndexOf('/') != package2Path.length()) {
continue;
}
// inner class
if (this.excludeInner && name.indexOf('$') != -1) {
logger.info("exclude inner class with name:" + name);
continue;
}
String classSimpleName = name
.substring(name.lastIndexOf('/') + 1);
//
if (this.filterClassName(classSimpleName)) {
String className = name.replace('/', '.');
className = className.substring(0, className.length() - 6);
try {
classes.add(Thread.currentThread()
.getContextClassLoader().loadClass(className));
} catch (ClassNotFoundException e) {
logger.error("Class.forName error:", e);
}
}
}
} catch (IOException e) {
logger.error("IOException error:", e);
}
}
/**
* Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
private void doScanPackageClassesByFile(Set> classes,
String packageName, String packagePath, boolean recursive) {
File dir = new File(packagePath);
if (!dir.exists() || !dir.isDirectory()) {
return;
}
final boolean fileRecursive = recursive;
File[] dirfiles = dir.listFiles(new FileFilter() {
//
public boolean accept(File file) {
if (file.isDirectory()) {
return fileRecursive;
}
String filename = file.getName();
if (excludeInner && filename.indexOf('$') != -1) {
logger.info("exclude inner class with name:" + filename);
return false;
}
return filterClassName(filename);
}
});
for (File file : dirfiles) {
if (file.isDirectory()) {
doScanPackageClassesByFile(classes, packageName + "."
+ file.getName(), file.getAbsolutePath(), recursive);
} else {
String className = file.getName().substring(0,
file.getName().length() - 6);
try {
classes.add(Thread.currentThread().getContextClassLoader()
.loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
logger.error("IOException error:", e);
}
}
}
}
/**
*
* @param className
* @return
*/
private boolean filterClassName(String className) {
if (!className.endsWith(".class")) {
return false;
}
if (null == this.classFilters || this.classFilters.isEmpty()) {
return true;
}
String tmpName = className.substring(0, className.length() - 6);
boolean flag = false;
for (String str : classFilters) {
String tmpreg = "^" + str.replace("*", ".*") + "$";
Pattern p = Pattern.compile(tmpreg);
if (p.matcher(tmpName).find()) {
flag = true;
break;
}
}
return (checkInOrEx && flag) || (!checkInOrEx && !flag);
}
/**
* @return the excludeInner
*/
public boolean isExcludeInner() {
return excludeInner;
}
/**
* @return the checkInOrEx
*/
public boolean isCheckInOrEx() {
return checkInOrEx;
}
/**
* @return the classFilters
*/
public List getClassFilters() {
return classFilters;
}
/**
* @param pExcludeInner the excludeInner to set
*/
public void setExcludeInner(boolean pExcludeInner) {
excludeInner = pExcludeInner;
}
/**
* @param pCheckInOrEx the checkInOrEx to set
*/
public void setCheckInOrEx(boolean pCheckInOrEx) {
checkInOrEx = pCheckInOrEx;
}
/**
* @param pClassFilters the classFilters to set
*/
public void setClassFilters(List pClassFilters) {
classFilters = pClassFilters;
}
/**
* @param args
*/
public static void main(String[] args) {
//
List classFilters = new ArrayList();
classFilters.add("File*");
// ，
ClassPathScanHandler handler = new ClassPathScanHandler(true, true,
classFilters);
System.out
.println(" jar ：org.apache.commons.io ...");
Set> calssList = handler.getPackageAllClasses(
"org.apache.commons.io", true);
for (Class> cla : calssList) {
System.out.println(cla.getName());
}
System.out.println(" file ：michael.hessian ...");
classFilters.clear();
classFilters.add("Hessian*");
calssList = handler.getPackageAllClasses("michael.hessian", true);
for (Class> cla : calssList) {
System.out.println(cla.getName());
}
}
}
테스트 실행 결 과 는 다음 과 같 습 니 다.
[quote]
[color=red]jar 파일 을 재 귀적 으로 스 캔 하기 시작 한 가방:org.apache.comons.io 에서 사용자 정의 필터 규칙 에 맞 는 클래스 입 니 다.[/color]
org.apache.commons.io.FileCleaner
org.apache.commons.io.filefilter.FileFilterUtils
org.apache.commons.io.FileUtils
[color=red]파일 을 재 귀적 으로 검색 하기 위 한 패키지:michael.hessian 에서 사용자 정의 필터 규칙 에 맞 는 클래스...[/color]
michael.hessian.client.HessianClientTest
michael.hessian.client.HessianSpringClient
[/quote]
마 이 클 스 블 로그@[url=http://sjsky.iteye.com]http://sjsky.iteye.com[/url]
---------------------------------------------------------------------------------
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
JPA + QueryDSL 계층형 댓글, 대댓글 구현(2)이번엔 전편에 이어서 계층형 댓글, 대댓글을 다시 리팩토링해볼 예정이다. 이전 게시글에서는 계층형 댓글, 대댓글을 구현은 되었지만 N+1 문제가 있었다. 이번에는 그 N+1 문제를 해결해 볼 것이다. 위의 로직은 이...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
