Java Code Examples for java.lang.reflect.Parameter#getAnnotation()

/**
 * Scans the event type and forms a map of event data expression (for
 * {@link com.vaadin.flow.dom.DomListenerRegistration#addEventData(String)}
 * ) to Java type, with the same order as the parameters for the event
 * constructor (as returned by {@link #getEventConstructor(Class)}).
 *
 * @return a map of event data expressions, in the order defined by the
 *         component event constructor parameters
 */
private static LinkedHashMap<String, Class<?>> findEventDataExpressions(
        Constructor<? extends ComponentEvent<?>> eventConstructor) {
    LinkedHashMap<String, Class<?>> eventDataExpressions = new LinkedHashMap<>();
    // Parameter 0 is always "Component source"
    // Parameter 1 is always "boolean fromClient"
    for (int i = 2; i < eventConstructor.getParameterCount(); i++) {
        Parameter p = eventConstructor.getParameters()[i];
        EventData eventData = p.getAnnotation(EventData.class);
        if (eventData == null || eventData.value().isEmpty()) {
            // The parameter foo of the constructor Bar(Foo foo) has no
            // @DomEvent, or its value is empty."
            throw new IllegalArgumentException(String.format(
                    "The parameter %s of the constructor %s has no @%s, or the annotation value is empty",
                    p.getName(), eventConstructor.toString(),
                    EventData.class.getSimpleName()));
        }
        eventDataExpressions.put(eventData.value(),p.getType());
    }
    return eventDataExpressions;
}
 

public SelenideConfig getSelenideConfig(Parameter parameter,
        Optional<Object> testInstance) throws IllegalAccessException {

    SelenideConfig config = new SelenideConfig();
    if (parameter != null) {
        // @SelenideConfiguration as parameter
        SelenideConfiguration selenideConfiguration = parameter
                .getAnnotation(SelenideConfiguration.class);
        if (selenideConfiguration != null) {
            config.browser(selenideConfiguration.browser());
            config.headless(selenideConfiguration.headless());
            config.browserBinary(selenideConfiguration.browserBinary());
        }

        // @SelenideConfiguration as field
        SelenideConfig globalConfig = annotationsReader
                .getFromAnnotatedField(testInstance,
                        SelenideConfiguration.class, SelenideConfig.class);
        if (globalConfig != null) {
            config = globalConfig;
        }
    }

    return config;
}
 

/**
 * Checks if the given constructor can be used when firing a
 * {@link ComponentEvent} based on a {@link DomEvent}.
 *
 * @param constructor
 *            the constructor to check
 * @return <code>true</code> if the constructor can be used,
 *         <code>false</code> otherwise
 */
public static boolean isDomEventConstructor(Constructor<?> constructor) {
    if (constructor.getParameterCount() < 2) {
        return false;
    }
    if (!Component.class
            .isAssignableFrom(constructor.getParameterTypes()[0])) {
        return false;
    }
    if (constructor.getParameterTypes()[1] != boolean.class) {
        return false;
    }
    for (int param = 2; param < constructor.getParameterCount(); param++) {
        Parameter p = constructor.getParameters()[param];

        if (p.getAnnotation(EventData.class) == null) {
            return false;
        }
    }

    return true;
}
 

private JaxrsQueryParameter jaxrsQueryParameter(Class<?> clz, Method method, Parameter parameter) {
	JaxrsParameterDescribe jaxrsParameterDescribe = parameter.getAnnotation(JaxrsParameterDescribe.class);
	QueryParam queryParam = parameter.getAnnotation(QueryParam.class);
	JaxrsQueryParameter o = new JaxrsQueryParameter();
	if (null != jaxrsParameterDescribe) {
		o.setDescription(jaxrsParameterDescribe.value());
	} else {
		logger.print("类: {}, 方法: {} ,未设置参数 {} 的JaxrsParameterDescribe.", clz.getName(), method.getName(),
				queryParam.value());
		o.setDescription("");
	}
	o.setName(queryParam.value());
	o.setType(this.simpleType(parameter.getType().getName()));
	return o;
}
 

