下面列出了怎么用javax.lang.model.element.ExecutableElement的API类实例代码及写法,或者点击链接到github查看源代码。
protected int getModeParameterCount(ExecutableElement method, WebParam.Mode mode) {
WebParam webParam;
int cnt = 0;
for (VariableElement param : method.getParameters()) {
webParam = param.getAnnotation(WebParam.class);
if (webParam != null) {
if (webParam.header())
continue;
if (isEquivalentModes(mode, webParam.mode()))
cnt++;
} else {
if (isEquivalentModes(mode, WebParam.Mode.IN)) {
cnt++;
}
}
}
return cnt;
}
private static String formalArgsString(ExecutableElement method) {
List<? extends VariableElement> parameters = method.getParameters();
if (parameters.isEmpty()) {
return "";
} else {
return ""
+ Joiner.on(", ").join(
FluentIterable.from(parameters).transform(new Function<VariableElement, String>() {
@Override
public String apply(VariableElement element) {
return "" + element.getSimpleName();
}
}))
+ "";
}
}
@Test
public void testSingleElementArrayAnnotationMirrorValueWithSingleEntry() throws IOException {
compile(
Joiner.on('\n')
.join(
"@FooHelper(42)",
"public class Foo {",
"}",
"@interface FooHelper {",
" int[] value();",
"}"));
AnnotationMirror a = elements.getTypeElement("Foo").getAnnotationMirrors().get(0);
ExecutableElement keyElement = findMethod("value", elements.getTypeElement("FooHelper"));
@SuppressWarnings("unchecked")
List<AnnotationValue> values =
(List<AnnotationValue>) a.getElementValues().get(keyElement).getValue();
assertEquals(42, values.get(0).getValue());
assertEquals(1, a.getElementValues().size());
assertEquals(1, values.size());
}
@Test
void testMethod_notFound() throws Exception {
Class<?> target = ExpressionValidationDao.class;
addCompilationUnit(target);
addProcessor(
new TestProcessor() {
@Override
protected void run() {
ExecutableElement methodElement = createMethodElement(target, "testEmp", Emp.class);
Map<String, TypeMirror> parameterTypeMap = createParameterTypeMap(methodElement);
ExpressionValidator validator =
new ExpressionValidator(ctx, methodElement, parameterTypeMap);
ExpressionNode node = new ExpressionParser("emp.notFound(1, \"aaa\".length())").parse();
try {
validator.validate(node);
fail();
} catch (AptException expected) {
System.out.println(expected);
assertEquals(Message.DOMA4071, expected.getMessageResource());
}
}
});
compile();
assertTrue(getCompiledResult());
}
public Boolean visitExecutable(ExecutableElement method, Void nothing) {
if (!isVisible(method)) {
// ok
return false;
}
for (VariableElement v : method.getParameters()) {
if (stop) {
return false;
}
if (v.asType().accept(this, nothing)) {
return true;
}
}
return method.getReturnType().accept(this, nothing);
}
/**
* Resolves a {@link VariableElement} parameter to a method or constructor based on the given
* container, or a member of a class. For parameters to a method or constructor, the variable's
* enclosing element must be a supertype of the container type. For example, given a
* {@code container} of type {@code Set<String>}, and a variable corresponding to the {@code E e}
* parameter in the {@code Set.add(E e)} method, this will return a TypeMirror for {@code String}.
*/
public static TypeMirror asMemberOf(Types types, DeclaredType container,
VariableElement variable) {
if (variable.getKind().equals(ElementKind.PARAMETER)) {
ExecutableElement methodOrConstructor =
MoreElements.asExecutable(variable.getEnclosingElement());
ExecutableType resolvedMethodOrConstructor =
MoreTypes.asExecutable(types.asMemberOf(container, methodOrConstructor));
List<? extends VariableElement> parameters = methodOrConstructor.getParameters();
List<? extends TypeMirror> parameterTypes = resolvedMethodOrConstructor.getParameterTypes();
checkState(parameters.size() == parameterTypes.size());
for (int i = 0; i < parameters.size(); i++) {
// We need to capture the parameter type of the variable we're concerned about,
// for later printing. This is the only way to do it since we can't use
// types.asMemberOf on variables of methods.
if (parameters.get(i).equals(variable)) {
return parameterTypes.get(i);
}
}
throw new IllegalStateException("Could not find variable: " + variable);
} else {
return types.asMemberOf(container, variable);
}
}
private void validateParameters(
TypeElement annotationElement,
ExecutableElement method,
ImmutableMap<String, Member> members,
ImmutableMap<String, Parameter> parameters,
ImmutableMap<String, AnnotationValue> defaultValues) {
boolean error = false;
for (String memberName : members.keySet()) {
if (!parameters.containsKey(memberName) && !defaultValues.containsKey(memberName)) {
reportError(
method,
"@AutoAnnotation method needs a parameter with name '%s' and type %s"
+ " corresponding to %s.%s, which has no default value",
memberName,
members.get(memberName).getType(),
annotationElement,
memberName);
error = true;
}
}
if (error) {
throw new AbortProcessingException();
}
}
/** Find a toBuilder method, if the user has provided one. */
private boolean hasToBuilderMethod(
DeclaredType builder,
boolean isExtensible,
Iterable<ExecutableElement> methods) {
for (ExecutableElement method : methods) {
if (isToBuilderMethod(builder, method)) {
if (!isExtensible) {
messager.printMessage(ERROR,
"No accessible no-args Builder constructor available to implement toBuilder",
method);
}
return true;
}
}
return false;
}
static MethodSpec generate(TypeElement element) {
ClassName.get(element).reflectionName();
Builder result =
MethodSpec.methodBuilder("toString")
.addModifiers(Modifier.PUBLIC)
.returns(String.class)
.addAnnotation(Override.class)
.addCode(
CodeBlock.builder()
.add(
"StringBuilder sb = new StringBuilder(\"@$L\");\n",
ClassName.get(element).reflectionName().replace('$', '.'))
.build());
List<ExecutableElement> methods = ElementFilter.methodsIn(element.getEnclosedElements());
if (!methods.isEmpty()) {
result.addCode("sb.append('(');\n");
}
for (ExecutableElement method : methods) {
result.addCode("sb.append(\"$1L=\").append($1L);\n", method.getSimpleName());
}
if (!methods.isEmpty()) {
result.addCode("sb.append(')');\n");
}
result.addCode("return sb.toString();\n");
return result.build();
}
/**
* Returns a new method spec builder that overrides {@code method} as a member of {@code
* enclosing}. This will resolve type parameters: for example overriding {@link
* Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T}
* parameter will be resolved to {@code Movie}.
*
* <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and
* throws declarations. An {@link Override} annotation will be added.
*
* <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and
* parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately.
*/
public static Builder overriding(
ExecutableElement method, DeclaredType enclosing, Types types) {
ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method);
List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes();
TypeMirror resolvedReturnType = executableType.getReturnType();
Builder builder = overriding(method);
builder.returns(TypeName.get(resolvedReturnType));
for (int i = 0, size = builder.parameters.size(); i < size; i++) {
ParameterSpec parameter = builder.parameters.get(i);
TypeName type = TypeName.get(resolvedParameterTypes.get(i));
builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build());
}
return builder;
}
/** Returns a bi-map between property names and the corresponding abstract property methods. */
final ImmutableBiMap<String, ExecutableElement> propertyNameToMethodMap(
Set<ExecutableElement> propertyMethods) {
Map<String, ExecutableElement> map = new LinkedHashMap<>();
Set<String> reportedDups = new HashSet<>();
boolean allPrefixed = gettersAllPrefixed(propertyMethods);
for (ExecutableElement method : propertyMethods) {
String methodName = method.getSimpleName().toString();
String name = allPrefixed ? nameWithoutPrefix(methodName) : methodName;
ExecutableElement old = map.put(name, method);
if (old != null) {
List<ExecutableElement> contexts = new ArrayList<>(Arrays.asList(method));
if (reportedDups.add(name)) {
contexts.add(old);
}
// Report the error for both of the methods. If this is a third or further occurrence,
// reportedDups prevents us from reporting more than one error for the same method.
for (ExecutableElement context : contexts) {
errorReporter.reportError(
context, "More than one @%s property called %s", simpleAnnotationName, name);
}
}
}
return ImmutableBiMap.copyOf(map);
}
protected boolean hasWebMethods(TypeElement element) {
if (element.getQualifiedName().toString().equals(Object.class.getName()))
return false;
WebMethod webMethod;
for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {
webMethod = method.getAnnotation(WebMethod.class);
if (webMethod != null) {
if (webMethod.exclude()) {
if (webMethod.operationName().length() > 0)
builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_WEBMETHOD_ELEMENT_WITH_EXCLUDE(
"operationName", element.getQualifiedName(), method.toString()), method);
if (webMethod.action().length() > 0)
builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_WEBMETHOD_ELEMENT_WITH_EXCLUDE(
"action", element.getQualifiedName(), method.toString()), method);
} else {
return true;
}
}
}
return false;//hasWebMethods(d.getSuperclass().getDeclaration());
}
private void validateMethodVisibility(ExecutableElement method, AnnotationHandle annotation, String type, TypeHandle target,
MethodHandle targetMethod) {
Visibility visTarget = targetMethod.getVisibility();
if (visTarget == null) {
return;
}
Visibility visMethod = TypeUtils.getVisibility(method);
String visibility = "visibility of " + visTarget + " method in " + target;
if (visTarget.ordinal() > visMethod.ordinal()) {
this.printMessage(Kind.WARNING, visMethod + " " + type + " method cannot reduce " + visibility, method, annotation,
SuppressedBy.VISIBILITY);
} else if (visTarget == Visibility.PRIVATE && visMethod.ordinal() > visTarget.ordinal()) {
this.printMessage(Kind.WARNING, visMethod + " " + type + " method will upgrade " + visibility, method, annotation,
SuppressedBy.VISIBILITY);
}
}
public void testSimplyAnnotatedMethod() throws Exception {
TestUtilities.copyStringToFileObject(srcFO, "MyClass.java",
"public class MyClass {" +
" @javax.annotation.Resource" +
" private void setMyResource(javax.sql.DataSource dataSource) {" +
" }" +
"}");
IndexingManager.getDefault().refreshIndexAndWait(srcFO.getURL(), null);
ClasspathInfo cpi = ClasspathInfo.create(srcFO);
final AnnotationModelHelper annotationModelHelper = AnnotationModelHelper.create(cpi);
annotationModelHelper.runJavaSourceTask(new Runnable() {
public void run() {
TypeElement myClass = annotationModelHelper.getCompilationController().getElements().getTypeElement("MyClass");
List<ExecutableElement> methods = ElementFilter.methodsIn(myClass.getEnclosedElements());
ExecutableElement annotatedMethod = methods.get(0);
ResourceImpl resource = new ResourceImpl(annotatedMethod, myClass, annotationModelHelper);
assertEquals("myResource", resource.getName());
assertEquals("javax.sql.DataSource", resource.getType());
assertEquals(ResourceImpl.DEFAULT_AUTHENTICATION_TYPE, resource.getAuthenticationType());
assertEquals(ResourceImpl.DEFAULT_SHAREABLE, resource.getShareable());
assertEquals(ResourceImpl.DEFAULT_MAPPED_NAME, resource.getMappedName());
assertEquals(ResourceImpl.DEFAULT_DESCRIPTION, resource.getDescription());
}
});
}
private ImmutableSet<String> collectThrownCheckedExceptions() {
Set<String> exceptions = new HashSet<>(2);
Environment env = protoclass().environment();
for (TypeMirror thrown : ((ExecutableElement) element).getThrownTypes()) {
if (env.isCheckedException(thrown)) {
exceptions.add(thrown.toString());
}
}
return ImmutableSet.copyOf(exceptions);
}
public static boolean allTypeVarsAccessible(Collection<TypeVariable> typeVars, Element target) {
if (target == null) {
return typeVars.isEmpty();
}
Set<TypeVariable> targetTypeVars = new HashSet<TypeVariable>();
OUTER: while (target.getKind() != ElementKind.PACKAGE) {
Iterable<? extends TypeParameterElement> tpes;
switch (target.getKind()) {
case ANNOTATION_TYPE:
case CLASS:
case ENUM:
case INTERFACE:
tpes = ((TypeElement) target).getTypeParameters();
break;
case METHOD:
case CONSTRUCTOR:
tpes = ((ExecutableElement) target).getTypeParameters();
break;
default:
break OUTER;
}
for (TypeParameterElement tpe : tpes) {
targetTypeVars.add((TypeVariable) tpe.asType());
}
if (target.getModifiers().contains(Modifier.STATIC)) {
break;
}
target = target.getEnclosingElement();
}
return targetTypeVars.containsAll(typeVars);
}
@Override
protected void processMethod(ExecutableElement method, WebMethod webMethod) {
builder.log("WrapperGen - method: "+method);
builder.log("method.getDeclaringType(): " + method.asType());
if (wrapped && soapStyle.equals(SOAPStyle.DOCUMENT)) {
generateWrappers(method, webMethod);
}
generateExceptionBeans(method);
}
private List<ExecutableElement> getMethods(CompilationController controller, TypeElement classElement) throws IOException {
List<? extends Element> members = classElement.getEnclosedElements();
List<ExecutableElement> methods = ElementFilter.methodsIn(members);
List<ExecutableElement> publicMethods = new ArrayList<ExecutableElement>();
for (ExecutableElement m:methods) {
//Set<Modifier> modifiers = method.getModifiers();
//if (modifiers.contains(Modifier.PUBLIC)) {
publicMethods.add(m);
//}
}
return publicMethods;
}
public String createInternalEventName(ExecutableElement executableElement) {
String internalEventname = executableElement.getSimpleName()
.toString();
for (VariableElement variableElement : executableElement.getParameters()) {
internalEventname += ProcessorConstants.PARAMETER_DELIMITER;
internalEventname += variableElement.asType()
.toString()
.replace(".",
"_");
}
return internalEventname;
}
private Mapping getExecuteMapping(ExecutableElement execute) {
Mapping mapping = null;
RequestMapping requestMapping = execute.getAnnotation(RequestMapping.class);
boolean isRest = execute.getAnnotation(ResponseBody.class) != null;
if (requestMapping != null) {
mapping = new Any(requestMapping, isRest);
}
if (mapping == null) {
GetMapping getMapping = execute.getAnnotation(GetMapping.class);
if (getMapping != null) {
mapping = new Get(getMapping, isRest);
}
}
if (mapping == null) {
PostMapping postMapping = execute.getAnnotation(PostMapping.class);
if (postMapping != null) {
mapping = new Post(postMapping, isRest);
}
}
if (mapping == null) {
PutMapping putMapping = execute.getAnnotation(PutMapping.class);
if (putMapping != null) {
mapping = new Put(putMapping, isRest);
}
}
if (mapping == null) {
PatchMapping patchMapping = execute.getAnnotation(PatchMapping.class);
if (patchMapping != null) {
mapping = new Patch(patchMapping, isRest);
}
}
if (mapping == null) {
DeleteMapping deleteMapping = execute.getAnnotation(DeleteMapping.class);
if (deleteMapping != null) {
mapping = new Delete(deleteMapping, isRest);
}
}
return mapping;
}
private void checkMethodParameters(Set<TypeElement> classes) {
Types types = processingEnv.getTypeUtils();
for (TypeElement te: classes) {
for (ExecutableElement ee: ElementFilter.methodsIn(te.getEnclosedElements())) {
for (VariableElement ve: ee.getParameters()) {
TypeMirror tm = ve.asType();
checkMethodParametersVisitor.visit(tm, types);
}
}
}
}
Map<? extends ExecutableElement, ? extends AnnotationValue> getElementValuesWithDefaults(
AnnotationMirror annotation) {
DeclaredType type = annotation.getAnnotationType();
Map<ExecutableElement, AnnotationValue> map = new LinkedHashMap<>(
annotation.getElementValues());
for (ExecutableElement method : getMethods((TypeElement) type.asElement())) {
AnnotationValue defaultValue = method.getDefaultValue();
if (defaultValue != null && !map.containsKey(method)) {
map.put(method, defaultValue);
}
}
return map;
}
public static void generateConstructors(WorkingCopy wc, TreePath path, Iterable<? extends VariableElement> initFields, List<? extends ExecutableElement> inheritedConstructors, int offset) {
ClassTree clazz = (ClassTree)path.getLeaf();
TypeElement te = (TypeElement) wc.getTrees().getElement(path);
GeneratorUtilities gu = GeneratorUtilities.get(wc);
List<Tree> members = new ArrayList<>();
for (ExecutableElement inheritedConstructor : inheritedConstructors) {
members.add(gu.createConstructor(te, initFields, inheritedConstructor));
}
wc.rewrite(clazz, insertClassMembers(wc, clazz, members, offset));
}
private synchronized void populateValues() {
if (valueCache == null) {
valueCache = new HashMap<>();
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
TreeBackedElements.getElementValuesWithDefaultsStatic(mirror).entrySet()) {
valueCache.put(entry.getKey().getSimpleName().toString(), entry.getValue());
}
}
}
final ImmutableListMultimap<ExecutableElement, AnnotationMirror> propertyMethodAnnotationMap(
TypeElement type, ImmutableSet<ExecutableElement> propertyMethods) {
ImmutableListMultimap.Builder<ExecutableElement, AnnotationMirror> builder =
ImmutableListMultimap.builder();
for (ExecutableElement propertyMethod : propertyMethods) {
builder.putAll(propertyMethod, propertyMethodAnnotations(type, propertyMethod));
}
return builder.build();
}
public String mangleMethod(ExecutableElement method, TypeElement clazz,
int mtype) throws TypeSignature.SignatureException {
StringBuilder result = new StringBuilder(100);
result.append("Java_");
if (mtype == Mangle.Type.METHOD_JDK_1) {
result.append(mangle(clazz.getQualifiedName(), Mangle.Type.CLASS));
result.append('_');
result.append(mangle(method.getSimpleName(),
Mangle.Type.FIELD));
result.append("_stub");
return result.toString();
}
/* JNI */
result.append(mangle(getInnerQualifiedName(clazz), Mangle.Type.JNI));
result.append('_');
result.append(mangle(method.getSimpleName(),
Mangle.Type.JNI));
if (mtype == Mangle.Type.METHOD_JNI_LONG) {
result.append("__");
String typesig = signature(method);
TypeSignature newTypeSig = new TypeSignature(elems);
String sig = newTypeSig.getTypeSignature(typesig, method.getReturnType());
sig = sig.substring(1);
sig = sig.substring(0, sig.lastIndexOf(')'));
sig = sig.replace('/', '.');
result.append(mangle(sig, Mangle.Type.JNI));
}
return result.toString();
}
private boolean isObservesParameter( VariableElement element,
ExecutableElement method , List<? extends AnnotationMirror> annotations )
throws org.netbeans.modules.web.beans.api.model.InjectionPointDefinitionError
{
List<? extends VariableElement> parameters = method.getParameters();
boolean observesFound = false;
for (VariableElement variableElement : parameters) {
if ( AnnotationObjectProvider.hasAnnotation(variableElement,
OBSERVES_ANNOTATION, getModel().getHelper()))
{
if ( observesFound ){
throw new org.netbeans.modules.web.beans.api.model.
InjectionPointDefinitionError(method,
NbBundle.getMessage(WebBeansModelImplementation.class,
"ERR_MultipleObserves" , method.getSimpleName()));
}
observesFound = true;
}
}
if ( !observesFound ){
return false;
}
String badAnnotation = checkInjectProducers(annotations);
if ( badAnnotation != null ){
throw new org.netbeans.modules.web.beans.api.model.
InjectionPointDefinitionError( method,
NbBundle.getMessage(WebBeansModelImplementation.class,
"ERR_ObserverHasInjectOrProduces" , method.getSimpleName(),
badAnnotation ));
}
return observesFound;
}
/**
* Filter the annotation type members and return either the required
* members or the optional members, depending on the value of the
* required parameter.
*
* @param typeElement The annotation type to process.
* @param required
* @return the annotation type members and return either the required
* members or the optional members, depending on the value of the
* required parameter.
*/
private List<Element> filterAnnotations(TypeElement typeElement, boolean required) {
List<Element> members = utils.getAnnotationMethods(typeElement);
List<Element> targetMembers = new ArrayList<>();
for (Element member : members) {
ExecutableElement ee = (ExecutableElement)member;
if ((required && ee.getDefaultValue() == null)
|| ((!required) && ee.getDefaultValue() != null)) {
targetMembers.add(member);
}
}
return targetMembers;
}
private static boolean hasStringArrayConstructor(TypeElement element) {
for (ExecutableElement e : ElementFilter.constructorsIn(element.getEnclosedElements())) {
if (e.getModifiers().contains(Modifier.PUBLIC) && e.getParameters().size() == 1) {
if (isArrayOfStrings(e.getParameters().get(0).asType())) {
return true;
}
}
}
return false;
}
private void addMethodOrConstructorToAnnotationDatabase(ExecutableElement methodOrConstructorElement, int level) {
String methodOrConstructorName = methodOrConstructorElement.getSimpleName().toString();
//System.out.printf("Type: %s, injection: %s \n",typeElementName, methodOrConstructorName);
if (methodOrConstructorName.startsWith("<init>")) {
addConstructor(methodOrConstructorElement, level);
} else {
addMethod(methodOrConstructorElement, level);
}
}