com.github.andyshaox.servlet.mapping.annotation.Mapping Maven / Gradle / Ivy
Show all versions of GearEE Show documentation
package com.github.andyshaox.servlet.mapping.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.github.andyshaox.servlet.mapping.MethodType;
/**
*
* Title:
* Descript:
* Copyright: Copryright(c) Dec 26, 2015
* Encoding:UNIX UTF-8
*
* @author Andy.Shao
*
*/
@Documented
@Target({ ElementType.METHOD , ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Mapping {
/**
* The parameters of the mapped request, narrowing the primary mapping.
*
* Same format for any environment: a sequence of "myParam=myValue" style
* expressions, with a request only mapped if each such parameter is found
* to have the given value. Expressions can be negated by using the "!="
* operator,
* as in "myAttributes!=myValue". "myParam" style expressions are also
* supported,
* with such parameters having to be present in the request (allowed to have
* any value). Finally, "!myParam" style expressions indicate that the
* specified parameter is not supposed to be present in the request.
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings inherit
* this parameter restriction (i.e. the type-level restriction
* gets checked before the handler method is even resolved).
*
* In a Servlet environment, parameter mappings are considered as
* restrictions
* that are enforced at the type level. The primary path mapping (i.e. the
* specified URI value) still has to uniquely identify the target handler,
* with
* parameter mappings simply expressing preconditions for invoking the
* handler.
*
* In a Portlet environment, parameters are taken into account as mapping
* differentiators, i.e. the primary portlet mode mapping plus the parameter
* conditions uniquely identify the target handler. Different handlers may
* be
* mapped onto the same portlet mode, as long as their parameter mappings
* differ.
*
* @return attributes
*/
String[] attributes() default "";
/**
* The consumable media types of the mapped request, narrowing the primary
* mapping.
*
* The format is a single media type or a sequence of media types,
* with a request only mapped if the {@code Content-Type} matches one of
* these media types.
* Examples:
*
*
* consumes = "text/plain"
* consumes = {"text/plain", "application/*"}
*
*
* Expressions can be negated by using the "!" operator, as in
* "!text/plain", which matches
* all requests with a {@code Content-Type} other than "text/plain".
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings override
* this consumes restriction.
* 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html
*
* @return consumes
*/
String consumes() default "";
/**
* The headers of the mapped request, narrowing the primary mapping.
*
* Same format for any environment: a sequence of "My-Header=myValue" style
* expressions, with a request only mapped if each such header is found
* to have the given value. Expressions can be negated by using the "!="
* operator,
* as in "My-Header!=myValue". "My-Header" style expressions are also
* supported,
* with such headers having to be present in the request (allowed to have
* any value). Finally, "!My-Header" style expressions indicate that the
* specified header is not supposed to be present in the request.
*
* Also supports media type wildcards (*), for headers such as Accept
* and Content-Type. For instance,
*
*
* @RequestMapping(value = "/something", headers = "content-type=text/*")
*
*
* will match requests with a Content-Type of "text/html", "text/plain",
* etc.
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings inherit
* this header restriction (i.e. the type-level restriction
* gets checked before the handler method is even resolved).
*
* Maps against HttpServletRequest headers in a Servlet environment,
* and against PortletRequest properties in a Portlet 2.0 environment.
*
* @return headers
*/
String[] headers() default "";
/**
* The HTTP request methods to map to, narrowing the primary mapping:
* GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings inherit
* this HTTP method restriction (i.e. the type-level restriction
* gets checked before the handler method is even resolved).
*
* Supported for Servlet environments as well as Portlet 2.0 environments.
* return methodType. default is {@link MethodType#GET} and
* {@link MethodType#POST}
*
* @return method type
*/
MethodType[] methodType() default { MethodType.GET , MethodType.POST };
/**
* The producible media types of the mapped request, narrowing the primary
* mapping.
*
* The format is a single media type or a sequence of media types,
* with a request only mapped if the {@code Accept} matches one of these
* media types.
* Examples:
*
*
* produces = "text/plain"
* produces = {"text/plain", "application/*"}
*
*
* Expressions can be negated by using the "!" operator, as in
* "!text/plain", which matches
* all requests with a {@code Accept} other than "text/plain".
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings override
* this consumes restriction.
* 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回
*
* @return produces
*/
String produces() default "";
/**
* The primary mapping expressed by this annotation.
*
* In a Servlet environment: the path mapping URIs (e.g. "/myPath.do").
* Ant-style path patterns are also supported (e.g. "/myPath/*.do").
* At the method level, relative paths (e.g. "edit.do") are supported
* within the primary mapping expressed at the type level.
* Path mapping URIs may contain placeholders (e.g. "/${connect}")
*
* In a Portlet environment: the mapped portlet modes
* (i.e. "EDIT", "VIEW", "HELP" or any custom modes).
*
* Supported at the type level as well as at the method level!
* When used at the type level, all method-level mappings inherit
* this primary mapping, narrowing it for a specific handler method.
*
* @return path
*/
String value() default "";
}