public ClassBasedMethodHandler(final Class<?> handlerClass, final boolean disableParamDecoding, final Collection<Parameter> handlerParameters) { super(handlerParameters); this.handlerClass = handlerClass; List<HandlerConstructor> constructors = new LinkedList<HandlerConstructor>(); for (Constructor<?> constructor : handlerClass.getConstructors()) { constructors.add(new HandlerConstructor( constructor, Parameter.create(handlerClass, handlerClass, constructor, disableParamDecoding))); } this.handlerConstructors = Collections.unmodifiableList(constructors); }
public ClassBasedMethodHandler(final Class<?> handlerClass, final boolean disableParamDecoding, final Collection<Parameter> handlerParameters) { super(handlerParameters); this.handlerClass = handlerClass; List<HandlerConstructor> constructors = new LinkedList<HandlerConstructor>(); for (Constructor<?> constructor : handlerClass.getConstructors()) { constructors.add(new HandlerConstructor( constructor, Parameter.create(handlerClass, handlerClass, constructor, disableParamDecoding))); } this.handlerConstructors = Collections.unmodifiableList(constructors); }
private static List<Parameter> create( Class concreteClass, Class declaringClass, boolean keepEncoded, Class[] parameterTypes, Type[] genericParameterTypes, Annotation[][] parameterAnnotations) { final List<Parameter> parameters = new ArrayList<>(parameterTypes.length); for (int i = 0; i < parameterTypes.length; i++) { final Parameter parameter = Parameter.create( concreteClass, declaringClass, keepEncoded, parameterTypes[i], genericParameterTypes[i], parameterAnnotations[i]); if (null != parameter) { parameters.add(parameter); } else { // TODO throw IllegalStateException instead? return Collections.emptyList(); } } return parameters; }
private static List<Parameter> create( Class concreteClass, Class declaringClass, boolean keepEncoded, Class[] parameterTypes, Type[] genericParameterTypes, Annotation[][] parameterAnnotations) { final List<Parameter> parameters = new ArrayList<>(parameterTypes.length); for (int i = 0; i < parameterTypes.length; i++) { final Parameter parameter = Parameter.create( concreteClass, declaringClass, keepEncoded, parameterTypes[i], genericParameterTypes[i], parameterAnnotations[i]); if (null != parameter) { parameters.add(parameter); } else { // TODO throw IllegalStateException instead? return Collections.emptyList(); } } return parameters; }
return create( concreteClass, declaringClass, ((null != ctor.getAnnotation(Encoded.class)) || keepEncoded),
return create( concreteClass, declaringClass, ((null != ctor.getAnnotation(Encoded.class)) || keepEncoded),
private BeanParameter(final Annotation[] markers, final Annotation marker, final String sourceName, final Class<?> rawType, final Type type, final boolean encoded, final String defaultValue) { super(markers, marker, Source.BEAN_PARAM, sourceName, rawType, type, encoded, defaultValue); final Collection<Parameter> parameters = new LinkedList<>(); for (Field field : AccessController.doPrivileged(ReflectionHelper.getDeclaredFieldsPA(rawType))) { if (field.getDeclaredAnnotations().length > 0) { Parameter beanParamParameter = Parameter.create( rawType, field.getDeclaringClass(), field.isAnnotationPresent(Encoded.class), field.getType(), field.getGenericType(), field.getAnnotations()); parameters.add(beanParamParameter); } } for (Constructor constructor : AccessController .doPrivileged(ReflectionHelper.getDeclaredConstructorsPA(rawType))) { for (Parameter parameter : Parameter.create(rawType, rawType, constructor, false)) { parameters.add(parameter); } } this.parameters = Collections.unmodifiableCollection(parameters); }
private BeanParameter(final Annotation[] markers, final Annotation marker, final String sourceName, final Class<?> rawType, final Type type, final boolean encoded, final String defaultValue) { super(markers, marker, Source.BEAN_PARAM, sourceName, rawType, type, encoded, defaultValue); final Collection<Parameter> parameters = new LinkedList<>(); for (Field field : AccessController.doPrivileged(ReflectionHelper.getDeclaredFieldsPA(rawType))) { if (field.getDeclaredAnnotations().length > 0) { Parameter beanParamParameter = Parameter.create( rawType, field.getDeclaringClass(), field.isAnnotationPresent(Encoded.class), field.getType(), field.getGenericType(), field.getAnnotations()); parameters.add(beanParamParameter); } } for (Constructor constructor : AccessController .doPrivileged(ReflectionHelper.getDeclaredConstructorsPA(rawType))) { for (Parameter parameter : Parameter.create(rawType, rawType, constructor, false)) { parameters.add(parameter); } } this.parameters = Collections.unmodifiableCollection(parameters); }
private void checkResourceClassFields(final boolean encodedFlag, boolean isInSingleton, Collection<Parameter> injectableParameters) { for (Field field : AccessController.doPrivileged(ReflectionHelper.getDeclaredFieldsPA(handlerClass))) { if (field.getDeclaredAnnotations().length > 0) { Parameter p = Parameter.create( handlerClass, field.getDeclaringClass(), encodedFlag || field.isAnnotationPresent(Encoded.class), field.getType(), field.getGenericType(), field.getAnnotations()); if (null != p) { ResourceMethodValidator.validateParameter(p, field, field.toGenericString(), field.getName(), isInSingleton); // we do not inject entity and unknown parameters into class instance fields and properties. if (p.getSource() != Parameter.Source.ENTITY) { injectableParameters.add(p); } } } } }
private void checkResourceClassFields(final boolean encodedFlag, boolean isInSingleton, Collection<Parameter> injectableParameters) { for (Field field : AccessController.doPrivileged(ReflectionHelper.getDeclaredFieldsPA(handlerClass))) { if (field.getDeclaredAnnotations().length > 0) { Parameter p = Parameter.create( handlerClass, field.getDeclaringClass(), encodedFlag || field.isAnnotationPresent(Encoded.class), field.getType(), field.getGenericType(), field.getAnnotations()); if (null != p) { ResourceMethodValidator.validateParameter(p, field, field.toGenericString(), field.getName(), isInSingleton); // we do not inject entity and unknown parameters into class instance fields and properties. if (p.getSource() != Parameter.Source.ENTITY) { injectableParameters.add(p); } } } } }
final Parameter parameter = Parameter.create( componentClass, componentClass,
final Parameter parameter = Parameter.create( componentClass, componentClass,
this.parameters = Collections.unmodifiableList(Parameter.create( handlerClass, definitionMethod.getDeclaringClass(), definitionMethod, encodedParameters));
this.parameters = Collections.unmodifiableList(Parameter.create( handlerClass, definitionMethod.getDeclaringClass(), definitionMethod, encodedParameters));
/** * Create a list of parameter models for a given Java method handling a resource * method, sub-resource method or a sub-resource locator. * * @param concreteClass concrete resource method handler implementation class. * @param declaringClass the class declaring the handling Java method. * @param javaMethod Java method handling a resource method, sub-resource * method or a sub-resource locator. * @param keepEncoded set to {@code true} to disable automatic decoding * of all the method parameters. (See {@link Encoded}. * @return a list of handling method parameter models. */ public static List<Parameter> create( Class concreteClass, Class declaringClass, Method javaMethod, boolean keepEncoded) { AnnotatedMethod method = new AnnotatedMethod(javaMethod); return create( concreteClass, declaringClass, ((null != method.getAnnotation(Encoded.class)) || keepEncoded), method.getParameterTypes(), method.getGenericParameterTypes(), method.getParameterAnnotations()); }
/** * Create a list of parameter models for a given Java method handling a resource * method, sub-resource method or a sub-resource locator. * * @param concreteClass concrete resource method handler implementation class. * @param declaringClass the class declaring the handling Java method. * @param javaMethod Java method handling a resource method, sub-resource * method or a sub-resource locator. * @param keepEncoded set to {@code true} to disable automatic decoding * of all the method parameters. (See {@link Encoded}. * @return a list of handling method parameter models. */ public static List<Parameter> create( Class concreteClass, Class declaringClass, Method javaMethod, boolean keepEncoded) { AnnotatedMethod method = new AnnotatedMethod(javaMethod); return create( concreteClass, declaringClass, ((null != method.getAnnotation(Encoded.class)) || keepEncoded), method.getParameterTypes(), method.getGenericParameterTypes(), method.getParameterAnnotations()); }
private void checkResourceClassSetters(final MethodList methodList, final boolean encodedFlag, Collection<Parameter> injectableParameters) { for (AnnotatedMethod method : methodList.withoutMetaAnnotation(HttpMethod.class) .withoutAnnotation(Path.class) .hasNumParams(1) .hasReturnType(void.class) .nameStartsWith("set")) { Parameter p = Parameter.create( handlerClass, method.getMethod().getDeclaringClass(), encodedFlag || method.isAnnotationPresent(Encoded.class), method.getParameterTypes()[0], method.getGenericParameterTypes()[0], method.getAnnotations()); if (null != p) { ResourceMethodValidator.validateParameter(p, method.getMethod(), method.getMethod().toGenericString(), "1", InvocableValidator.isSingleton(handlerClass)); // we do not inject entity parameters into class instance fields and properties. if (p.getSource() != Parameter.Source.ENTITY) { injectableParameters.add(p); } } } }
private void checkResourceClassSetters(final MethodList methodList, final boolean encodedFlag, Collection<Parameter> injectableParameters) { for (AnnotatedMethod method : methodList.withoutMetaAnnotation(HttpMethod.class) .withoutAnnotation(Path.class) .hasNumParams(1) .hasReturnType(void.class) .nameStartsWith("set")) { Parameter p = Parameter.create( handlerClass, method.getMethod().getDeclaringClass(), encodedFlag || method.isAnnotationPresent(Encoded.class), method.getParameterTypes()[0], method.getGenericParameterTypes()[0], method.getAnnotations()); if (null != p) { ResourceMethodValidator.validateParameter(p, method.getMethod(), method.getMethod().toGenericString(), "1", InvocableValidator.isSingleton(handlerClass)); // we do not inject entity parameters into class instance fields and properties. if (p.getSource() != Parameter.Source.ENTITY) { injectableParameters.add(p); } } } }
public ClassBasedMethodHandler(final Class<?> handlerClass, final boolean disableParamDecoding, final Collection<Parameter> handlerParameters) { super(handlerParameters); this.handlerClass = handlerClass; List<HandlerConstructor> constructors = new LinkedList<HandlerConstructor>(); for (Constructor<?> constructor : handlerClass.getConstructors()) { constructors.add(new HandlerConstructor( constructor, Parameter.create(handlerClass, handlerClass, constructor, disableParamDecoding))); } this.handlerConstructors = Collections.unmodifiableList(constructors); }
private void checkResourceClassFields(final boolean encodedFlag, boolean isInSingleton, Collection<Parameter> injectableParameters) { for (Field field : AccessController.doPrivileged(ReflectionHelper.getDeclaredFieldsPA(handlerClass))) { if (field.getDeclaredAnnotations().length > 0) { Parameter p = Parameter.create( handlerClass, field.getDeclaringClass(), encodedFlag || field.isAnnotationPresent(Encoded.class), field.getType(), field.getGenericType(), field.getAnnotations()); if (null != p) { ResourceMethodValidator.validateParameter(p, field, field.toGenericString(), field.getName(), isInSingleton); // we do not inject entity and unknown parameters into class instance fields and properties. if (p.getSource() != Parameter.Source.ENTITY) { injectableParameters.add(p); } } } } }