Java RequestMapping.value方法代码示例

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
private void findAndRegisterAnnotatedDelegateMethods(Object bean,
                                                     Method method) {
    RequestMapping requestMapping = method
            .getAnnotation(RequestMapping.class);
    if (requestMapping != null) {
        String[] paths = requestMapping.value();
        for (String path : paths) {
            if (path != null && !path.isEmpty()) {
                DelegateMethodInvoker delegate = new DelegateMethodInvoker(
                        bean, method,
                        findMatchingArgumentResolvers(method),
                        findMatchingReturnValueHandler(method));
                Order order = method.getAnnotation(Order.class);
                if (order == null) {
                    registerDelegate(path, delegate);
                } else {
                    registerDelegate(path, delegate, order.value());
                }
            }
        }
    }
}
 

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
@Override
public boolean process(RestyRequestTemplate requestTemplate, Annotation annotation) {

    RequestMapping methodMapping = ANNOTATION.cast(annotation);
    // HTTP Method
    RequestMethod[] methods = methodMapping.method();
    if (methods.length == 0) {
        methods = new RequestMethod[]{RequestMethod.GET};
    }
    checkOne(methods, "method");
    requestTemplate.setHttpMethod(methods[0].name());

    // path
    checkAtMostOne(methodMapping.value(), "value");
    if (methodMapping.value().length > 0) {
        String pathValue = emptyToNull(methodMapping.value()[0]);
        if (pathValue != null) {
            pathValue = resolve(pathValue);
            // Append path from @RequestMapping if value is present on httpMethod
            if (!pathValue.startsWith("/")) {
                pathValue = "/" + pathValue;
            }
            requestTemplate.setMethodUrl(pathValue);
        }
    }

    // produces #不需要解析consumes， 无视接口返回的content-type，只处理application/json
    // parseProduces(requestTemplate, method, methodMapping);

    // consumes #不需要解析consumes， 无视接口所需的content-type，只提交application/json
    // parseConsumes(requestTemplate, method, methodMapping);

    // params
    parseParams(requestTemplate, null, methodMapping);

    // headers
    parseHeaders(requestTemplate, null, methodMapping);
    return false;
}
 

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
@Nullable
@Override
public AnnotatedMethod process(Method method) {
    RequestMapping named = method.getAnnotation(RequestMapping.class);
    if (named != null) {
        Class[] parameterTypes = Reflection.getParameterTypes(method);
        String[] parameterNames = new String[parameterTypes.length];
        String name = "";
        if (named.value().length > 0) {
            name = named.value()[0];
        } else {
            name = method.getName();
        }
        AnnotatedMethod res = new AnnotatedMethod(method, name, parameterTypes, parameterNames);
        Annotation[][] declaredParameterAnnotations = Reflection.getParameterAnnotations(method);
        NEXT_PARAM:
        for (int i = 0; i < declaredParameterAnnotations.length; i++) {
            Annotation[] annotations = declaredParameterAnnotations[i];
            for (Annotation annotation : annotations) {
                if (annotation instanceof RequestParam) {
                    String pName = ((RequestParam) annotation).value();
                    parameterNames[i] = pName;
                    continue NEXT_PARAM;
                }
            }
            //if we come here, no annotation was found -> not good!
            LoggerFactory.getLogger(method.getDeclaringClass()).error("{}.{}: {}. Parameter is unnamed and may cause invocation failure at runtime ", method.getDeclaringClass().getSimpleName(), res, i);
        }
        return res;
    }
    return null;
}
 

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
private Set<String> getPathTemplates(RequestMapping requestMapping) {
    if (requestMapping.value().length > 0) {
        return new HashSet<>(Arrays.asList(requestMapping.value()));
    } else if (requestMapping.path().length > 0) {
        return new HashSet<>(Arrays.asList(requestMapping.path()));
    } else {
        return Collections.singleton(StringUtils.EMPTY);
    }
}
 

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
/**
 * Searches {@link org.springframework.web.bind.annotation.RequestMapping RequestMapping}
 * annotation on the given method argument and extracts
 * If RequestMapping annotation is not found, NoRequestMappingFoundException is thrown.
 * {@link org.springframework.http.HttpMethod HttpMethod} type equivalent to
 * {@link org.springframework.web.bind.annotation.RequestMethod RequestMethod} type
 *
 * @param element AnnotatedElement object to be examined.
 * @return Mapping object
 */
