[Spring Reading Code] @ControllerAdvice

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.bind.annotation;

import java.lang.annotation.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 org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Component;

/**
 * Specialization of {@link Component @Component} for classes that declare
 * {@link ExceptionHandler @ExceptionHandler}, {@link InitBinder @InitBinder}, or
 * {@link ModelAttribute @ModelAttribute} methods to be shared across
 * multiple {@code @Controller} classes.
 *
 * <p>Classes annotated with {@code @ControllerAdvice} can be declared explicitly
 * as Spring beans or auto-detected via classpath scanning. All such beans are
 * sorted based on {@link org.springframework.core.Ordered Ordered} semantics or
 * {@link org.springframework.core.annotation.Order @Order} /
 * {@link javax.annotation.Priority @Priority} declarations, with {@code Ordered}
 * semantics taking precedence over {@code @Order} / {@code @Priority} declarations.
 * {@code @ControllerAdvice} beans are then applied in that order at runtime.
 * Note, however, that {@code @ControllerAdvice} beans that implement
 * {@link org.springframework.core.PriorityOrdered PriorityOrdered} are <em>not</em>
 * given priority over {@code @ControllerAdvice} beans that implement {@code Ordered}.
 * In addition, {@code Ordered} is not honored for scoped {@code @ControllerAdvice}
 * beans &mdash; for example if such a bean has been configured as a request-scoped
 * or session-scoped bean.  For handling exceptions, an {@code @ExceptionHandler}
 * will be picked on the first advice with a matching exception handler method. For
 * model attributes and data binding initialization, {@code @ModelAttribute} and
 * {@code @InitBinder} methods will follow {@code @ControllerAdvice} order.
 *
 * <p>Note: For {@code @ExceptionHandler} methods, a root exception match will be
 * preferred to just matching a cause of the current exception, among the handler
 * methods of a particular advice bean. However, a cause match on a higher-priority
 * advice will still be preferred over any match (whether root or cause level)
 * on a lower-priority advice bean. As a consequence, please declare your primary
 * root exception mappings on a prioritized advice bean with a corresponding order.
 *
 * <p>By default, the methods in an {@code @ControllerAdvice} apply globally to
 * all controllers. Use selectors such as {@link #annotations},
 * {@link #basePackageClasses}, and {@link #basePackages} (or its alias
 * {@link #value}) to define a more narrow subset of targeted controllers.
 * If multiple selectors are declared, boolean {@code OR} logic is applied, meaning
 * selected controllers should match at least one selector. Note that selector checks
 * are performed at runtime, so adding many selectors may negatively impact
 * performance and add complexity.
 *
 * @author Rossen Stoyanchev
 * @author Brian Clozel
 * @author Sam Brannen
 * @since 3.2
 * @see org.springframework.stereotype.Controller
 * @see RestControllerAdvice
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface ControllerAdvice {

   /**
    * Alias for the {@link #basePackages} attribute.
    * <p>Allows for more concise annotation declarations &mdash; for example,
    * {@code @ControllerAdvice("org.my.pkg")} is equivalent to
    * {@code @ControllerAdvice(basePackages = "org.my.pkg")}.
    * @since 4.0
    * @see #basePackages
    */
   @AliasFor("basePackages")
   String[] value() default {};

   /**
    * Array of base packages.
    * <p>Controllers that belong to those base packages or sub-packages thereof
    * will be included &mdash; for example,
    * {@code @ControllerAdvice(basePackages = "org.my.pkg")} or
    * {@code @ControllerAdvice(basePackages = {"org.my.pkg", "org.my.other.pkg"})}.
    * <p>{@link #value} is an alias for this attribute, simply allowing for
    * more concise use of the annotation.
    * <p>Also consider using {@link #basePackageClasses} as a type-safe
    * alternative to String-based package names.
    * @since 4.0
    */
   @AliasFor("value")
   String[] basePackages() default {};

   /**
    * Type-safe alternative to {@link #basePackages} for specifying the packages
    * in which to select controllers to be advised by the {@code @ControllerAdvice}
    * annotated class.
    * <p>Consider creating a special no-op marker class or interface in each package
    * that serves no purpose other than being referenced by this attribute.
    * @since 4.0
    */
   Class<?>[] basePackageClasses() default {};

   /**
    * Array of classes.
    * <p>Controllers that are assignable to at least one of the given types
    * will be advised by the {@code @ControllerAdvice} annotated class.
    * @since 4.0
    */
   Class<?>[] assignableTypes() default {};

   /**
    * Array of annotation types.
    * <p>Controllers that are annotated with at least one of the supplied annotation
    * types will be advised by the {@code @ControllerAdvice} annotated class.
    * <p>Consider creating a custom composed annotation or use a predefined one,
    * like {@link RestController @RestController}.
    * @since 4.0
    */
   Class<? extends Annotation>[] annotations() default {};

}

 

 

주석처리만 봐도 어떻게 써야하는지 설명이 적혀있는데,

대부분 documentation 에 있는 내용이다

 

 

저 default 는 뭐지? 하고 찾아봤더니

 

default 키워드는 애노테이션 속성의 기본값을 정의하는데 사용할 수 있다고 한다

유형값을 지정하지 않아도 된다는 뜻 이라고 한다

 

문서에 따르자면

 

https://docs.oracle.com/javase/1.5.0/docs/guide/language/annotations.html

Annotations

 

 

 

Typical application programmers will never have to define an annotation type, but it is not hard to do so. Annotation type declarations are similar to normal interface declarations. An at-sign (@) precedes the interface keyword. Each method declaration defines an element of the annotation type. Method declarations must not have any parameters or a throws clause. Return types are restricted to primitives, String, Class, enums, annotations, and arrays of the preceding types. Methods can have default values. Here is an example annotation type declaration:

/**
 * Describes the Request-For-Enhancement(RFE) that led
 * to the presence of the annotated API element.
 */
public @interface RequestForEnhancement {
    int    id();
    String synopsis();
    String engineer() default "[unassigned]"; 
    String date();    default "[unimplemented]"; 
}

 

annotation 선언은 일반 인터페이스 선언과 유사핟

각 method 선언은 애노테이션 주석 type의 요소를 정의하는데

method 선언에 매개변수나 throw 절이 없어야하며, return type이 제한 되기 때문에

default 를 붙여주는 듯 하다

 

반환해야하니 없으면 디폴트로 이걸 던져라는 뜻인듯 하다.

 

 

 

 

 

org.springframework.stereotype.Controller, RestControllerAdvice

 

 

 

/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.bind.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 org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Controller;

/**
 * A convenience annotation that is itself annotated with
 * {@link Controller @Controller} and {@link ResponseBody @ResponseBody}.
 * <p>
 * Types that carry this annotation are treated as controllers where
 * {@link RequestMapping @RequestMapping} methods assume
 * {@link ResponseBody @ResponseBody} semantics by default.
 *
 * <p><b>NOTE:</b> {@code @RestController} is processed if an appropriate
 * {@code HandlerMapping}-{@code HandlerAdapter} pair is configured such as the
 * {@code RequestMappingHandlerMapping}-{@code RequestMappingHandlerAdapter}
 * pair which are the default in the MVC Java config and the MVC namespace.
 *
 * @author Rossen Stoyanchev
 * @author Sam Brannen
 * @since 4.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {

   /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any (or empty String otherwise)
    * @since 4.0.1
    */
   @AliasFor(annotation = Controller.class)
   String value() default "";

}