private void findPayloadParameter(){
	if(this.method.getParameterCount() == 0){
		throw new IllegalStateException("Service methods must have at least one receiving parameter");
	}

	else if(this.method.getParameterCount() == 1){
		this.payloadParameter = new MethodParameter(this.method, 0);
	}
	int payloadAnnotations = Flux.just(this.method.getParameters())
			.filter(parameter -> parameter.getAnnotation(Payload.class) != null)
			.reduce(0, (a, parameter) -> { return a+1; })
			.block();
	if(payloadAnnotations > 1){
		throw new IllegalStateException("Service methods can have at most one @Payload annotated parameters");
	}

	for(int i=0; i<this.method.getParameters().length; i++){
		Parameter p = this.method.getParameters()[i];
		if(p.getAnnotation(Payload.class) != null){
			this.payloadParameter = new MethodParameter(this.method, i);
			break;
		}
	}
	if(this.payloadParameter == null){
		throw new IllegalStateException("Service methods annotated with more than one parameter must declare one @Payload parameter");
	}
	resolvePayloadType();
}
 

/**
 * Returns the name of a parameter.
 *
 * @param parameter
 * @return the name of a parameter.
 */
public static String getParameterName(Parameter parameter) {
    // identify parameter name and pattern from controllerMethod signature
    String methodParameterName = parameter.getName();
    if (parameter.isAnnotationPresent(Param.class)) {
        Param param = parameter.getAnnotation(Param.class);
        if (!StringUtils.isNullOrEmpty(param.value())) {
            methodParameterName = param.value();
        }
    }

    return methodParameterName;
}
 

private JaxrsQueryParameter jaxrsQueryParameter(Class<?> clz, Method method, Parameter parameter) {
	JaxrsParameterDescribe jaxrsParameterDescribe = parameter.getAnnotation(JaxrsParameterDescribe.class);
	QueryParam queryParam = parameter.getAnnotation(QueryParam.class);
	JaxrsQueryParameter o = new JaxrsQueryParameter();
	if (null != jaxrsParameterDescribe) {
		o.setDescription(jaxrsParameterDescribe.value());
	} else {
		logger.print("类: {}, 方法: {} ,未设置参数 {} 的JaxrsParameterDescribe.", clz.getName(), method.getName(),
				queryParam.value());
		o.setDescription("");
	}
	o.setName(queryParam.value());
	o.setType(this.simpleType(parameter.getType().getName()));
	return o;
}
 

private boolean validateOnPongMethod(Object webSocketEndpoint)
        throws WebSocketMethodParameterException, WebSocketEndpointMethodReturnTypeException {
    EndpointDispatcher dispatcher = new EndpointDispatcher();
    Method method;
    if (dispatcher.getOnPongMessageMethod(webSocketEndpoint).isPresent()) {
        method = dispatcher.getOnPongMessageMethod(webSocketEndpoint).get();
    } else {
        return true;
    }
    validateReturnType(method);
    boolean foundPrimaryPong = false;
    for (Parameter parameter: method.getParameters()) {
        Class<?> paraType = parameter.getType();
        if (paraType == String.class) {
            if (parameter.getAnnotation(PathParam.class) == null) {
                throw new WebSocketMethodParameterException("Invalid parameter found on pong message method: " +
                                                                    "string parameter without " +
                                                                    "@PathParam annotation.");
            }
        } else if (paraType == PongMessage.class) {
            if (foundPrimaryPong) {
                throw new WebSocketMethodParameterException("Invalid parameter found on pong message method: " +
                                                                    "only one PongMessage should be declared.");
            }
            foundPrimaryPong = true;
        } else if (paraType != WebSocketConnection.class) {
            throw new WebSocketMethodParameterException("Invalid parameter found on pong message method: " +
                                                                paraType);
        }
    }
    return foundPrimaryPong;
}
 

@Override
public DataBinder build(Parameter parameter) {
  DataBinder dataBinder = new DataBinder();
  dataBinder.setType(parameter.getType());
  dataBinder.setName(parameter.getName());
  MultipartParam param = parameter.getAnnotation(MultipartParam.class);
  if (param != null && param.value().length() > 0) {
    dataBinder.setName(param.value());
  }
  dataBinder.setFunc(ctx -> ctx.request().getMultipartItem(dataBinder.getName()));
  return dataBinder;
}
 

@Override
public MutableCapabilities getOptions(Parameter parameter,
        Optional<Object> testInstance)
        throws IOException, IllegalAccessException {
    OperaOptions operaOptions = new OperaOptions();

    if (parameter != null) {
        // @Arguments
        Arguments arguments = parameter.getAnnotation(Arguments.class);
        if (arguments != null) {
            stream(arguments.value()).forEach(operaOptions::addArguments);
        }

        // @Extensions
        Extensions extensions = parameter.getAnnotation(Extensions.class);
        if (extensions != null) {
            for (String extension : extensions.value()) {
                operaOptions.addExtensions(getExtension(extension));
            }
        }

        // @Binary
        Binary binary = parameter.getAnnotation(Binary.class);
        if (binary != null) {
            operaOptions.setBinary(binary.value());
        }

        // @Options
        OperaOptions optionsFromAnnotatedField = annotationsReader
                .getFromAnnotatedField(testInstance, Options.class,
                        OperaOptions.class);
        if (optionsFromAnnotatedField != null) {
            operaOptions = optionsFromAnnotatedField.merge(operaOptions);
        }
    }

    return operaOptions;
}
 

