下面列出了javax.lang.model.element.ExecutableElement#getAnnotation ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
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());
}
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());
}
public String buildBody(ExecutableElement method) {
String body = "";
// TODO duplicated routine
retrofacebook.RetroFacebook.POST post = method.getAnnotation(retrofacebook.RetroFacebook.POST.class);
if (post == null) return body;
// TODO duplicated code
List<? extends VariableElement> parameters = method.getParameters();
for (VariableElement parameter : parameters) {
if (parameter.getAnnotation(retrofacebook.RetroFacebook.Body.class) != null) {
body = parameter.getSimpleName().toString();
}
}
return body;
}
public String buildPath(ExecutableElement method) {
// TODO duplicated routine
retroweibo.RetroWeibo.GET get = method.getAnnotation(retroweibo.RetroWeibo.GET.class);
retroweibo.RetroWeibo.POST post = method.getAnnotation(retroweibo.RetroWeibo.POST.class);
retroweibo.RetroWeibo.DELETE delete = method.getAnnotation(retroweibo.RetroWeibo.DELETE.class);
String fullPath = null;
if (get != null) fullPath = get.value();
if (post != null) fullPath = post.value();
if (delete != null) fullPath = delete.value();
List<? extends VariableElement> parameters = method.getParameters();
for (VariableElement parameter : parameters) {
retroweibo.RetroWeibo.Path path = parameter
.getAnnotation(retroweibo.RetroWeibo.Path.class);
if ((path != null) && (!path.value().equals("null"))) {
fullPath = fullPath.replace("{" + path.value() + "}", "\" + " +
parameter.getSimpleName().toString() + " + \"");
} else {
fullPath = fullPath.replace("{" + parameter.getSimpleName().toString() + "}", "\" + " +
parameter.getSimpleName().toString() + " + \"");
}
}
return "\"" + fullPath.replaceAll("\\?.+", "") + "\"";
}
private IntentMethodBinding getIntentMethodBinding(ExecutableElement element) throws InvalidTypeException {
IntentBuilder intentBuilder = element.getAnnotation(IntentBuilder.class);
String intentBuilderName = IntentBuilder.class.getName();
String action = null;
if (!isDefaultAnnotationElement(element, intentBuilderName, "action")) {
action = intentBuilder.action();
}
Element dataParam = getIntentData(element);
String dataParamName = null;
if (dataParam != null) {
dataParamName = dataParam.getSimpleName().toString();
}
boolean dataParamIsString = dataParam != null && types.isAssignable(dataParam.asType(), typeUtil.stringType);
Integer flags = null;
if (!isDefaultAnnotationElement(element, intentBuilderName, "flags")) {
flags = intentBuilder.flags();
}
String type = null;
if (!isDefaultAnnotationElement(element, intentBuilderName, "type")) {
type = intentBuilder.type();
}
IntentMethodBinding binding = new IntentMethodBinding(element.getSimpleName().toString(), getIntentBuilderClsValue(element), action,
dataParamName, flags, intentBuilder.categories(), type, dataParamIsString);
for (Element parameter : element.getParameters()) {
binding.addField(getIntentFieldBinding(parameter));
}
return binding;
}
private static boolean canCreateDiffModels(
ExecutableElement method,
List<Class<? extends Annotation>> delegateMethodAnnotationsThatSkipDiffModels) {
for (Class<? extends Annotation> delegate : delegateMethodAnnotationsThatSkipDiffModels) {
if (method.getAnnotation(delegate) != null) {
return false;
}
}
return true;
}
AnnotatedMethod(@NonNull ExecutableElement methodElement,
@NonNull Class<? extends Annotation> annotationClass) throws IllegalArgumentException {
Annotation annotation = methodElement.getAnnotation(annotationClass);
mAnnotatedMethodElement = methodElement;
mDelay = getDelayFromAnnotation(annotation);
mSensorType = getSensorTypeFromAnnotation(annotation);
if (mSensorType == INVALID_SENSOR) {
throw new IllegalArgumentException(String.format(
"No sensor type specified in @%s for method %s."
+ " Set a sensor type such as Sensor.TYPE_ACCELEROMETER.",
annotationClass.getSimpleName(), methodElement.getSimpleName().toString()));
}
}
@Override
public Void visitExecutable(ExecutableElement method, Object o) {
// Methods must be public
if (!method.getModifiers().contains(Modifier.PUBLIC))
return null;
if (processedMethod(method))
return null;
WebMethod webMethod = method.getAnnotation(WebMethod.class);
if (webMethod != null && webMethod.exclude())
return null;
SOAPBinding soapBinding = method.getAnnotation(SOAPBinding.class);
if (soapBinding == null && !method.getEnclosingElement().equals(typeElement)) {
if (method.getEnclosingElement().getKind().equals(ElementKind.CLASS)) {
soapBinding = method.getEnclosingElement().getAnnotation(SOAPBinding.class);
if (soapBinding != null)
builder.log("using " + method.getEnclosingElement() + "'s SOAPBinding.");
else {
soapBinding = new MySoapBinding();
}
}
}
boolean newBinding = false;
if (soapBinding != null) {
newBinding = pushSoapBinding(soapBinding, method, typeElement);
}
try {
if (shouldProcessMethod(method, webMethod)) {
processMethod(method, webMethod);
}
} finally {
if (newBinding) {
popSoapBinding();
}
}
return null;
}
public static AutoReducerInit parse(Env env, ExecutableElement executableElement, TypeMirror stateType) throws ValidationException {
if (executableElement.getAnnotation(AutoReducer.Action.class) != null) {
throw new ValidationException(executableElement, "Method %s should be may be annotated" +
" with either @AutoReducer.InitialState or @AutoReducer.Action but not both", executableElement);
}
ValidationUtils.validateReturnsState(env, stateType, executableElement);
ValidationUtils.validateIsNotPrivate(executableElement);
int paramsCount = executableElement.getParameters().size();
if (paramsCount != 0) {
throw new ValidationException(executableElement, "Method %s should not have any parameters", executableElement);
}
return new AutoReducerInit(executableElement);
}
Key forProvidesMethod(ExecutableType executableType, ExecutableElement e) {
checkNotNull(e);
checkArgument(e.getKind().equals(METHOD));
Provides providesAnnotation = e.getAnnotation(Provides.class);
checkArgument(providesAnnotation != null);
TypeMirror returnType = normalize(types, executableType.getReturnType());
switch (providesAnnotation.type()) {
case UNIQUE:
return new AutoValue_Key(
wrapOptionalInEquivalence(AnnotationMirrors.equivalence(), getQualifier(e)),
MoreTypes.equivalence().wrap(returnType));
case SET:
TypeMirror setType = types.getDeclaredType(getSetElement(), returnType);
return new AutoValue_Key(
wrapOptionalInEquivalence(AnnotationMirrors.equivalence(), getQualifier(e)),
MoreTypes.equivalence().wrap(setType));
case MAP:
AnnotationMirror mapKeyAnnotation = Iterables.getOnlyElement(getMapKeys(e));
MapKey mapKey =
mapKeyAnnotation.getAnnotationType().asElement().getAnnotation(MapKey.class);
TypeElement keyTypeElement =
mapKey.unwrapValue() ? Util.getKeyTypeElement(mapKeyAnnotation, elements)
: (TypeElement) mapKeyAnnotation.getAnnotationType().asElement();
TypeMirror valueType = types.getDeclaredType(getProviderElement(), returnType);
TypeMirror mapType =
types.getDeclaredType(getMapElement(), keyTypeElement.asType(), valueType);
return new AutoValue_Key(
wrapOptionalInEquivalence(AnnotationMirrors.equivalence(), getQualifier(e)),
MoreTypes.equivalence().wrap(mapType));
case SET_VALUES:
// TODO(gak): do we want to allow people to use "covariant return" here?
checkArgument(returnType.getKind().equals(DECLARED));
checkArgument(((DeclaredType) returnType).asElement().equals(getSetElement()));
return new AutoValue_Key(
wrapOptionalInEquivalence(AnnotationMirrors.equivalence(), getQualifier(e)),
MoreTypes.equivalence().wrap(returnType));
default:
throw new AssertionError();
}
}
@Hint(displayName = "#DN_org.netbeans.modules.java.hints.ClassStructure.finalMethodInFinalClass", description = "#DESC_org.netbeans.modules.java.hints.ClassStructure.finalMethodInFinalClass", category = "class_structure", enabled = false, suppressWarnings = {"FinalMethodInFinalClass"}) //NOI18N
@TriggerTreeKind(Kind.METHOD)
public static ErrorDescription finalMethodInFinalClass(HintContext context) {
final MethodTree mth = (MethodTree) context.getPath().getLeaf();
final Tree parent = context.getPath().getParentPath().getLeaf();
if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && mth.getModifiers().getFlags().contains(Modifier.FINAL) && ((ClassTree) parent).getModifiers().getFlags().contains(Modifier.FINAL)) {
// see defect #236974; although redundant, if the method is annotated with @SafeVarargs, we must permit final modifier.
ExecutableElement ee = (ExecutableElement)context.getInfo().getTrees().getElement(context.getPath());
if (ee == null || ee.getAnnotation(SafeVarargs.class) == null) {
return ErrorDescriptionFactory.forName(context, mth, NbBundle.getMessage(ClassStructure.class, "MSG_FinalMethodInFinalClass", mth.getName()), //NOI18N
FixFactory.removeModifiersFix(context.getInfo(), TreePath.getPath(context.getPath(), mth.getModifiers()), EnumSet.of(Modifier.FINAL), NbBundle.getMessage(ClassStructure.class, "FIX_RemoveFinalFromMethod", mth.getName()))); //NOI18N
}
}
return null;
}
private void collectOpMethods(
Multimap<String, MethodSpec> groupedMethods, TypeElement opClass, TypeElement annotation) {
boolean opClassDeprecated = opClass.getAnnotation(Deprecated.class) != null;
AnnotationMirror operatorAnnot = getAnnotationMirror(opClass, annotation.getQualifiedName());
if (operatorAnnot == null) {
throw new IllegalArgumentException(
"Annotation "
+ annotation.getSimpleName()
+ " not present on element "
+ opClass.getSimpleName());
}
String opGroup = getAnnotationElementValueAsString("group", operatorAnnot);
String opName = getAnnotationElementValueAsString("name", operatorAnnot);
if (Strings.isNullOrEmpty(opName)) {
opName = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, ClassName.get(opClass).simpleName());
}
// Build an endpoint for each method annotated with @Endpoint, which takes in parameter a scope
// and, optionally, a list of arguments
for (ExecutableElement opMethod : ElementFilter.methodsIn(opClass.getEnclosedElements())) {
AnnotationMirror endpointAnnot =
getAnnotationMirror(opMethod, elements.getName(T_ENDPOINT.toString()));
if (endpointAnnot != null) {
if (!opMethod.getModifiers().containsAll(Arrays.asList(Modifier.STATIC, Modifier.PUBLIC))) {
throw new IllegalArgumentException(
"Endpoint " + opMethod + " of class " + opClass + " must be static and public");
}
if (opMethod.getParameters().isEmpty() ||
!((TypeElement)types.asElement(opMethod.getParameters().get(0).asType())).getQualifiedName()
.equals(elements.getName(T_SCOPE.toString()))) {
throw new IllegalArgumentException(
"Endpoint " + opMethod + " of class " + opClass + " must take an instance of " + T_SCOPE
+ " as its first parameter");
}
String endpointGroup = getAnnotationElementValueAsString("group", endpointAnnot);
if (endpointGroup.isEmpty()) {
endpointGroup = opGroup;
}
String endpointName = getAnnotationElementValueAsString("name", endpointAnnot);
if (endpointName.isEmpty()) {
endpointName = opName;
}
boolean describeByClass =
getAnnotationElementValueAsBoolean("describeByClass", endpointAnnot, false);
boolean deprecated = opMethod.getAnnotation(Deprecated.class) != null || opClassDeprecated;
MethodSpec method = buildOpMethod(endpointName, opClass, opMethod, describeByClass, deprecated);
groupedMethods.put(endpointGroup, method);
}
}
}
private void createHandlerAdapter(String registerPackageName,
Map<TypeElement, List<ExecutableElement>> controllers) {
Map<String, List<String>> adapterMap = new HashMap<>();
for (Map.Entry<TypeElement, List<ExecutableElement>> entry : controllers.entrySet()) {
TypeElement type = entry.getKey();
List<ExecutableElement> executes = entry.getValue();
mLog.i(String.format("------ Processing %s ------", type.getSimpleName()));
String typeName = type.getQualifiedName().toString();
Mapping typeMapping = getTypeMapping(type);
validateMapping(typeMapping, typeName);
TypeName controllerType = TypeName.get(type.asType());
FieldSpec hostField = FieldSpec.builder(controllerType, "mHost", Modifier.PRIVATE).build();
FieldSpec mappingField = FieldSpec.builder(mMappingList, "mMappingMap", Modifier.PRIVATE).build();
CodeBlock.Builder rootCode = CodeBlock.builder()
.addStatement("this.mHost = new $T()", type)
.addStatement("this.mMappingMap = new $T<>()", LinkedHashMap.class);
for (ExecutableElement execute : executes) {
Mapping mapping = getExecuteMapping(execute);
validateExecuteMapping(mapping, typeName + "#" + execute.getSimpleName().toString() + "()");
mapping = new Merge(typeMapping, mapping);
rootCode.beginControlFlow("\n").addStatement("$T mapping = new $T()", mMapping, mMapping);
addMapping(rootCode, mapping);
Addition addition = execute.getAnnotation(Addition.class);
rootCode.add("\n").addStatement("$T addition = new $T()", mAddition, mAddition);
addAddition(rootCode, addition);
String handlerName = createHandler(type, execute, mapping.path(), mapping.isRest());
rootCode.addStatement("$L handler = new $L(mHost, mapping, addition, $L)", handlerName, handlerName,
mapping.isRest()).addStatement("mMappingMap.put(mapping, handler)").endControlFlow();
}
MethodSpec rootMethod = MethodSpec.constructorBuilder()
.addModifiers(Modifier.PUBLIC)
.addCode(rootCode.build())
.build();
MethodSpec mappingMethod = MethodSpec.methodBuilder("getMappingMap")
.addAnnotation(Override.class)
.addModifiers(Modifier.PROTECTED)
.returns(mMappingList)
.addStatement("return mMappingMap")
.build();
MethodSpec hostMethod = MethodSpec.methodBuilder("getHost")
.addAnnotation(Override.class)
.addModifiers(Modifier.PROTECTED)
.returns(controllerType)
.addStatement("return mHost")
.build();
String adapterPackageName = getPackageName(type).getQualifiedName().toString();
String className = String.format("%sAdapter", type.getSimpleName());
TypeSpec adapterClass = TypeSpec.classBuilder(className)
.addJavadoc(Constants.DOC_EDIT_WARN)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.superclass(mMappingAdapter)
.addField(hostField)
.addField(mappingField)
.addMethod(rootMethod)
.addMethod(mappingMethod)
.addMethod(hostMethod)
.build();
JavaFile javaFile = JavaFile.builder(adapterPackageName, adapterClass).build();
try {
javaFile.writeTo(mFiler);
} catch (IOException e) {
throw new RuntimeException(e);
}
String group = getGroup(type);
List<String> adapterList = adapterMap.get(group);
if (CollectionUtils.isEmpty(adapterList)) {
adapterList = new ArrayList<>();
adapterMap.put(group, adapterList);
}
adapterList.add(adapterPackageName + "." + className);
}
if (!adapterMap.isEmpty()) {
createRegister(registerPackageName, adapterMap);
}
}
public boolean hasMethodAnnotation(Class<? extends Annotation> a, ExecutableElement method) {
return method.getAnnotation(a)!=null;
}
public boolean hasMethodAnnotation(Class<? extends Annotation> a, ExecutableElement method) {
return method.getAnnotation(a)!=null;
}
protected boolean isLegalMethod(ExecutableElement method, TypeElement typeElement) {
WebMethod webMethod = method.getAnnotation(WebMethod.class);
//SEI cannot have methods with @WebMethod(exclude=true)
if (typeElement.getKind().equals(ElementKind.INTERFACE) && webMethod != null && webMethod.exclude())
builder.processError(WebserviceapMessages.WEBSERVICEAP_INVALID_SEI_ANNOTATION_ELEMENT_EXCLUDE("exclude=true", typeElement.getQualifiedName(), method.toString()), method);
// With https://jax-ws.dev.java.net/issues/show_bug.cgi?id=577, hasWebMethods has no effect
if (hasWebMethods && webMethod == null) // backwards compatibility (for legacyWebMethod computation)
return true;
if ((webMethod != null) && webMethod.exclude()) {
return true;
}
/*
This check is not needed as Impl class is already checked that it is not abstract.
if (typeElement instanceof TypeElement && method.getModifiers().contains(Modifier.ABSTRACT)) { // use Kind.equals instead of instanceOf
builder.processError(method.getPosition(), WebserviceapMessages.WEBSERVICEAP_WEBSERVICE_METHOD_IS_ABSTRACT(typeElement.getQualifiedName(), method.getSimpleName()));
return false;
}
*/
TypeMirror returnType = method.getReturnType();
if (!isLegalType(returnType)) {
builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_RETURN_TYPE_CANNOT_IMPLEMENT_REMOTE(typeElement.getQualifiedName(),
method.getSimpleName(),
returnType), method);
}
boolean isOneWay = method.getAnnotation(Oneway.class) != null;
if (isOneWay && !isValidOneWayMethod(method, typeElement))
return false;
SOAPBinding soapBinding = method.getAnnotation(SOAPBinding.class);
if (soapBinding != null) {
if (soapBinding.style().equals(SOAPBinding.Style.RPC)) {
builder.processError(WebserviceapMessages.WEBSERVICEAP_RPC_SOAPBINDING_NOT_ALLOWED_ON_METHOD(typeElement.getQualifiedName(), method.toString()), method);
}
}
int paramIndex = 0;
for (VariableElement parameter : method.getParameters()) {
if (!isLegalParameter(parameter, method, typeElement, paramIndex++))
return false;
}
if (!isDocLitWrapped() && soapStyle.equals(SOAPStyle.DOCUMENT)) {
VariableElement outParam = getOutParameter(method);
int inParams = getModeParameterCount(method, WebParam.Mode.IN);
int outParams = getModeParameterCount(method, WebParam.Mode.OUT);
if (inParams != 1) {
builder.processError(WebserviceapMessages.WEBSERVICEAP_DOC_BARE_AND_NO_ONE_IN(typeElement.getQualifiedName(), method.toString()), method);
}
if (returnType.accept(NO_TYPE_VISITOR, null)) {
if (outParam == null && !isOneWay) {
builder.processError(WebserviceapMessages.WEBSERVICEAP_DOC_BARE_NO_OUT(typeElement.getQualifiedName(), method.toString()), method);
}
if (outParams != 1) {
if (!isOneWay && outParams != 0)
builder.processError(WebserviceapMessages.WEBSERVICEAP_DOC_BARE_NO_RETURN_AND_NO_OUT(typeElement.getQualifiedName(), method.toString()), method);
}
} else {
if (outParams > 0) {
builder.processError(WebserviceapMessages.WEBSERVICEAP_DOC_BARE_RETURN_AND_OUT(typeElement.getQualifiedName(), method.toString()), outParam);
}
}
}
return true;
}
public boolean buildIsGet(ExecutableElement method) {
// TODO duplicated routine
return method.getAnnotation(retrofacebook.RetroFacebook.GET.class) != null;
}
private static List<DaoMethod> parserMethods(Element element) {
boolean isInterface = element.getKind().isInterface();
List<DaoMethod> methods = new ArrayList<DaoMethod>();
List<? extends Element> elems = element.getEnclosedElements();
for (Element e : elems) {
if (e instanceof ExecutableElement
&& e.getKind() == ElementKind.METHOD) {
ExecutableElement executableElement = (ExecutableElement) e;
TypeElement enclosingElement = (TypeElement) e
.getEnclosingElement();
if (isInterface || isAbstract(executableElement)) {
DaoMethod method = new DaoMethod();
String methodName = executableElement.getSimpleName()
.toString();
method.setMethodName(methodName);
String returnType = executableElement.getReturnType()
.toString();
method.setReturnType(returnType);
com.yoda.yodao.annotation.Query query = executableElement
.getAnnotation(com.yoda.yodao.annotation.Query.class);
if (query != null) {
method.setSql(query.value());
}
List<? extends VariableElement> parameters = executableElement
.getParameters();
int count = parameters.size();
if (parameters != null && count > 0) {
DaoParam[] params = new DaoParam[count];
for (int i = 0; i < count; i++) {
VariableElement param = parameters.get(i);
String paramType = param.asType().toString();
String paramName = param.getSimpleName().toString();
params[i] = new DaoParam(paramName, paramType);
}
method.setMethodParams(params);
}
method.setElement(e);
methods.add(method);
}
}
}
return methods;
}
public boolean buildIsPost(ExecutableElement method) {
// TODO duplicated routine
return method.getAnnotation(retrofacebook.RetroFacebook.POST.class) != null;
}
public static boolean isTerminal(ExecutableElement executableElement) {
return executableElement.getAnnotation(Terminal.class) != null;
}