/** * Determine if a given {@link FacesWrapperFactory} is suitable by resolving generic arguments. * * @param factory the factory to test * @return <tt>true</tt> if the <tt>factory</tt> is supported, otherwise <tt>false</tt> */ @SuppressWarnings({"rawtypes", "unchecked"}) private boolean isFactorySupported(FacesWrapperFactory factory) { Class typeArg = GenericTypeResolver.resolveTypeArgument(factory.getClass(), FacesWrapperFactory.class); if (typeArg == null) { Class targetClass = AopUtils.getTargetClass(factory); if (targetClass != factory.getClass()) { typeArg = GenericTypeResolver.resolveTypeArgument(targetClass, FacesWrapperFactory.class); } } return (typeArg == null || typeArg.isAssignableFrom(this.typeClass)); }
@SuppressWarnings("unchecked") private ApplicationContextInitializer<ConfigurableApplicationContext> loadInitializer( String className, ConfigurableApplicationContext wac) { try { Class<?> initializerClass = ClassUtils.forName(className, wac.getClassLoader()); Class<?> initializerContextClass = GenericTypeResolver.resolveTypeArgument( initializerClass, ApplicationContextInitializer.class); if (initializerContextClass != null) { Assert.isAssignable( initializerContextClass, wac.getClass(), String.format( "Could not add context initializer [%s] since its generic parameter [%s] " + "is not assignable from the type of application context used by this " + "framework servlet [%s]: ", initializerClass.getName(), initializerContextClass.getName(), wac.getClass().getName())); } return BeanUtils.instantiateClass(initializerClass, ApplicationContextInitializer.class); } catch (Exception ex) { throw new IllegalArgumentException( String.format( "Could not instantiate class [%s] specified " + "via 'contextInitializerClasses' init-param", className), ex); } }
public final Object invokeHandlerMethod( Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception { Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod); try { boolean debug = logger.isDebugEnabled(); for (String attrName : this.methodResolver.getActualSessionAttributeNames()) { Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName); if (attrValue != null) { implicitModel.addAttribute(attrName, attrValue); } } for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) { Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod); Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel); if (debug) { logger.debug("Invoking model attribute method: " + attributeMethodToInvoke); } String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value(); if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) { continue; } ReflectionUtils.makeAccessible(attributeMethodToInvoke); Object attrValue = attributeMethodToInvoke.invoke(handler, args); if ("".equals(attrName)) { Class<?> resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass()); attrName = Conventions.getVariableNameForReturnType( attributeMethodToInvoke, resolvedType, attrValue); } if (!implicitModel.containsAttribute(attrName)) { implicitModel.addAttribute(attrName, attrValue); } } Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel); if (debug) { logger.debug("Invoking request handler method: " + handlerMethodToInvoke); } ReflectionUtils.makeAccessible(handlerMethodToInvoke); return handlerMethodToInvoke.invoke(handler, args); } catch (IllegalStateException ex) { // Internal assertion failed (e.g. invalid signature): // throw exception with full handler method context... throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex); } catch (InvocationTargetException ex) { // User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception... ReflectionUtils.rethrowException(ex.getTargetException()); return null; } }
private List<ConnectInterceptor<?>> interceptingConnectionsTo( ConnectionFactory<?> connectionFactory) { Class<?> serviceType = GenericTypeResolver.resolveTypeArgument( connectionFactory.getClass(), ConnectionFactory.class); List<ConnectInterceptor<?>> typedInterceptors = connectInterceptors.get(serviceType); if (typedInterceptors == null) { typedInterceptors = Collections.emptyList(); } return typedInterceptors; }
@SuppressWarnings("unchecked") private void initApiProxy() { Class<?> apiType = GenericTypeResolver.resolveTypeArgument(serviceProvider.getClass(), ServiceProvider.class); if (apiType.isInterface()) { apiProxy = (A) Proxy.newProxyInstance( apiType.getClassLoader(), new Class[] {apiType}, new ApiInvocationHandler()); } }
protected final void addReturnValueAsModelAttribute( Method handlerMethod, Class handlerType, Object returnValue, ExtendedModelMap implicitModel) { ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class); String attrName = (attr != null ? attr.value() : ""); if ("".equals(attrName)) { Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType); attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue); } implicitModel.addAttribute(attrName, returnValue); }
/** Resolve the prepared arguments stored in the given bean definition. */ private Object[] resolvePreparedArguments( String beanName, RootBeanDefinition mbd, BeanWrapper bw, Member methodOrCtor, Object[] argsToResolve) { Class<?>[] paramTypes = (methodOrCtor instanceof Method ? ((Method) methodOrCtor).getParameterTypes() : ((Constructor<?>) methodOrCtor).getParameterTypes()); TypeConverter converter = (this.beanFactory.getCustomTypeConverter() != null ? this.beanFactory.getCustomTypeConverter() : bw); BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter); Object[] resolvedArgs = new Object[argsToResolve.length]; for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) { Object argValue = argsToResolve[argIndex]; MethodParameter methodParam = MethodParameter.forMethodOrConstructor(methodOrCtor, argIndex); GenericTypeResolver.resolveParameterType(methodParam, methodOrCtor.getDeclaringClass()); if (argValue instanceof AutowiredArgumentMarker) { argValue = resolveAutowiredArgument(methodParam, beanName, null, converter); } else if (argValue instanceof BeanMetadataElement) { argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue); } else if (argValue instanceof String) { argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd); } Class<?> paramType = paramTypes[argIndex]; try { resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam); } catch (TypeMismatchException ex) { String methodType = (methodOrCtor instanceof Constructor ? "constructor" : "factory method"); throw new UnsatisfiedDependencyException( mbd.getResourceDescription(), beanName, argIndex, paramType, "Could not convert " + methodType + " argument value of type [" + ObjectUtils.nullSafeClassName(argValue) + "] to required type [" + paramType.getName() + "]: " + ex.getMessage()); } } return resolvedArgs; }
public final Object invokeHandlerMethod( Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception { Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod); try { boolean debug = logger.isDebugEnabled(); for (String attrName : this.methodResolver.getActualSessionAttributeNames()) { Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName); if (attrValue != null) { implicitModel.addAttribute(attrName, attrValue); } } for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) { Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod); Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel); if (debug) { logger.debug("Invoking model attribute method: " + attributeMethodToInvoke); } String attrName = AnnotationUtils.findAnnotation(attributeMethodToInvoke, ModelAttribute.class).value(); if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) { continue; } Object attrValue = doInvokeMethod(attributeMethodToInvoke, handler, args); if ("".equals(attrName)) { Class resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass()); attrName = Conventions.getVariableNameForReturnType( attributeMethodToInvoke, resolvedType, attrValue); } if (!implicitModel.containsAttribute(attrName)) { implicitModel.addAttribute(attrName, attrValue); } } Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel); if (debug) { logger.debug("Invoking request handler method: " + handlerMethodToInvoke); } return doInvokeMethod(handlerMethodToInvoke, handler, args); } catch (IllegalStateException ex) { // Throw exception with full handler method context... throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex); } }
private Mono<Object[]> resolveArguments( ServerWebExchange exchange, BindingContext bindingContext, Object... providedArgs) { if (ObjectUtils.isEmpty(getMethodParameters())) { return NO_ARGS; } try { List<Mono<Object>> monos = Stream.of(getMethodParameters()) .map( param -> { param.initParameterNameDiscovery(this.parameterNameDiscoverer); GenericTypeResolver.resolveParameterType(param, getBean().getClass()); if (!ObjectUtils.isEmpty(providedArgs)) { for (Object providedArg : providedArgs) { if (param.getParameterType().isInstance(providedArg)) { return Mono.just(providedArg).log("reactor.resolved"); } } } HandlerMethodArgumentResolver resolver = this.resolvers .stream() .filter(r -> r.supportsParameter(param)) .findFirst() .orElseThrow(() -> getArgError("No resolver for ", param, null)); try { return resolver .resolveArgument(param, bindingContext, exchange) .defaultIfEmpty(NO_VALUE) .doOnError( cause -> { if (logger.isDebugEnabled()) { logger.debug( getDetailedErrorMessage("Error resolving ", param), cause); } }) .log("reactor.unresolved"); } catch (Exception ex) { throw getArgError("Error resolving ", param, ex); } }) .collect(Collectors.toList()); // Create Mono with array of resolved values... return Mono.when(monos, args -> Stream.of(args).map(o -> o != NO_VALUE ? o : null).toArray()); } catch (Throwable ex) { return Mono.error(ex); } }
@SuppressWarnings("unchecked") public AbstractMethodAnnotationPostProcessor(ConfigurableListableBeanFactory beanFactory) { Assert.notNull(beanFactory, "'beanFactory' must not be null"); this.messageHandlerAttributes.add(SEND_TIMEOUT_ATTRIBUTE); this.beanFactory = beanFactory; ConversionService conversionService = this.beanFactory.getConversionService(); if (conversionService != null) { this.conversionService = conversionService; } else { this.conversionService = DefaultConversionService.getSharedInstance(); } this.channelResolver = new BeanFactoryChannelResolver(beanFactory); this.annotationType = (Class<T>) GenericTypeResolver.resolveTypeArgument( this.getClass(), MethodAnnotationPostProcessor.class); }
/** * Creates {@link TypeInformation} for the given {@link Type}. * * @param fieldType the field type * @return the type information */ @SuppressWarnings({"rawtypes", "unchecked"}) protected TypeInformation<?> createInfo(Type fieldType) { if (fieldType.equals(this.type)) { return this; } if (fieldType instanceof Class) { return new ClassTypeInformation((Class<?>) fieldType); } Map<TypeVariable, Type> variableMap = GenericTypeResolver.getTypeVariableMap(resolveType(fieldType)); if (fieldType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) fieldType; return new ParameterizedTypeInformation(parameterizedType, this); } if (fieldType instanceof TypeVariable) { TypeVariable<?> variable = (TypeVariable<?>) fieldType; return new TypeVariableTypeInformation(variable, type, this, variableMap); } if (fieldType instanceof GenericArrayType) { return new GenericArrayTypeInformation((GenericArrayType) fieldType, this); } if (fieldType instanceof WildcardType) { WildcardType wildcardType = (WildcardType) fieldType; Type[] bounds = wildcardType.getLowerBounds(); if (bounds.length > 0) { return createInfo(bounds[0]); } bounds = wildcardType.getUpperBounds(); if (bounds.length > 0) { return createInfo(bounds[0]); } } throw new IllegalArgumentException(); }
public ImmutableRepositoryDescriptor( Class<R> repositoryType, Map<K, E> data, Map<MethodDescriptor, DataOperation<E, K>> operations, String keyProperty, KeyGeneration keyGeneration) { this.repositoryType = repositoryType; this.data = data == null ? new HashMap<K, E>() : new HashMap<K, E>(data); this.operations = operations == null ? new HashMap<MethodDescriptor, DataOperation<E, K>>() : new HashMap<MethodDescriptor, DataOperation<E, K>>(operations); this.keyProperty = keyProperty; this.keyGeneration = keyGeneration; final Class<?>[] typeArguments = GenericTypeResolver.resolveTypeArguments(repositoryType, Repository.class); //noinspection unchecked entityType = (Class<E>) typeArguments[0]; //noinspection unchecked keyType = (Class<K>) typeArguments[1]; }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) public void afterPropertiesSet() { // code borrowed from AbstractAuthorizeTag ApplicationContext appContext = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext()); Map<String, SecurityExpressionHandler> handlers = appContext.getBeansOfType(SecurityExpressionHandler.class); for (SecurityExpressionHandler h : handlers.values()) { if (FilterInvocation.class.equals( GenericTypeResolver.resolveTypeArgument(h.getClass(), SecurityExpressionHandler.class))) { handler = h; break; } } if (handler == null) { throw new IllegalStateException( "No visible WebSecurityExpressionHandler instance " + "could be found in the application context"); } super.afterPropertiesSet(); }
/** * Resolves the given type into a plain {@link Class}. * * @param type the type * @return the class */ @SuppressWarnings("unchecked") protected Class<S> resolveType(Type type) { return (Class<S>) GenericTypeResolver.resolveType(type, getTypeVariableMap()); }
private Object[] resolveInitBinderArguments( Object handler, Method initBinderMethod, WebDataBinder binder, NativeWebRequest webRequest) throws Exception { Class[] initBinderParams = initBinderMethod.getParameterTypes(); Object[] initBinderArgs = new Object[initBinderParams.length]; for (int i = 0; i < initBinderArgs.length; i++) { MethodParameter methodParam = new MethodParameter(initBinderMethod, i); methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer); GenericTypeResolver.resolveParameterType(methodParam, handler.getClass()); String paramName = null; boolean paramRequired = false; String paramDefaultValue = null; String pathVarName = null; Annotation[] paramAnns = methodParam.getParameterAnnotations(); for (Annotation paramAnn : paramAnns) { if (RequestParam.class.isInstance(paramAnn)) { RequestParam requestParam = (RequestParam) paramAnn; paramName = requestParam.value(); paramRequired = requestParam.required(); paramDefaultValue = requestParam.defaultValue(); break; } else if (ModelAttribute.class.isInstance(paramAnn)) { throw new IllegalStateException( "@ModelAttribute is not supported on @InitBinder methods: " + initBinderMethod); } else if (PathVariable.class.isInstance(paramAnn)) { PathVariable pathVar = (PathVariable) paramAnn; pathVarName = pathVar.value(); } } if (paramName == null && pathVarName == null) { Object argValue = resolveCommonArgument(methodParam, webRequest); if (argValue != WebArgumentResolver.UNRESOLVED) { initBinderArgs[i] = argValue; } else { Class paramType = initBinderParams[i]; if (paramType.isInstance(binder)) { initBinderArgs[i] = binder; } else if (BeanUtils.isSimpleProperty(paramType)) { paramName = ""; } else { throw new IllegalStateException( "Unsupported argument [" + paramType.getName() + "] for @InitBinder method: " + initBinderMethod); } } } if (paramName != null) { initBinderArgs[i] = resolveRequestParam( paramName, paramRequired, paramDefaultValue, methodParam, webRequest, null); } else if (pathVarName != null) { initBinderArgs[i] = resolvePathVariable(pathVarName, methodParam, webRequest, null); } } return initBinderArgs; }
@SuppressWarnings("unchecked") private Object[] resolveHandlerArguments( Method handlerMethod, Object handler, NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception { Class[] paramTypes = handlerMethod.getParameterTypes(); Object[] args = new Object[paramTypes.length]; for (int i = 0; i < args.length; i++) { MethodParameter methodParam = new MethodParameter(handlerMethod, i); methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer); GenericTypeResolver.resolveParameterType(methodParam, handler.getClass()); String paramName = null; String headerName = null; boolean requestBodyFound = false; String cookieName = null; String pathVarName = null; String attrName = null; boolean required = false; String defaultValue = null; boolean validate = false; int found = 0; Annotation[] paramAnns = methodParam.getParameterAnnotations(); for (Annotation paramAnn : paramAnns) { if (RequestParam.class.isInstance(paramAnn)) { RequestParam requestParam = (RequestParam) paramAnn; paramName = requestParam.value(); required = requestParam.required(); defaultValue = requestParam.defaultValue(); found++; } else if (RequestHeader.class.isInstance(paramAnn)) { RequestHeader requestHeader = (RequestHeader) paramAnn; headerName = requestHeader.value(); required = requestHeader.required(); defaultValue = requestHeader.defaultValue(); found++; } else if (RequestBody.class.isInstance(paramAnn)) { requestBodyFound = true; found++; } else if (CookieValue.class.isInstance(paramAnn)) { CookieValue cookieValue = (CookieValue) paramAnn; cookieName = cookieValue.value(); required = cookieValue.required(); defaultValue = cookieValue.defaultValue(); found++; } else if (PathVariable.class.isInstance(paramAnn)) { PathVariable pathVar = (PathVariable) paramAnn; pathVarName = pathVar.value(); found++; } else if (ModelAttribute.class.isInstance(paramAnn)) { ModelAttribute attr = (ModelAttribute) paramAnn; attrName = attr.value(); found++; } else if (Value.class.isInstance(paramAnn)) { defaultValue = ((Value) paramAnn).value(); } else if ("Valid".equals(paramAnn.annotationType().getSimpleName())) { validate = true; } } if (found > 1) { throw new IllegalStateException( "Handler parameter annotations are exclusive choices - " + "do not specify more than one such annotation on the same parameter: " + handlerMethod); } if (found == 0) { Object argValue = resolveCommonArgument(methodParam, webRequest); if (argValue != WebArgumentResolver.UNRESOLVED) { args[i] = argValue; } else if (defaultValue != null) { args[i] = resolveDefaultValue(defaultValue); } else { Class paramType = methodParam.getParameterType(); if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) { args[i] = implicitModel; } else if (SessionStatus.class.isAssignableFrom(paramType)) { args[i] = this.sessionStatus; } else if (Errors.class.isAssignableFrom(paramType)) { throw new IllegalStateException( "Errors/BindingResult argument declared " + "without preceding model attribute. Check your handler method signature!"); } else if (BeanUtils.isSimpleProperty(paramType)) { paramName = ""; } else { attrName = ""; } } } if (paramName != null) { args[i] = resolveRequestParam( paramName, required, defaultValue, methodParam, webRequest, handler); } else if (headerName != null) { args[i] = resolveRequestHeader( headerName, required, defaultValue, methodParam, webRequest, handler); } else if (requestBodyFound) { args[i] = resolveRequestBody(methodParam, webRequest, handler); } else if (cookieName != null) { args[i] = resolveCookieValue( cookieName, required, defaultValue, methodParam, webRequest, handler); } else if (pathVarName != null) { args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler); } else if (attrName != null) { WebDataBinder binder = resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler); boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1])); if (binder.getTarget() != null) { doBind(binder, webRequest, validate, !assignBindingResult); } args[i] = binder.getTarget(); if (assignBindingResult) { args[i + 1] = binder.getBindingResult(); i++; } implicitModel.putAll(binder.getBindingResult().getModel()); } } return args; }
/** * Gets the type argument. * * @param type the type * @param bound the bound * @param index the index * @return the type argument */ private TypeInformation<?> getTypeArgument(Class<?> type, Class<?> bound, int index) { Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(type, bound); return arguments == null ? null : createInfo(arguments[index]); }
/** * 得到参数列表 * * @param method * @param model * @param request * @param response * @param c * @return */ @SuppressWarnings("unchecked") public static Object[] getArgs( Method method, Map<String, Object> model, HttpServletRequest request, HttpServletResponse response, Class<?> c) { Class<?>[] paramTypes = method.getParameterTypes(); Object[] args = new Object[paramTypes.length]; Map<String, Object> argMap = new HashMap<String, Object>(args.length); Map<String, String> pathValues = null; PathPattern pathPattern = method.getAnnotation(PathPattern.class); if (pathPattern != null) { String path = request.getRequestURI(); int index = path.lastIndexOf('.'); if (index != -1) { path = path.substring(0, index); String[] patterns = pathPattern.patterns(); pathValues = getPathValues(patterns, path); } } MapBindingResult errors = new MapBindingResult(argMap, ""); ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer(); for (int i = 0; i < paramTypes.length; i++) { Class<?> paramType = paramTypes[i]; MethodParameter methodParam = new MethodParameter(method, i); methodParam.initParameterNameDiscovery(parameterNameDiscoverer); GenericTypeResolver.resolveParameterType(methodParam, c.getClass()); String paramName = methodParam.getParameterName(); // map if (Map.class.isAssignableFrom(paramType)) { args[i] = model; } // HttpServletRequest else if (HttpServletRequest.class.isAssignableFrom(paramType)) { args[i] = request; } // HttpServletResponse else if (HttpServletResponse.class.isAssignableFrom(paramType)) { args[i] = response; } // HttpSession else if (HttpSession.class.isAssignableFrom(paramType)) { args[i] = request.getSession(); } // Errors else if (Errors.class.isAssignableFrom(paramType)) { args[i] = errors; } // MultipartFile else if (MultipartFile.class.isAssignableFrom(paramType)) { MultipartFile[] files = resolveMultipartFiles(request, errors, paramName); if (files != null && files.length > 0) { args[i] = files[0]; } } // MultipartFile[] else if (MultipartFile[].class.isAssignableFrom(paramType)) { args[i] = resolveMultipartFiles(request, errors, paramName); } else { // 简单数据类型 if (BeanUtils.isSimpleProperty(paramType)) { SimpleTypeConverter converter = new SimpleTypeConverter(); Object value; // 是否是数组 if (paramType.isArray()) { value = request.getParameterValues(paramName); } else { Object[] parameterAnnotations = methodParam.getParameterAnnotations(); value = null; if (parameterAnnotations != null && parameterAnnotations.length > 0) { if (pathValues != null && pathValues.size() > 0) { for (Object object : parameterAnnotations) { if (PathVariable.class.isInstance(object)) { PathVariable pv = (PathVariable) object; if (StringUtils.isEmpty(pv.value())) { value = pathValues.get(paramName); } else { value = pathValues.get(pv.value()); } break; } } } } else { value = request.getParameter(paramName); } } try { args[i] = converter.convertIfNecessary(value, paramType, methodParam); model.put(paramName, args[i]); } catch (TypeMismatchException e) { errors.addError(new FieldError(paramName, paramName, e.getMessage())); } } else { // 复杂数据类型POJO类 if (paramType.isArray()) { ObjectArrayDataBinder binder = new ObjectArrayDataBinder(paramType.getComponentType(), paramName); args[i] = binder.bind(request); model.put(paramName, args[i]); } else { Object bindObject = BeanUtils.instantiateClass(paramType); SummerServletRequestDataBinder binder = new SummerServletRequestDataBinder(bindObject, paramName); binder.bind(request); BindException be = new BindException(binder.getBindingResult()); List<FieldError> fieldErrors = be.getFieldErrors(); for (FieldError fieldError : fieldErrors) { errors.addError(fieldError); } args[i] = binder.getTarget(); model.put(paramName, args[i]); } } } } return args; }
/** * Registers an annotation-based formatter. * * @param clazz class handled by this formatter * @param formatter the formatter to register */ @SuppressWarnings("unchecked") public static <A extends Annotation, T> void register( final Class<T> clazz, final AnnotationFormatter<A, T> formatter) { final Class<? extends Annotation> annotationType = (Class<? extends Annotation>) GenericTypeResolver.resolveTypeArguments( formatter.getClass(), AnnotationFormatter.class)[0]; conversion.addConverter( new ConditionalGenericConverter() { public Set<GenericConverter.ConvertiblePair> getConvertibleTypes() { Set<GenericConverter.ConvertiblePair> types = new HashSet<GenericConverter.ConvertiblePair>(); types.add(new GenericConverter.ConvertiblePair(clazz, String.class)); return types; } public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { return (sourceType.getAnnotation(annotationType) != null); } public Object convert( Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { final A a = (A) sourceType.getAnnotation(annotationType); Locale locale = LocaleContextHolder.getLocale(); try { return formatter.print(a, (T) source, locale); } catch (Exception ex) { throw new ConversionFailedException(sourceType, targetType, source, ex); } } public String toString() { return "@" + annotationType.getName() + " " + clazz.getName() + " -> " + String.class.getName() + ": " + formatter; } }); conversion.addConverter( new ConditionalGenericConverter() { public Set<GenericConverter.ConvertiblePair> getConvertibleTypes() { Set<GenericConverter.ConvertiblePair> types = new HashSet<GenericConverter.ConvertiblePair>(); types.add(new GenericConverter.ConvertiblePair(String.class, clazz)); return types; } public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { return (targetType.getAnnotation(annotationType) != null); } public Object convert( Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { final A a = (A) targetType.getAnnotation(annotationType); Locale locale = LocaleContextHolder.getLocale(); try { return formatter.parse(a, (String) source, locale); } catch (Exception ex) { throw new ConversionFailedException(sourceType, targetType, source, ex); } } public String toString() { return String.class.getName() + " -> @" + annotationType.getName() + " " + clazz.getName() + ": " + formatter; } }); }
@Override protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable { if (checkPropertySkipping(pvs)) { return; } Method method = (Method) this.member; try { Object[] arguments; if (this.cached) { // Shortcut for avoiding synchronization... arguments = resolveCachedArguments(beanName); } else { Class<?>[] paramTypes = method.getParameterTypes(); arguments = new Object[paramTypes.length]; DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length]; Set<String> autowiredBeanNames = new LinkedHashSet<String>(paramTypes.length); TypeConverter typeConverter = beanFactory.getTypeConverter(); for (int i = 0; i < arguments.length; i++) { MethodParameter methodParam = new MethodParameter(method, i); GenericTypeResolver.resolveParameterType(methodParam, bean.getClass()); descriptors[i] = new DependencyDescriptor(methodParam, this.required); arguments[i] = beanFactory.resolveDependency( descriptors[i], beanName, autowiredBeanNames, typeConverter); if (arguments[i] == null && !this.required) { arguments = null; break; } } synchronized (this) { if (!this.cached) { if (arguments != null) { this.cachedMethodArguments = new Object[arguments.length]; for (int i = 0; i < arguments.length; i++) { this.cachedMethodArguments[i] = descriptors[i]; } registerDependentBeans(beanName, autowiredBeanNames); if (autowiredBeanNames.size() == paramTypes.length) { Iterator<String> it = autowiredBeanNames.iterator(); for (int i = 0; i < paramTypes.length; i++) { String autowiredBeanName = it.next(); if (beanFactory.containsBean(autowiredBeanName)) { if (beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) { this.cachedMethodArguments[i] = new RuntimeBeanReference(autowiredBeanName); } } } } } else { this.cachedMethodArguments = null; } this.cached = true; } } } if (arguments != null) { ReflectionUtils.makeAccessible(method); method.invoke(bean, arguments); } } catch (InvocationTargetException ex) { throw ex.getTargetException(); } catch (Throwable ex) { throw new BeanCreationException("Could not autowire method: " + method, ex); } }