protected Object defaultValue(Parameter parameter, AnnotatedType parameterType, GlobalEnvironment environment) {

        GraphQLArgument meta = parameter.getAnnotation(GraphQLArgument.class);
        if (meta == null) return null;
        try {
            return defaultValueProvider(meta.defaultValueProvider(), environment)
                    .getDefaultValue(parameter, environment.getMappableInputType(parameterType), ReservedStrings.decode(environment.messageBundle.interpolate(meta.defaultValue())));
        } catch (ReflectiveOperationException e) {
            throw new IllegalArgumentException(
                    meta.defaultValueProvider().getName() + " must expose a public default constructor, or a constructor accepting " + GlobalEnvironment.class.getName(), e);
        }
    }
 

/**
 * 查询标识有指定注解的参数
 *
 * @param clazz      待查找的类型
 * @param parameters 参数类型集
 * @return 参数类型
 */
public static Parameter findParameter(Class<? extends Annotation> clazz, Parameter[] parameters) {
    for (Parameter parameter : parameters) {
        if (parameter.getAnnotation(clazz) != null) {
            return parameter;
        }
    }
    return null;
}
 

private JaxrsPathParameter jaxrsPathParameter(Class<?> clz, Method method, Parameter parameter) throws Exception {
	JaxrsParameterDescribe jaxrsParameterDescribe = parameter.getAnnotation(JaxrsParameterDescribe.class);
	PathParam pathParam = parameter.getAnnotation(PathParam.class);
	JaxrsPathParameter o = new JaxrsPathParameter();
	o.setName(pathParam.value());
	if (null != jaxrsParameterDescribe) {
		o.setDescription(jaxrsParameterDescribe.value());
	} else {
		logger.print("类: {}, 方法: {} ,未设置参数 {} 的JaxrsParameterDescribe.", clz.getName(), method.getName(),
				pathParam.value());
		o.setDescription("");
	}
	o.setType(this.getJaxrsParameterType(parameter));
	return o;
}
 

private boolean validateOnStringMethod(Object webSocketEndpoint)
        throws WebSocketMethodParameterException, WebSocketEndpointMethodReturnTypeException {
    EndpointDispatcher dispatcher = new EndpointDispatcher();
    Method method;
    if (dispatcher.getOnStringMessageMethod(webSocketEndpoint).isPresent()) {
        method = dispatcher.getOnStringMessageMethod(webSocketEndpoint).get();
    } else {
        return true;
    }
    validateReturnType(method);
    boolean foundPrimaryString = false;
    for (Parameter parameter: method.getParameters()) {
        Class<?> paraType = parameter.getType();
        if (paraType == String.class) {
            if (parameter.getAnnotation(PathParam.class) == null) {
                if (foundPrimaryString) {
                    throw new WebSocketMethodParameterException("Invalid parameter found on text message method: " +
                                                                        "More than one string parameter without " +
                                                                        "@PathParam annotation.");
                }
                foundPrimaryString = true;
            }
        } else if (paraType != WebSocketConnection.class) {
            throw new WebSocketMethodParameterException("Invalid parameter found on text message method: " +
                                                                paraType);
        }
    }
    return foundPrimaryString;
}
 

private static Optional<FunctionArgumentTemplate> tryExtractInputGroupArgument(Method method, int paramPos) {
	final Parameter parameter = method.getParameters()[paramPos];
	final DataTypeHint hint = parameter.getAnnotation(DataTypeHint.class);
	if (hint != null) {
		final DataTypeTemplate template = DataTypeTemplate.fromAnnotation(hint, null);
		if (template.inputGroup != null) {
			return Optional.of(FunctionArgumentTemplate.of(template.inputGroup));
		}
	}
	return Optional.empty();
}
 