Mapping extractMapping(AnnotatedElement element) {
  Annotation annotation = findMappingAnnotation(element);
  String[] urls;
  RequestMethod requestMethod;
  String consumes;

  if (annotation instanceof RequestMapping) {
    RequestMapping requestMapping = (RequestMapping) annotation;
    requestMethod = requestMapping.method().length == 0
        ? RequestMethod.GET : requestMapping.method()[0];
    urls = requestMapping.value();
    consumes = StringHelper.getFirstOrEmpty(requestMapping.consumes());

  } else if (annotation instanceof GetMapping) {

    requestMethod = RequestMethod.GET;
    urls = ((GetMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((GetMapping) annotation).consumes());

  } else if (annotation instanceof PostMapping) {

    requestMethod = RequestMethod.POST;
    urls = ((PostMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PostMapping) annotation).consumes());

  } else if (annotation instanceof PutMapping) {

    requestMethod = RequestMethod.PUT;
    urls = ((PutMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PutMapping) annotation).consumes());

  } else if (annotation instanceof DeleteMapping) {

    requestMethod = RequestMethod.DELETE;
    urls = ((DeleteMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((DeleteMapping) annotation).consumes());

  } else if (annotation instanceof PatchMapping) {

    requestMethod = RequestMethod.PATCH;
    urls = ((PatchMapping) annotation).value();
    consumes = StringHelper.getFirstOrEmpty(((PatchMapping) annotation).consumes());

  } else {
    throw new NoRequestMappingFoundException(element);
  }

  HttpMethod httpMethod = HttpMethod.resolve(requestMethod.name());
  String url = StringHelper.getFirstOrEmpty(urls);

  MediaType mediaType;
  try {
    mediaType =  MediaType.valueOf(consumes);
  } catch (InvalidMediaTypeException exception) {
    mediaType = MediaType.APPLICATION_JSON_UTF8;
  }

  return new Mapping(httpMethod, url, mediaType);

}
 

import org.springframework.web.bind.annotation.RequestMapping; //导入方法依赖的package包/类
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object object) throws Exception {
	log.info("Before process request");
	
	mdc:
	if(object instanceof HandlerMethod) {
		HandlerMethod handlerMethod = (HandlerMethod)object;
		
		Logged annotation = handlerMethod.getMethod().getAnnotation(Logged.class);
		if(annotation == null) {
			annotation = handlerMethod.getBeanType().getAnnotation(Logged.class);
		}
		
		if(annotation != null) {
			Class<? extends DomainMarker> value = annotation.value();
			
			RequestMapping methodRequestMapping = handlerMethod.getMethod().getAnnotation(RequestMapping.class);
			if(methodRequestMapping != null) {

				String[] requestMappingValue = methodRequestMapping.value();
				if(requestMappingValue.length == 1) {
					DomainMarker marker;
		        	try {
						marker = value.newInstance();
					} catch (Exception e) {
						throw new RuntimeException(e);
					}
		        	
		        	// slash the controller path, if present
		        	String requestURI = request.getRequestURI();
					RequestMapping classRequestMapping = handlerMethod.getBeanType().getAnnotation(RequestMapping.class);
					if(classRequestMapping != null) {
						String[] classValues = classRequestMapping.value();
						if(classValues.length == 1) {
							requestURI = requestURI.substring(classValues[0].length());
						} else {
							break mdc;
						}
					}
					
					String values[] = requestURI.split("/");
		        	String keys[] = requestMappingValue[0].split("/"); // assume /a/b/c
		        	if(values.length == keys.length) {
			        	for(int i = 0; i < keys.length; i++) {
			        		// Now create matcher object.
			                Matcher m = pattern.matcher(keys[i]);
				            if(m.matches()) {
				            	String key = m.group("key");
				            	if(marker.definesKey(key)) {
				            		marker.parseAndSetKey(key, values[i]);
				            	}
				            }
			        	}
			        	
			        	marker.pushContext();
			        	
			        	threadLocal.set(marker);
			        	
			        	return true;
		        	}
				}
			}
		}
	}
	threadLocal.remove();
	
	return true;
}