private void handleEmbeddedType(Element element, Set<TypeElement> elements) {
TypeMirror type = element.asType();
if (element.getKind() == ElementKind.METHOD) {
type = ((ExecutableElement) element).getReturnType();
}
String typeName = type.toString();
if (typeName.startsWith(Collection.class.getName())
|| typeName.startsWith(List.class.getName())
|| typeName.startsWith(Set.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(0);
} else if (typeName.startsWith(Map.class.getName())) {
type = ((DeclaredType) type).getTypeArguments().get(1);
}
TypeElement typeElement = typeExtractor.visit(type);
if (typeElement != null
&& !TypeUtils.hasAnnotationOfType(typeElement, conf.getEntityAnnotations())) {
if (!typeElement.getQualifiedName().toString().startsWith("java.")) {
elements.add(typeElement);
}
}
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> List<E> listFilter(
Iterable<? extends Element> elements, Set<ElementKind> targetKinds, Class<E> clazz) {
List<E> list = new ArrayList<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind())) list.add(clazz.cast(e));
}
return list;
}
// Assumes targetKinds and E are sensible.
private static <E extends Element> Set<E> setFilter(
Set<? extends Element> elements, Set<ElementKind> targetKinds, Class<E> clazz) {
// Return set preserving iteration order of input set.
Set<E> set = new LinkedHashSet<E>();
for (Element e : elements) {
if (targetKinds.contains(e.getKind())) set.add(clazz.cast(e));
}
return set;
}
public void printElement(TypeElement typeElement) {
List<? extends AnnotationMirror> annotationMirrors = typeElement.getAnnotationMirrors();
generator.log("class: " + typeElement + ", annotations: " + annotationMirrors);
for (Element ele : typeElement.getEnclosedElements()) {
if (ele.getKind().equals(ElementKind.METHOD)) {
ExecutableElement method = (ExecutableElement) ele;
printMethod(method);
}
}
}
private boolean doesClassContainNoArgsConstructor(Element el) {
for (Element subelement : el.getEnclosedElements()) {
if (subelement.getKind() == ElementKind.CONSTRUCTOR
&& subelement.getModifiers().contains(Modifier.PUBLIC)) {
TypeMirror mirror = subelement.asType();
if (mirror.accept(noArgsVisitor, null)) return true;
}
}
return false;
}
public void parse(TypeElement layoutElement) {
if (!layoutElement.getInterfaces().isEmpty()) {
parseSuperLayout(
(TypeElement) ((DeclaredType) layoutElement.getInterfaces().get(0)).asElement());
}
parseName(layoutElement);
objectTypeSuperclass = layoutElement.getAnnotation(Layout.class).objectTypeSuperclass();
for (Element element : layoutElement.getEnclosedElements()) {
if (element.getKind() == ElementKind.FIELD) {
final String simpleName = element.getSimpleName().toString();
if (simpleName.endsWith("_IDENTIFIER")) {
parseIdentifier((VariableElement) element);
} else {
throw new AssertionError("Unknown field in layout interface");
}
} else if (element.getKind() == ElementKind.METHOD) {
final String simpleName = element.getSimpleName().toString();
if (simpleName.equals("create" + name + "Shape")) {
parseShapeConstructor((ExecutableElement) element);
} else if (simpleName.equals("create" + name)) {
parseConstructor((ExecutableElement) element);
} else if (simpleName.equals("is" + name)) {
parseGuard((ExecutableElement) element);
} else if (simpleName.startsWith("get")) {
parseGetter((ExecutableElement) element);
} else if (simpleName.startsWith("set")) {
parseSetter((ExecutableElement) element);
} else {
throw new AssertionError("Unknown method in layout interface " + interfaceFullName);
}
}
}
assert constructorProperties.size() == properties.size();
assert constructorProperties.containsAll(properties.keySet());
}
protected boolean isExplicitTypeDefinition(Element declaration) {
if (declaration.getKind() != ElementKind.CLASS) {
debug("%s isn't a potential JAXB type because it's not a class.", declaration);
return false;
}
PackageElement pckg =
this.context.getProcessingEnvironment().getElementUtils().getPackageOf(declaration);
if ((pckg != null) && (pckg.getAnnotation(Ignore.class) != null)) {
debug(
"%s isn't a potential JAXB type because its package is annotated as to be ignored.",
declaration);
return false;
}
if (isThrowable(declaration)) {
debug(
"%s isn't a potential JAXB type because it's an instance of java.lang.Throwable.",
declaration);
return false;
}
List<? extends AnnotationMirror> annotationMirrors = declaration.getAnnotationMirrors();
boolean explicitXMLTypeOrElement = false;
for (AnnotationMirror mirror : annotationMirrors) {
Element annotationDeclaration = mirror.getAnnotationType().asElement();
if (annotationDeclaration != null) {
String fqn =
annotationDeclaration instanceof TypeElement
? ((TypeElement) annotationDeclaration).getQualifiedName().toString()
: "";
// exclude all XmlTransient types and all jaxws types.
if (XmlTransient.class.getName().equals(fqn)
|| fqn.startsWith("javax.xml.ws")
|| fqn.startsWith("javax.ws.rs")
|| fqn.startsWith("javax.jws")) {
debug("%s isn't a potential JAXB type because of annotation %s.", declaration, fqn);
return false;
} else {
explicitXMLTypeOrElement =
(XmlType.class.getName().equals(fqn)) || (XmlRootElement.class.getName().equals(fqn));
}
}
if (explicitXMLTypeOrElement) {
break;
}
}
return explicitXMLTypeOrElement;
}
@Override
public Image getColumnImage(Object element, int columnIndex) {
ProcessStep processStep = (ProcessStep) element;
Element el = null;
if (columnIndex > processStep.size()) return null;
if (columnIndex == 0) el = processStep.get(0);
if (columnIndex == 2) el = processStep.get(1);
if (columnIndex == 4) el = processStep.get(2);
if (el != null) {
if (el.getKind() == Element.Kind.Event) return EVENT;
if (el.getKind() == Element.Kind.Function) return FUNCTION;
if (el.getKind() == Element.Kind.Null) return NONE;
}
return null;
}
@Override
public void finished(TaskEvent e) {
if (e.getKind() != TaskEvent.Kind.ANALYZE) return;
if (!elements.remove(e.getTypeElement().getQualifiedName())) return;
if (e.getTypeElement().getSimpleName().contentEquals("MyClass")) {
Element owner = e.getTypeElement().getEnclosingElement();
if (owner.getKind() != ElementKind.PACKAGE)
throw new RuntimeException("class owner should be a package: " + owner);
if (owner.getAnnotationMirrors().size() != 1)
throw new RuntimeException("the owner package should have one annotation: " + owner);
}
}
@Override
public JsonType visitDeclared(DeclaredType declaredType, Void o) {
if (isJsonPrimitive(declaredType)) {
// 'primitive'-ish things
return new JsonPrimitive(declaredType.toString());
} else if (isInstanceOf(declaredType, Collection.class)) {
if (declaredType.getTypeArguments().size() == 0) {
return new JsonArray(new JsonPrimitive(Object.class.getName()));
} else {
TypeMirror elem = declaredType.getTypeArguments().get(0);
return new JsonArray(elem.accept(this, o));
}
} else if (isInstanceOf(declaredType, Map.class)) {
if (declaredType.getTypeArguments().size() == 0) {
return new JsonDict(
new JsonPrimitive(Object.class.getName()), new JsonPrimitive(Object.class.getName()));
} else {
TypeMirror key = declaredType.getTypeArguments().get(0);
TypeMirror val = declaredType.getTypeArguments().get(1);
return new JsonDict(key.accept(this, o), val.accept(this, o));
}
} else {
TypeElement element = (TypeElement) declaredType.asElement();
if (element.getKind() == ElementKind.ENUM) {
List<String> enumConstants = new ArrayList();
for (Element e : element.getEnclosedElements()) {
if (e.getKind() == ElementKind.ENUM_CONSTANT) {
enumConstants.add(e.toString());
}
}
JsonPrimitive primitive =
new JsonPrimitive(String.class.getName()); // TODO is this always a string?
primitive.setRestrictions(enumConstants);
return primitive;
} else {
return buildType(declaredType, element);
}
}
}
/** @throws IOException */
public List<Api> parse(TypeElement typeElement) throws IOException {
RequestMapping requestMapping = typeElement.getAnnotation(RequestMapping.class);
if (requestMapping == null) {
generator.log("Controller missing @RequestMapping, " + typeElement);
return null;
}
ApiDoc apiDoc = typeElement.getAnnotation(ApiDoc.class);
if (apiDoc == null) {
generator.log("Controller missing @ApiDoc, " + typeElement);
return null;
}
// printElement(typeElement);
List<Api> apiList = Lists.newArrayList();
String controllerName = typeElement.getQualifiedName().toString();
for (Element ele : typeElement.getEnclosedElements()) {
if (ele.getKind().equals(ElementKind.METHOD)
&& ele.getModifiers().contains(Modifier.PUBLIC)) {
Api api = new Api();
api.apiDoc = apiDoc;
api.packageMapping = requestMapping;
api.controllerName = controllerName;
ExecutableElement method = (ExecutableElement) ele;
this.parseMethod(api, method);
if (api.apiMethodDoc != null) {
apiList.add(api);
}
}
}
return apiList;
}
boolean isUnnamedPackage(Element e) {
return (e != null && e.getKind() == ElementKind.PACKAGE && ((PackageElement) e).isUnnamed());
}
// 循环处理每个需要处理的程序对象
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// 定义一个文件输出流，用于生成额外的文件
PrintStream ps = null;
try {
// 遍历每个被@Persistent修饰的class文件
for (Element t : roundEnv.getElementsAnnotatedWith(Persistent.class)) {
// 获取正在处理的类名
Name clazzName = t.getSimpleName();
// 获取类定义前的@Persistent Annotation
Persistent per = t.getAnnotation(Persistent.class);
// 创建文件输出流
ps = new PrintStream(new FileOutputStream(clazzName + ".hbm.xml"));
// 执行输出
ps.println("<?xml version=\"1.0\"?>");
ps.println("<!DOCTYPE hibernate-mapping PUBLIC");
ps.println(" \"-//Hibernate/Hibernate " + "Mapping DTD 3.0//EN\"");
ps.println(" \"http://www.hibernate.org/dtd/" + "hibernate-mapping-3.0.dtd\">");
ps.println("<hibernate-mapping>");
ps.print(" <class name=\"" + t);
// 输出per的table()的值
ps.println("\" table=\"" + per.table() + "\">");
for (Element f : t.getEnclosedElements()) {
// 只处理成员变量上的Annotation
if (f.getKind() == ElementKind.FIELD) // ①
{
// 获取成员变量定义前的@Id Annotation
Id id = f.getAnnotation(Id.class); // ②
// 当@Id Annotation存在时输出<id.../>元素
if (id != null) {
ps.println(
" <id name=\""
+ f.getSimpleName()
+ "\" column=\""
+ id.column()
+ "\" type=\""
+ id.type()
+ "\">");
ps.println(" <generator class=\"" + id.generator() + "\"/>");
ps.println(" </id>");
}
// 获取成员变量定义前的@Property Annotation
Property p = f.getAnnotation(Property.class); // ③
// 当@Property Annotation存在时输出<property.../>元素
if (p != null) {
ps.println(
" <property name=\""
+ f.getSimpleName()
+ "\" column=\""
+ p.column()
+ "\" type=\""
+ p.type()
+ "\"/>");
}
}
}
ps.println(" </class>");
ps.println("</hibernate-mapping>");
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (ps != null) {
try {
ps.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
System.out.println("processing: " + env.toString());
List<MethodToLog> methodToLogs = new ArrayList<>();
List<String> classNames = new ArrayList<>();
for (Element element : env.getElementsAnnotatedWith(XLog.class)) {
if (element.getKind() != ElementKind.METHOD
&& element.getKind() != ElementKind.CONSTRUCTOR
&& element.getKind() != ElementKind.CLASS) {
throw new IllegalStateException(
String.format(
"@%s annotation must be on as method, constructor or class.",
element.getSimpleName()));
}
if (element instanceof TypeElement) {
// class
String pkgName = ((TypeElement) element).getQualifiedName().toString();
if (!classNames.contains(pkgName)) {
classNames.add(pkgName);
}
} else if (element instanceof ExecutableElement) {
// method or constructor
ExecutableElement e = (ExecutableElement) element;
int type = XLogUtils.TYPE_METHOD;
if (e.getKind() == ElementKind.METHOD) {
type = XLogUtils.TYPE_METHOD;
} else if (e.getKind() == ElementKind.CONSTRUCTOR) {
type = XLogUtils.TYPE_CONSTRUCTOR;
}
TypeElement te = findEnclosingTypeElement(e);
System.out.println(te.getQualifiedName().toString() + "." + e.getSimpleName());
System.out.println(e.getReturnType());
List<String> parameters = new ArrayList<>();
List<String> parameterNames = new ArrayList<>();
for (VariableElement ve : e.getParameters()) {
System.out.println(ve.asType());
System.out.println(ve.getSimpleName());
parameters.add(ve.asType().toString());
parameterNames.add(ve.getSimpleName().toString());
}
MethodToLog methodToLog =
new MethodToLog(
type,
te.getQualifiedName().toString(),
e.getSimpleName().toString(),
parameters,
parameterNames);
methodToLogs.add(methodToLog);
if (!classNames.contains(methodToLog.getClassName())) {
classNames.add(methodToLog.getClassName());
}
}
}
if (methodToLogs.size() > 0) {
generateXLogProcessor("_" + MD5(env.toString()), methodToLogs, classNames);
}
return true;
}
/**
* Whether the specified declaration is throwable.
*
* @param declaration The declaration to determine whether it is throwable.
* @return Whether the specified declaration is throwable.
*/
protected boolean isThrowable(Element declaration) {
return declaration.getKind() == ElementKind.CLASS
&& ((DecoratedTypeMirror) declaration.asType()).isInstanceOf(Throwable.class);
}