@Test
public void parseParameter() throws NoSuchMethodException {
  Class<ParamAnnotationResource> paramAnnotationResourceClass = ParamAnnotationResource.class;
  OasContext oasContext = new OasContext(null);
  OperationContext operationContext;
  ParameterContext parameterContext;

  RequestParamAnnotationProcessor requestParamAnnotationProcessor = new RequestParamAnnotationProcessor();
  Method requestParamMethod = paramAnnotationResourceClass.getMethod("requestParam", String.class);
  Parameter requestParamMethodParam = requestParamMethod.getParameters()[0];
  RequestParam requestParamAnnotation = requestParamMethodParam
      .getAnnotation(RequestParam.class);
  operationContext = new OperationContext(requestParamMethod, oasContext);
  parameterContext = new ParameterContext(operationContext, requestParamMethodParam);
  requestParamAnnotationProcessor.process(requestParamAnnotation, parameterContext);
  io.swagger.v3.oas.models.parameters.Parameter oasParameter = parameterContext.toParameter();
  Assert.assertNull(parameterContext.getDefaultValue());
  Assert.assertNull(oasParameter.getSchema().getDefault());

  PathVariableAnnotationProcessor pathVariableAnnotationProcessor = new PathVariableAnnotationProcessor();
  Method pathVariableMethod = paramAnnotationResourceClass.getMethod("pathVariable", String.class);
  Parameter pathVariableMethodParam = pathVariableMethod.getParameters()[0];
  PathVariable pathVariableAnnotation = pathVariableMethodParam
      .getAnnotation(PathVariable.class);
  operationContext = new OperationContext(pathVariableMethod, oasContext);
  parameterContext = new ParameterContext(operationContext, pathVariableMethodParam);
  pathVariableAnnotationProcessor.process(pathVariableAnnotation, parameterContext);
  parameterContext.toParameter();
  Assert.assertTrue(parameterContext.isRequired());

  RequestPartAnnotationProcessor requestPartAnnotationProcessor = new RequestPartAnnotationProcessor();
  Method requestPartMethod = paramAnnotationResourceClass.getMethod("requestPart", MultipartFile.class);
  Parameter requestPartMethodParam = requestPartMethod.getParameters()[0];
  RequestPart requestPartParamAnnotation = requestPartMethodParam
      .getAnnotation(RequestPart.class);
  operationContext = new OperationContext(requestPartMethod, oasContext);
  parameterContext = new ParameterContext(operationContext, requestPartMethodParam);
  requestPartAnnotationProcessor.process(requestPartParamAnnotation, parameterContext);
  oasParameter = parameterContext.toParameter();
  Assert.assertNull(parameterContext.getDefaultValue());
  Assert.assertEquals(FileSchema.class, oasParameter.getSchema().getClass());

  RequestHeaderAnnotationProcessor requestHeaderAnnotationProcessor = new RequestHeaderAnnotationProcessor();
  Method requestHeaderMethod = paramAnnotationResourceClass.getMethod("requestHeader", String.class);
  Parameter requestHeaderMethodParam = requestHeaderMethod.getParameters()[0];
  RequestHeader requestHeaderParamAnnotation = requestHeaderMethodParam
      .getAnnotation(RequestHeader.class);
  operationContext = new OperationContext(requestPartMethod, oasContext);
  parameterContext = new ParameterContext(operationContext, requestHeaderMethodParam);
  requestHeaderAnnotationProcessor.process(requestHeaderParamAnnotation, parameterContext);
  oasParameter = parameterContext.toParameter();
  Assert.assertNull(parameterContext.getDefaultValue());
  Assert.assertNull(oasParameter.getSchema().getDefault());

  RequestBodyAnnotationProcessor requestBodyAnnotationProcessor = new RequestBodyAnnotationProcessor();
  Method requestBodyMethod = paramAnnotationResourceClass.getMethod("requestBody", String.class);
  Parameter requestBodyMethodParam = requestBodyMethod.getParameters()[0];
  RequestBody requestBodyParamAnnotation = requestBodyMethodParam
      .getAnnotation(RequestBody.class);
  operationContext = new OperationContext(requestBodyMethod, oasContext);
  parameterContext = new ParameterContext(operationContext, requestBodyMethodParam);
  requestBodyAnnotationProcessor.process(requestBodyParamAnnotation, parameterContext);
  parameterContext.toParameter();
  Assert.assertTrue(parameterContext.isRequired());
}
 

