maven plugin classloader加载class问题
顾鸣
今天在写基于maven plugin的一个小程序，它的功能是在maven执行install阶段将已经打好包，从这个包中抽取分布式服务中所有标识@Dic注解的字典枚举类，之后会将这些字典枚举类打成一个jar包。也就是执行了mvn install之后会在工程的target中生成两个jar包，一个是服务器端部署包，一个是字典依赖包，同时会把该依赖包depoly到私服，把jar包坐标信息，字典信息上传给相应的服务展示出来供他人使用。
使用URLClassLoader urlClassLoader = new URLClassLoader(urls,Thread.currentThread().getContextClassLoader());
不要使用ContextClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
否则会发现执行maven命令的时候加载的是从maven的repository里的jar，而不是当前工程的classpath
package com.annotation.processor;
import com.alibaba.fastjson.JSONObject;
import com.annotition.Dic;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.*;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* @author lmfeng
* @goal dic
* @requiresDependencyResolution runtime
* @phase deploy
*/
public class DicGenerateMojo extends AbstractMojo {
/**
* @parameter default-value="${project}"
*/
private MavenProject project;
/**
* @parameter property="scanDir" default-value="${basedir}/src/main/java/"
*/
private String scanDir;
/**
* @parameter property="scanPackage" default-value="com.xxx"
*/
private String scanPackage;
/**
* @parameter property="groupId" default-value="com.xxx"
*/
private String groupId;
/**
* @parameter property="version" default-value="1.0"
*/
private String version;
/**
* @parameter property="packaging" default-value="jar"
*/
private String packaging;
/**
* @parameter property="url" default-value="https://repo.xxx-inc.com/repository/snapshots"
*/
private String url;
/**
* @parameter property="reportUrl"
*/
private String reportUrl;
/**
* @parameter property="repositoryId" default-value="nexus-snapshots"
*/
private String repositoryId;
/**
* @parameter property="classPath" default-value="${basedir}/target/classes/"
*/
private String classPath;
/**
* 字典类全路径集合
*/
private Set<String> dicClassesRealPath = new LinkedHashSet<String>();
private Set<Object> dicInformation = new HashSet<Object>();
// class类的集合
private Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
public static void main(String[] args) throws IOException, MojoFailureException, MojoExecutionException {
DicGenerateMojo dicGenerateMojo = new DicGenerateMojo();
dicGenerateMojo.execute();
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
// package
String dicJarPath = packageing();
// deploy
boolean deployDicJar = deployDicJar(dicJarPath);
getLog().info(deployDicJar ? "deploy dic jar successed":"deploy dic jar failed");
if (deployDicJar){
// delete jar
deleteJar(dicJarPath);
// 上报信息 url
jsonPost(reportUrl,dicInformation);
}
}
/**
* 删除 jar
*
* @param filePath
* @return
*/
private boolean deleteJar(String filePath){
return new File(filePath).delete();
}
// mvn deploy:deploy-file -DgroupId=com.test -DartifactId=test -Dversion=1.0 -Dpackaging=jar
private boolean deployDicJar(String dicJarPath){
try {
if (dicJarPath == null){
getLog().warn("dicJarPath is null+");
return false;
}
StringBuffer cmd = new StringBuffer("mvn deploy:deploy-file");
String artifactId = app+"-dic";
cmd.append(" -DgroupId="+groupId).append(" -DartifactId="+artifactId).append(" -Dversion="+version).append(" -Dpackaging="+packaging)
.append(" -Dfile="+dicJarPath).append(" -Durl="+url).append(" -DrepositoryId="+repositoryId);
System.err.println(cmd.toString());
// Linux or Mac下
Process process = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", cmd.toString()});
process.waitFor();
process.destroy();
System.err.println("dic 坐标是:=======>");
StringBuffer sb = new StringBuffer("<dependency>");
sb.append("\n").append("<groupId>").append(groupId).append("<groupId>").append("\n")
.append("<artifactId>").append(artifactId).append("<artifactId>").append("\n")
.append("<version>").append(version).append("<version>").append("\n").append("<dependency>");
System.err.println(sb.toString());
return true;
} catch (Exception e) {
getLog().error("deploy is failed !",e);
}
return false;
}
// 通过 jar cvf appName-dic.jar 将 class 生成 jar 包
private String packageing(){
try {
Set<String> dicClassesRealPath = getDicClassesRealPath(scanPackage);
if (dicClassesRealPath.size() == 0){
getLog().warn("scan "+scanPackage+", no class is used for @Dic annotation");
return null;
}
// 打成 jar
StringBuffer cmd = new StringBuffer("jar cvf ");
if (app == null){
app = "flm_test";
}
String jarName = app+"-dic"+'-'+version+'.'+packaging;
cmd.append(jarName);
for (String str : dicClassesRealPath) {
cmd.append(" ").append(str);
}
System.err.println(cmd.toString());
// Linux or Mac下
Process process = Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", cmd.toString()});
process.waitFor();
process.destroy();
File dicJarFile = new File(jarName);
if (dicJarFile.exists()){
String dicJarPath = dicJarFile.getAbsolutePath();
System.out.println("dicJarPath is => "+dicJarPath);
return dicJarPath;
}
} catch (Exception e) {
getLog().error("package failed",e);
}
return null;
}
// TODO 判断当前系统是 Linux or windows
/**
* 获取字典类全路径
*
* @param scanPackage
* @return
*/
public Set getDicClassesRealPath(String scanPackage){
// 包下面的类
if (scanPackage == null){
scanPackage = "com.xxx";
System.err.println("scanPackage is default => "+scanPackage);
}
System.out.println("scanPackage is =>"+scanPackage);
getClasses(scanPackage);
return dicClassesRealPath;
}
/**
* 获取方法上的注解
*
* @param clazz
*/
private void getMethodsAnnotation(Class<?> clazz) {
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
Annotation[] annotations = method.getDeclaredAnnotations();
for (Annotation annotation : annotations) {
System.out.println(clazz.getSimpleName().concat(".").concat(method.getName()).concat(".")
.concat(annotation.annotationType().getSimpleName()));
}
}
}
/**
* 从包package中获取所有的Class
*
* @param pack
* @return
*/
public void getClasses(String pack) {
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
URL[] urls = new URL[1];
urls[0] = new URL("file:"+classPath);
URLClassLoader urlClassLoader = new URLClassLoader(urls,Thread.currentThread().getContextClassLoader());
dirs = urlClassLoader.getResources(packageDirName);
// 使用上下文类加载器有问题。。。
// dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
System.out.println("dirs.hasMoreElements()"+dirs.hasMoreElements());
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
System.out.println("URL is => "+url);
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
System.err.println("file类型的扫描");
// 获取包的物理路径
String packagePath = URLDecoder.decode(url.getFile(), "UTF-8");
System.out.println("packagePath is => "+packagePath);
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, packagePath, recursive, classes,urlClassLoader);
}
// else if ("jar".equals(protocol)) {
// packageName = scanJarFile(classes, recursive, packageName, packageDirName, url);
// }
}
} catch (IOException e) {
getLog().error("getClasses failed ", e);
}
}
/**
* load jar
*/
private String scanJarFile(Set<Class<?>> classes, boolean recursive, String packageName, String packageDirName, URL url) {
// 如果是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) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
// log.error("在扫描用户定义视图时从jar包获取文件出错");
e.printStackTrace();
}
return packageName;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
Set<Class<?>> classes,ClassLoader classLoader) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
getLog().warn("用户定义包名 " + packagePath + " 下没有任何文件");
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,classLoader);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去 这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
// classes.add(Class.forName(packageName + '.' + className));
System.out.println("packageName+className => "+packageName + '.' + className);
// Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className);
Class<?> clazz = classLoader.loadClass(packageName + '.' + className);
System.out.println("clazz is => "+clazz);
if (clazz.isEnum() && isDicClass(clazz)){
dicClassesRealPath.add(file.getAbsolutePath());
// 获得枚举类详细信息
dicInformation.add(enumInformation(clazz));
}
} catch (Exception e) {
getLog().error("load class failed" ,e);
}
}
}
}
/**
* 是否使用@Dic 注解
*
* @param clazz
* @return
*/
private boolean iDicClass(Class<?> clazz){
Annotation[] annos = clazz.getAnnotations();
for (Annotation anno : annos) {
if(Dic.class.equals(anno.annotationType())){
return true;
}
}
return false;
}
/**
* 枚举类详细信息
*
* @param clazz
*/
private Map<String,List<Map<String,Object>>> enumInformation(Class<?> clazz){
Map<String,List<Map<String,Object>>> enumTypeMap = new HashMap<String,List<Map<String,Object>>>();
Class<Enum> enumClass = (Class<Enum>) clazz;
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
// TODO 把信息添加到DicJar里
String clazzName = enumClass.getName();
Enum[] enumConstants = enumClass.getEnumConstants();
Map<String, Method> methods = getMethods(enumClass, enumConstants);
for (Enum enumType : enumConstants) {
Map<String,Object> map = new HashMap<String,Object>();
for (String key : methods.keySet()) {
try {
Method method = methods.get(key);
Object invoke = method.invoke(enumType);
map.put(key,invoke);
} catch (Exception e) {
e.printStackTrace();
}
}
String name = enumType.name();
int ordinal = enumType.ordinal();
map.put("name",name);
map.put("ordinal",ordinal);
list.add(map);
}
enumTypeMap.put(clazzName,list);
return enumTypeMap;
}
private Map<String,Method> getMethods(Class<Enum> enumClass,Enum[] enumConstants){
List<String> enumNames = new ArrayList<String>();
Map<String,Method> methods = new HashMap<String, Method>();
for (Enum enumType : enumConstants) {
enumNames.add(enumType.name());
}
Field[] declaredFields = enumClass.getDeclaredFields();
for (Field field:declaredFields) {
String fieldName = field.getName();
if (!enumNames.contains(fieldName) && !fieldName.equals("$VALUES")){
try {
Method method = enumClass.getMethod("get" + (fieldName.charAt(0) + "").toUpperCase() + fieldName.substring(1, fieldName.length()));
methods.put(fieldName,method);
} catch (NoSuchMethodException e) {
getLog().error(e.getMessage(),e);
}
}
}
return methods;
}
/**
* 父类、接口
*
* @param clazz
* @param classesAll
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Set<Class<?>> getByInterface(Class clazz, Set<Class<?>> classesAll) {
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
// 获取指定接口的实现类
if (!clazz.isInterface()) {
try {
/**
* 循环判断路径下的所有类是否继承了指定类 并且排除父类自己
*/
Iterator<Class<?>> iterator = classesAll.iterator();
while (iterator.hasNext()) {
Class<?> cls = iterator.next();
/**
* isAssignableFrom该方法的解析，请参考博客：
* http://blog.csdn.net/u010156024/article/details/44875195
*/
if (clazz.isAssignableFrom(cls)) {
if (!clazz.equals(cls)) {// 自身并不加进去
classes.add(cls);
} else {
}
}
}
} catch (Exception e) {
System.out.println("出现异常");
}
}
return classes;
}
/**
* 发送HttpPost请求
*
* @param strURL 服务地址
* @param params
*
* @return 成功:返回json字符串<br/>
*/
public String jsonPost(String strURL, Object params) {
try {
URL url = new URL(strURL);// 创建连接
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoOutput(true);
connection.setDoInput(true);
connection.setUseCaches(false);
connection.setInstanceFollowRedirects(true);
connection.setRequestMethod("POST"); // 设置请求方式
connection.setRequestProperty("Accept", "application/json"); // 设置接收数据的格式
connection.setRequestProperty("Content-Type", "application/json"); // 设置发送数据的格式
connection.connect();
OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream(), "UTF-8"); // utf-8编码
out.append(JSONObject.toJSONString(params));
out.flush();
out.close();
int code = connection.getResponseCode();
InputStream is = null;
if (code == 200) {
is = connection.getInputStream();
} else {
is = connection.getErrorStream();
}
// 读取响应
int length = (int) connection.getContentLength();// 获取长度
if (length != -1) {
byte[] data = new byte[length];
byte[] temp = new byte[512];
int readLen = 0;
int destPos = 0;
while ((readLen = is.read(temp)) > 0) {
System.arraycopy(temp, 0, data, destPos, readLen);
destPos += readLen;
}
String result = new String(data, "UTF-8"); // utf-8编码
return result;
}
} catch (IOException e) {
getLog().error("Exception occur when send http post request!", e);
}
return "error"; // 自定义错误信息
}
}-
@Dic字典注解
package com.annotation.dic; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @author lmfeng */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Dic { public String value() default ""; /** * 字典描述信息 * * @return string */ public String dicDecription() default ""; } -
maven依赖
<dependencies>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-api</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-descriptor</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-project</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-model</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-artifact</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.29</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.5</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>1.3</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>
</dependency>
</dependencies>
类似资料：