private void processFromProperties(TypeElement type, Set<TypeElement> types) { List<? extends Element> children = type.getEnclosedElements(); VisitorConfig config = conf.getConfig(type, children); // fields if (config.visitFieldProperties()) { for (VariableElement field : ElementFilter.fieldsIn(children)) { TypeElement typeElement = typeExtractor.visit(field.asType()); if (typeElement != null) { types.add(typeElement); } } } // getters if (config.visitMethodProperties()) { for (ExecutableElement method : ElementFilter.methodsIn(children)) { String name = method.getSimpleName().toString(); if ((name.startsWith("get") || name.startsWith("is")) && method.getParameters().isEmpty()) { TypeElement typeElement = typeExtractor.visit(method.getReturnType()); if (typeElement != null) { types.add(typeElement); } } } } }
private void parseMethod(Api api, ExecutableElement executableElement) throws IOException { Element actionElement = generator .getProcessingEnvironment() .getElementUtils() .getTypeElement(ApiMethodDoc.class.getName()); TypeMirror apiMethodDocType = actionElement.asType(); for (AnnotationMirror am : executableElement.getAnnotationMirrors()) { if (am.getAnnotationType().equals(apiMethodDocType)) { api.apiMethodDoc = Maps.newHashMap(); for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> ee : am.getElementValues().entrySet()) { api.apiMethodDoc.put(ee.getKey().getSimpleName().toString(), ee.getValue()); } break; } } // generator.log("apiMethodDoc: " + api.apiMethodDoc); if (null == api.apiMethodDoc) { generator.log("Method miss @ApiMethodDoc. " + executableElement); return; } api.methodName = executableElement.getSimpleName().toString(); api.methodMapping = executableElement.getAnnotation(RequestMapping.class); api.parameters = Lists.newArrayList(); for (VariableElement var : executableElement.getParameters()) { api.parameters.add(var); } }
private void parseSetter(ExecutableElement methodElement) { assert methodElement.getSimpleName().toString().startsWith("set"); assert methodElement.getParameters().size() == 2; final boolean isFactorySetter = methodElement .getParameters() .get(0) .asType() .toString() .equals(DynamicObjectFactory.class.getName()); final boolean isUnsafeSetter = methodElement.getSimpleName().toString().endsWith("Unsafe"); assert !(isFactorySetter && isUnsafeSetter); if (isFactorySetter) { assert methodElement.getParameters().get(0).getSimpleName().toString().equals("factory"); } else { assert methodElement .getParameters() .get(0) .asType() .toString() .equals(DynamicObject.class.getName()); assert methodElement.getParameters().get(0).getSimpleName().toString().equals("object"); } String name = titleToCamel(methodElement.getSimpleName().toString().substring("get".length())); if (isUnsafeSetter) { name = name.substring(0, name.length() - "Unsafe".length()); } final PropertyBuilder property = getProperty(name); if (isFactorySetter) { property.setHasFactorySetter(true); } else { if (isUnsafeSetter) { property.setHasUnsafeSetter(isUnsafeSetter); } else { property.setHasSetter(true); } } setPropertyType(property, methodElement.getParameters().get(1).asType()); }
private void parseGetter(ExecutableElement methodElement) { assert methodElement.getSimpleName().toString().startsWith("get"); assert methodElement.getParameters().size() == 1; final boolean isFactoryGetter = methodElement .getParameters() .get(0) .asType() .toString() .equals(DynamicObjectFactory.class.getName()); final boolean isObjectTypeGetter = methodElement.getParameters().get(0).asType().toString().equals(ObjectType.class.getName()); assert !(isFactoryGetter & isObjectTypeGetter); if (isFactoryGetter) { assert methodElement.getParameters().get(0).getSimpleName().toString().equals("factory"); } else if (isObjectTypeGetter) { assert methodElement.getParameters().get(0).getSimpleName().toString().equals("objectType"); } else { assert methodElement .getParameters() .get(0) .asType() .toString() .equals(DynamicObject.class.getName()); assert methodElement.getParameters().get(0).getSimpleName().toString().equals("object"); } final String name = titleToCamel(methodElement.getSimpleName().toString().substring("get".length())); final PropertyBuilder property = getProperty(name); if (isFactoryGetter) { property.setHasFactoryGetter(true); } else if (isObjectTypeGetter) { property.setHasObjectTypeGetter(true); } else { property.setHasGetter(true); } setPropertyType(property, methodElement.getReturnType()); }
private boolean isJsonBeanGetter(ExecutableElement executableElement) { if (executableElement.getKind() != ElementKind.METHOD) { return false; } if (executableElement.getReturnType().getKind() == TypeKind.NULL) { return false; } if (!(executableElement.getSimpleName().toString().startsWith("get") || executableElement.getSimpleName().toString().startsWith("is"))) { return false; } if (executableElement.getParameters().size() > 0) { return false; } return executableElement.getAnnotation(JsonIgnore.class) == null; }
private RequestMethod getRequestMethod( ExecutableElement executableElement, TypeElement cls, RequestMapping anno) { if (anno.method().length != 1) { throw new IllegalStateException( String.format( "The RequestMapping annotation for %s.%s is not parseable. Exactly one request method (GET/POST/etc) is required.", cls.getQualifiedName(), executableElement.getSimpleName())); } else { return anno.method()[0]; } }
private String addMethodPathComponent( ExecutableElement executableElement, TypeElement cls, String path, RequestMapping anno) { if (anno == null) { throw new IllegalArgumentException( String.format( "Method %s should have Request mapping annotation", executableElement.getSimpleName())); } if (anno.value() != null && anno.value().length > 0) { return Utils.joinPaths(path, anno.value()[0]); } return path; }
private Set<TypeElement> processDelegateMethods() { Set<Element> delegateMethods = (Set) getElements(QueryDelegate.class); Set<TypeElement> typeElements = new HashSet<TypeElement>(); for (Element delegateMethod : delegateMethods) { ExecutableElement method = (ExecutableElement) delegateMethod; Element element = delegateMethod.getEnclosingElement(); String name = method.getSimpleName().toString(); Type delegateType = typeFactory.getType(element.asType(), true); Type returnType = typeFactory.getType(method.getReturnType(), true); List<Parameter> parameters = elementHandler.transformParams(method.getParameters()); // remove first element parameters = parameters.subList(1, parameters.size()); EntityType entityType = null; for (AnnotationMirror annotation : delegateMethod.getAnnotationMirrors()) { if (TypeUtils.isAnnotationMirrorOfType(annotation, QueryDelegate.class)) { TypeMirror type = TypeUtils.getAnnotationValueAsTypeMirror(annotation, "value"); if (type != null) { entityType = typeFactory.getEntityType(type, true); } } } if (entityType != null) { registerTypeElement(entityType.getFullName(), (TypeElement) element); entityType.addDelegate( new Delegate(entityType, delegateType, name, parameters, returnType)); TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(entityType.getFullName()); boolean isAnnotated = false; for (Class<? extends Annotation> ann : conf.getEntityAnnotations()) { if (typeElement.getAnnotation(ann) != null) { isAnnotated = true; } } if (isAnnotated) { // handle also properties of entity type typeElements.add( processingEnv.getElementUtils().getTypeElement(entityType.getFullName())); } else { // skip handling properties context.extensionTypes.put(entityType.getFullName(), entityType); context.allTypes.put(entityType.getFullName(), entityType); } } } return typeElements; }
private void buildRequestBodies( ExecutableElement executableElement, RestDocumentation.Resource.Method doc) { List<VariableElement> requestBodies = new ArrayList<VariableElement>(); for (VariableElement var : executableElement.getParameters()) { if (var.getAnnotation(org.springframework.web.bind.annotation.RequestBody.class) != null) { requestBodies.add(var); } } if (requestBodies.size() > 1) { throw new IllegalStateException( String.format( "Method %s in class %s has multiple @RequestBody params", executableElement.getSimpleName(), executableElement.getEnclosingElement())); } if (requestBodies.size() == 1) { buildRequestBody(requestBodies.get(0), doc); } }
private void addFieldFromBeanMethod(JsonObject o, ExecutableElement executableElement) { if (!isJsonBeanGetter(executableElement)) { return; } TypeMirror type = executableElement.getReturnType(); String methodName = executableElement.getSimpleName().toString(); int trimLength = methodName.startsWith("is") ? 2 : 3; String beanName = methodName.substring(trimLength + 1, methodName.length()); beanName = methodName.substring(trimLength, trimLength + 1).toLowerCase() + beanName; // loop over the element's generic types, and build a concrete list from the owning context List<DeclaredType> concreteTypes = new ArrayList(); // replace variables with the current concrete manifestation if (type instanceof TypeVariable) { type = getDeclaredTypeForTypeVariable((TypeVariable) type); if (type == null) { return; // couldn't find a replacement -- must be a generics-capable type with no generics // info } } String docComment = processingEnv.getElementUtils().getDocComment(executableElement); if (type instanceof DeclaredType) { TypeElement element = (TypeElement) ((DeclaredType) type).asElement(); for (TypeParameterElement generic : element.getTypeParameters()) { concreteTypes.add(_typeArguments.get(generic.getSimpleName())); } Collection<DeclaredType> types = new HashSet<DeclaredType>(_typeRecursionGuard); types.add(_type); o.addField(beanName, newJsonType((DeclaredType) type, concreteTypes, types)) .setCommentText(docComment); } else { o.addField(beanName, newJsonType(type)).setCommentText(docComment); } }
@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; }