private void resolveInjectableConstructorDependencies(Constructor<?> constructor, Object[] initParams, int offset, Optional<Request> request) throws MissingInformationException, ElementNotFoundException {
    for (int i = offset; i < constructor.getParameterCount(); i++) {
        final Parameter constructorParameter = constructor.getParameters()[i];
        final RequestAttribute requestAttribute = constructorParameter.getAnnotation(RequestAttribute.class);
        final com.flipkart.poseidon.datasources.ServiceClient serviceClientAttribute = constructorParameter.getAnnotation(com.flipkart.poseidon.datasources.ServiceClient.class);
        final SystemDataSource systemDataSourceAttribute = constructorParameter.getAnnotation(SystemDataSource.class);
        if (requestAttribute != null) {
            final String attributeName = StringUtils.isNullOrEmpty(requestAttribute.value()) ? constructorParameter.getName() : requestAttribute.value();
            initParams[i] = request.map(r -> r.getAttribute(attributeName)).map(attr -> {
                if (constructorParameter.getType().isAssignableFrom(attr.getClass())) {
                    return attr;
                } else {
                    return mapper.convertValue(attr, mapper.constructType(constructorParameter.getParameterizedType()));
                }
            }).orElse(null);
        } else if (serviceClientAttribute != null) {
            ServiceClient serviceClient = serviceClientsByName.get(constructor.getParameterTypes()[i].getName());
            if (serviceClient == null) {
                throw new ElementNotFoundException("Unable to find ServiceClient for class = " + constructor.getParameterTypes()[i]);
            }
            initParams[i] = serviceClient;
        } else if (systemDataSourceAttribute != null) {
            final DataSource<?> systemDataSource = systemDataSources.get(systemDataSourceAttribute.value());
            if (systemDataSource == null) {
                throw new ElementNotFoundException("Unable to find SystemDataSource for id = " + systemDataSourceAttribute.value());
            }
            initParams[i] = systemDataSource;
        } else {
            final Qualifier qualifier = constructorParameter.getAnnotation(Qualifier.class);
            String beanName = null;
            if (qualifier != null && !StringUtils.isNullOrEmpty(qualifier.value())) {
                beanName = qualifier.value();
            }

            initParams[i] = beanName == null ? context.getBean(constructor.getParameterTypes()[i]) : context.getBean(beanName, constructor.getParameterTypes()[i]);
            if (initParams[i] == null) {
                throw new MissingInformationException("Unmet dependency for constructor " + constructor.getName() + ": " + constructor.getParameterTypes()[i].getCanonicalName());
            }
        }
    }
}
 

protected String getArgumentDescription(Parameter parameter, AnnotatedType parameterType, MessageBundle messageBundle) {
    GraphQLArgument meta = parameter.getAnnotation(GraphQLArgument.class);
    return meta != null ? messageBundle.interpolate(meta.description()) : null;
}
 

private StringBuilder extractArguments(
    Method method,
    Object[] args) {
  StringBuilder theSB = new StringBuilder();
  try {
    Parameter[] parameters = method.getParameters();
    boolean added = false;
    if (parameters != null && parameters.length > 0) {
      theSB.append(": ");
      for (int i = 0; i < parameters.length; i++) {
        Parameter parameter = parameters[i];
        if (parameter.getAnnotation(DontLog.class) == null && args[i] != null) {
          final Class<?> parameterType = parameter.getType();
          final boolean isLogable = Logable.class.isAssignableFrom(parameterType);
          //@formatter:off
                      if (
                          parameterType.isPrimitive()
                          || parameterType.isEnum()
                          || CharSequence.class.isAssignableFrom(parameterType)
                          || isLogable
                          ) {
                          addParameterName(theSB, added, parameter);
                          if(isLogable) {
                            theSB.append(((Logable)args[i]).formatted());
                          } else {
                            theSB.append(args[i].toString());
                          }
                          added = true;
                      } else if (
                              parameterType.isArray()
                              && (
                                  parameterType.getComponentType().isPrimitive()
                                  || parameterType.getComponentType().isEnum()
                                  || CharSequence.class.isAssignableFrom(parameterType.getComponentType())
                              )
                      ) {
                          addParameterName(theSB, added, parameter);
                          int lenght = Array.getLength(args[i]);
                          StringJoiner st = new StringJoiner(",");
                          for(int j = 0 ; j < lenght ; j++) {
                            st.add(Array.get(args[i], j).toString());
                          }
                          theSB.append(st.toString());
                          added = true;
                      }
                      //@formatter:on
        }
      }
    }
  } catch (Exception e) {
    log.error("Error extracting arguments from method", e);
  }
  return theSB;
}
 

@Override
public boolean supportsParameter(ParameterContext paramContext, ExtensionContext extensionContext) throws ParameterResolutionException {
    final Parameter parameter = paramContext.getParameter();
    return parameter.getAnnotation(TempDirectory.class) != null && Path.class.equals(parameter.getType());
}