代码
注意:每一个注解处理器都是单例!
NameCheckProcessor
package ztf;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
//可以用"*"表示支持所有Annotations,可以使用通配符,如果需要不同包下的话可以使用{}进行分割
@SupportedAnnotationTypes("*")
//这里填写支持的java版本
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class NameCheckProcessor extends AbstractProcessor {
private NameChecker nameChecker;
/**
* 初始化名称检查插件,processingEnv为注解处理器提供的上下文环境
*/
@Override
public void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
nameChecker = new NameChecker(processingEnv);
}
/**
* 对输入的语法树的各个节点进行进行名称检查
*/
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (!roundEnv.processingOver()) {
for (Element element : roundEnv.getRootElements())
//这里可以执行想要的操作
nameChecker.checkNames(element);
}
return false;
}
}
NameChecker
package ztf;
import java.util.EnumSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.Name;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.ElementScanner6;
import javax.lang.model.util.ElementScanner8;
import javax.tools.Diagnostic.Kind;
//为了演示效果,命名正常的类也会以警告级别显示出来
public class NameChecker {
//Messager用于向编译器发送信息
private final Messager messager;
NameCheckScanner nameCheckScanner = new NameCheckScanner();
NameChecker(ProcessingEnvironment processsingEnv) {
this.messager = processsingEnv.getMessager();
}
public void checkNames(Element element) {
nameCheckScanner.scan(element);
}
/**
* 名称检查器实现类
* 将会以Visitor模式访问抽象语法树中的元素
* 命名规则判断中将不对语法树进行修改,因此全部返回值都为null
*/
private class NameCheckScanner extends ElementScanner8<Void, Void> {
/**
* 此方法用于检查类名
* 带可变参数Void,该参数包含9种类型
*/
@Override
public Void visitType(TypeElement e, Void p) {
scan(e.getTypeParameters(), p);
checkClassName(e);
super.visitType(e, p);
return null;
}
//首字母大写
public void checkClassName(TypeElement e) {
String name = e.getSimpleName().toString();
if("".equals(name)||name==null) {
messager.printMessage(Kind.WARNING, "类名" + name + "出现异常", e);
}
String regEx ="[A-Z][A-Za-z0-9]{0,}";
Pattern pattern = Pattern.compile(regEx);
Matcher matcher = pattern.matcher(name);
if(matcher.matches()) {
messager.printMessage(Kind.WARNING, "类名" + name + "符合驼式命名法,首字母大写", e);
}else {
messager.printMessage(Kind.WARNING, "类名" + name + "不符合符合驼式命名法", e);
}
}
/**
* 检查方法命名是否合法
*/
@Override
public Void visitExecutable(ExecutableElement e, Void p) {
if (e.getKind() == ElementKind.METHOD) {
Name name = e.getSimpleName();
checkMethodName(e);
}
super.visitExecutable(e, p);
return null;
}
//首字母大写
public void checkMethodName(ExecutableElement e) {
String name = e.getSimpleName().toString();
if("".equals(name)||name==null) {
messager.printMessage(Kind.WARNING, "方法名" + name + "出现异常", e);
}
String regEx ="[a-z][A-Za-z0-9]{0,}";
Pattern pattern = Pattern.compile(regEx);
Matcher matcher = pattern.matcher(name);
if(matcher.matches()) {
messager.printMessage(Kind.WARNING, "方法名" + name + "符合驼式命名法,首字母小写", e);
}else {
messager.printMessage(Kind.WARNING, "方法名" + name + "不符合符合驼式命名法,首字母小写", e);
}
}
/**
* 检查变量命名是否合法
*/
@Override
public Void visitVariable(VariableElement e, Void p) {
// 如果这个Variable是枚举或常量,则按大写命名检查,否则按照驼式命名法规则检查
if (e.getKind() == ElementKind.ENUM_CONSTANT || e.getConstantValue() != null || heuristicallyConstant(e))
checkEnumFinal(e);
else
checkField(e);
return null;
}
public void checkField(VariableElement e) {
String name = e.getSimpleName().toString();
if("".equals(name)||name==null) {
messager.printMessage(Kind.WARNING, "字段名" + name + "出现异常", e);
}
String regEx ="[a-z][A-Za-z0-9]{0,}";
Pattern pattern = Pattern.compile(regEx);
Matcher matcher = pattern.matcher(name);
if(matcher.matches()) {
messager.printMessage(Kind.WARNING, "字段名" + name + "符合驼式命名法,首字母小写", e);
}else {
messager.printMessage(Kind.WARNING, "字段名" + name + "不符合符合驼式命名法,首字母小写", e);
}
}
public void checkEnumFinal(VariableElement e) {
String name = e.getSimpleName().toString();
if("".equals(name)||name==null) {
messager.printMessage(Kind.WARNING, "常量" + name + "出现异常", e);
}
String regEx ="[A-Z][A-Z_]{0,}";
Pattern pattern = Pattern.compile(regEx);
Matcher matcher = pattern.matcher(name);
if(matcher.matches()) {
messager.printMessage(Kind.WARNING, "常量" + name + "符合要求全部大写字母或下划线构成,并且第一个字符不能是下划\r\n" +
"线", e);
}else {
messager.printMessage(Kind.WARNING, "常量" + name + "不符合要求全部大写字母或下划线构成,并且第一个字符不能是下划\r\n" +
"线", e);
}
}
/**
* 判断一个变量是否是常量
*/
private boolean heuristicallyConstant(VariableElement e) {
//获得封闭该变量的类,看是否为借口
if (e.getEnclosingElement().getKind() == ElementKind.INTERFACE)
return true;
else if (e.getKind() == ElementKind.FIELD && e.getModifiers().containsAll(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)))
return true;
else {
return false;
}
}
}
}
运行与测试
这里可以通过javac的-processor来让编译时附上自己编写的自定义注解处理器。
在Eclipse可以使用另外一种方法:
在src或者工程目录下创建文件夹META-INF/services,然后在services下创建文件javax.annotation.processing.Processor
里面写上注解处理器的全类名(包括包名)
如:
ztf.NameCheckProcessor
然后到处为jar文件,在你需要用到这个注解处理器的工程里右键Proerties没,大功告成!: