关于注解的面试题

- 日理万妓 2022-03-26 10:22 240阅读 0赞

金三银四，三四月是找工作最好的时期。错过了三月千万别放弃四月。

在面试的时候，有些面试官会问注解相关的问题, 注解最典型的代表框架就是Spring了，特别是Spring Boot出来之后，用注解代替了XML的配置，非常方便，今天我们就来聊聊注解相关的面试回答。

面试官的问法可能千奇百怪，我在这边总结几个常见的问题：  
注解是什么？

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

简单来说注解其实就是代码中的特殊标记，这些标记可以在编译、类加载、运行时被读取，并执行相对应的处理。  
JDK内置了哪些注解？

Overried  
    Overried是告诉编译器要检查该方法是实现父类的方法。

Deprecated  
    Deprecated用于标记一些过时的代码。

SuppressWarnings  
    SuppressWarnings用于消除一些警告信息，使用集合的时候，如果没有指定泛型，IDE会提示安全检查的警告。

FunctionalInterface  
    FunctionalInterface是JDK8中的注解，用来指定该接口是函数式接口。

SafeVarargs  
    SafeVarargs是JDK 7中的注解，主要目的是处理可变长参数中的泛型，此注解告诉编译器：在可变长参数中的泛型是类型安全的。

怎么自定义一个注解？

在Java中，类使用class定义，接口使用interface定义，注解和接口的定义差不多，增加了一个@符号，即@interface，代码如下：

public @interface EnableAuth \{

1  
    2  
    3  
    4

注解中可以定义成员变量，用于信息的描述，跟接口中方法的定义类似，代码如下：

public @interface EnableAuth \{  
    String name();  
\}

1  
    2  
    3

还可以添加默认值：

public @interface EnableAuth \{  
    String name() default "猿天地";  
\}

1  
    2  
    3

上面的介绍只是完成了自定义注解的第一步，开发中日常使用注解大部分是用在类上，方法上，字段上，示列代码如下：

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface EnableAuth \{

1  
    2  
    3  
    4  
    5  
    6

Target  
    用于指定被修饰的注解修饰哪些程序单元，也就是上面说的类，方法，字段

Retention  
    用于指定被修饰的注解被保留多长时间，分别SOURCE（注解仅存在于源码中，在class字节码文件中不包含）,CLASS（默认的保留策略，注解会在class字节码文件中存在，但运行时无法获取）,RUNTIME（注解会在class字节码文件中存在，在运行时可以通过反射获取到）三种类型，如果想要在程序运行过程中通过反射来获取注解的信息需要将Retention设置为RUNTIME

Documented  
    用于指定被修饰的注解类将被javadoc工具提取成文档

Inherited  
    用于指定被修饰的注解类将具有继承性

如何获取注解中的值？

可以通过反射来判断类，方法，字段上是否有某个注解以及获取注解中的值, 获取某个类中方法上的注解代码示例如下：

Class<?> clz = bean.getClass();  
Method\[\] methods = clz.getMethods();  
for (Method method : methods) \{  
    if (method.isAnnotationPresent(EnableAuth.class)) \{  
        String name = method.getAnnotation(EnableAuth.class).name();  
    \}  
\}

1  
    2  
    3  
    4  
    5  
    6  
    7

通过isAnnotationPresent判断是否存在某个注解，通过getAnnotation获取注解对象，然后获取值  
工作中经常接触的注解有哪些？

注解在很多框架中都应用非常多，这个问题你可以说下Spring中的即可，大概的解释下每个注解的含义和用途，除了Spring还有很多别的框架中也有使用注解，比如Swagger, Lombok，JPA，Spring Data等

Component  
    Controller  
    Repository  
    Service  
    RequestMapping  
    RequestParam  
    RequestAttribute  
    RequestBody  
    ResponseBody  
    ……

注解的使用场景？

生成文档  
    Swagger中就是通过注解对接口，实体类中的字段进行描述生成可视化的文档  
    代替配置文件  
    Spring中Bean的装载注入  
    导出数据  
    可以写一个统一的导出工具类，传入一个List<实体类>进去即可导出Excel文件，Excel的表头可以用注解加载字段上  
    框架层面的统一处理  
    注解在底层框架中用的比较多，在框架中需要考虑到通用性，能用注解做很多事情，比如对API进行权限控制，限流等操作都可以通过自定义注解来标识是否需要进行认证，限流等，还有数据的缓存，典型的就是@Cacheable,还有异步方法的调用@Async，ORM框架中的使用，可以用注解标识表名，字段名，JPA中，Spring Data框架中都有使用

权限控制详细讲解

比如我们有的接口需要认证才能调用，有的不需要，简单的做法就是用配置的方式，将需要认证的接口配置好，然后进行拦截过滤，缺点是需要经常维护配置信息，用注解可以避免这个情况。  
可以自定义一个注解，只要加了这个注解我们就对这个接口进行认证拦截操作，接下里详细的讲解下这个功能实现。

定义开启认证的注解，作用在方法上，运行时可获取注解信息

/\*\*  
 \* 开启API权限认证  
 \* @author yinjihuan  
 \*  
 \*/  
@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface EnableAuth \{

1  
    2  
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    11  
    12

在需要认证的接口上增加注解

@EnableAuth  
@GetMapping("/userCollectCityInfo")  
@ApiOperation(value="获取登录用户关注的城市信息", notes="获取登录用户关注的城市信息", produces = "application/json")  
@ApiResponses(  
        @ApiResponse(response = UserCollectCityInfoDto.class, code = 200, message = "")  
)  
public Response getUserCollectCityInfos(HttpServletRequest request) \{  
    try \{  
        Long uid = UserInfoUtils.getLoginUserId(request);  
        List<CityCollect> citys = cityCollectService.findAllByUid(uid);  
        List<UserCollectCityInfoDto> results = citys.stream().map(this::ofCityInfo)  
                    .sorted((l1, l2) -> l1.getRangeLevel().compareTo(l2.getRangeLevel()))  
                    .collect(Collectors.toList());  
        return Response.ok(results);  
    \} catch (Exception e) \{  
        logger.error("获取登录用户关注的城市信息异常", e);  
        return Response.fail("获取登录用户关注的城市信息异常");  
    \}  
\}

1  
    2  
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    11  
    12  
    13  
    14  
    15  
    16  
    17  
    18  
    19

在拦截器中进行拦截，拦截需要知道当前请求的接口是不是需要拦截的，我们可以在启动时将所有增加了@EnableAuth的接口信息保存起来，这样在拦截器中就知道哪个接口是需要认证。

初始化需要认证的接口信息代码如下：

/\*\*  
 \* API 验证数据初始化  
 \* @author yinjihuan  
 \*  
 \*/  
@Component  
@Configuration  
public class ApiAuthDataInit implements ApplicationContextAware \{

public static List<String> checkApis = new ArrayList<String>();

@Override  
    public void setApplicationContext(ApplicationContext ctx) throws BeansException \{  
        Map<String, Object> beanMap = ctx.getBeansWithAnnotation(RestController.class);  
        if (beanMap != null) \{  
            for (Object bean : beanMap.values()) \{  
                Class<?> clz = bean.getClass();  
                Method\[\] methods = clz.getMethods();  
                for (Method method : methods) \{  
                    if (method.isAnnotationPresent(EnableAuth.class)) \{  
                        String uri = getApiUri(clz, method);  
                        checkApis.add(uri);  
                    \}  
                \}  
            \}  
        \}  
    \}

private String getApiUri(Class<?> clz, Method method) \{  
        StringBuilder uri = new StringBuilder();  
        uri.append(clz.getAnnotation(RequestMapping.class).value()\[0\]);  
        if (method.isAnnotationPresent(GetMapping.class)) \{  
            uri.append(method.getAnnotation(GetMapping.class).value()\[0\]);  
        \} else if (method.isAnnotationPresent(PostMapping.class)) \{  
            uri.append(method.getAnnotation(PostMapping.class).value()\[0\]);  
        \} else if (method.isAnnotationPresent(RequestMapping.class)) \{  
            uri.append(method.getAnnotation(RequestMapping.class).value()\[0\]);  
        \}  
        return uri.toString();  
    \}

1  
    2  
    3  
    4  
    5  
    6  
    7  
    8  
    9  
    10  
    11  
    12  
    13  
    14  
    15  
    16  
    17  
    18  
    19  
    20  
    21  
    22  
    23  
    24  
    25  
    26  
    27  
    28  
    29  
    30  
    31  
    32  
    33  
    34  
    35  
    36  
    37  
    38  
    39  
    40  
    41  
    42

实现ApplicationContextAware接口，然后通过getBeansWithAnnotation获取所有接口的bean信息，通过RestController注解来获取，也就是说只要class上增加了RestController注解，这边就都能获取到。

然后通过反射获取bean中所有的方法，如果有增加EnableAuth的话就获取接口的uri存储到map中，这样过滤器中就可以根据map中的值来判断是不是需要进行权限认证了。

更多技术分享请关注微信公众号：猿天地  
猿天地微信公众号  
\---------------------   
作者：尹吉欢   
来源：CSDN   
原文：https://blog.csdn.net/u010889990/article/details/80333100   
版权声明：本文为博主原创文章，转载请附上博文链接！

===================================================================================

## **1.简介** ##

自Java 5以来，注释已经出现，而现在，它们是无处不在的编程结构，可以丰富代码。

在本文中，我们将回顾一些关于注释的问题; 通常会在技术面谈时询问，并在适当情况下; 我们将实施示例以更好地理解他们的答案。

## **2.问题** ##

### **Q1。什么是注释？他们的典型用例是什么？** ###

注释是绑定到程序源代码元素的元数据，对它们运行的代码的操作没有影响。

他们的典型用例是：

*  **编译器的信息** - 使用注释，编译器可以检测错误或抑制警告
 *  **编译时和部署时处理** - 软件工具可以处理注释并生成代码，配置文件等。
 *  **运行时处理** - 可以在运行时检查注释以自定义程序的行为

### **Q2。从标准库中描述一些有用的注释。** ###

*java.lang*和*java.lang.annotation*包中有几个注释，更常见的包括但不限于：

*  *@Override -*标记方法是否覆盖超类中声明的元素。如果它无法正确覆盖该方法，编译器将发出错误
 *  *@Deprecated* - 表示该元素已弃用且不应使用。如果程序使用标有此批注的方法，类或字段，编译器将发出警告
 *  *@SuppressWarnings* - 告诉编译器禁止特定警告。在与泛型出现之前编写的遗留代码接口时最常用的
 *  *@FunctionalInterface* - 在Java 8中引入，表明类型声明是一个功能接口，可以使用Lambda Expression提供其实现

### **Q3。你怎么能创建一个注释？** ###

注释是一种接口形式，其中关键字*接口*以*@开头，*其主体包含与方法非常相似的*注释类型元素*声明：

1.   
2.   
3.  `public @interface SimpleAnnotation {`
4.   
5.  `    String value();`
6.   
7.   
8.   
9.  `    int[] types();`
10.  
11. `}`

定义注释后，yon可以通过代码开始使用它：

1.  `@SimpleAnnotation(value = "an element", types = 1)`
2.   
3.  `public class Element {`
4.   
5.  `    @SimpleAnnotation(value = "an attribute", types = { 1, 2 })`
6.   
7.  `    public Element nextElement;`
8.   
9.  `}`

请注意，为数组元素提供多个值时，必须将它们括在括号中。

可选地，只要它们是编译器的常量表达式，就可以提供默认值：

1.  `public @interface SimpleAnnotation {`
2.   
3.  `    String value() default "This is an element";`
4.   
5.   
6.   
7.  `    int[] types() default { 1, 2, 3 };`
8.   
9.  `}`

现在，您可以使用没有这些元素的注释：

1.  `@SimpleAnnotation`
2.   
3.  `public class Element {`
4.   
5.  `    // ...`
6.   
7.  `}`

或者只是其中一些：

1.  `@SimpleAnnotation(value = "an attribute")`
2.   
3.  `public Element nextElement;`

### **Q4。可以从注释方法声明返回哪些对象类型？** ###

返回类型必须是基本类型，*String*，*Class*，*Enum*或以前类型之一的数组。否则，编译器将抛出错误。

这是一个成功遵循这个原则的示例代码：

1.  `enum Complexity {`
2.   
3.  `    LOW, HIGH`
4.   
5.  `}`
6.   
7.   
8.   
9.  `public @interface ComplexAnnotation {`
10.  
11. `    Class<? extends Object> value();`
12.  
13.  
14.  
15. `    int[] types();`
16.  
17.  
18.  
19. `    Complexity complexity();`
20.  
21. `}`

由于*Object*不是有效的返回类型，下一个示例将无法编译：

1.  `public @interface FailingAnnotation {`
2.   
3.  `    Object complexity();`
4.  `}`

### **Q5。哪些程序元素可以注释？** ###

注释可以应用于整个源代码的多个位置。它们可以应用于类，构造函数和字段的声明：

1.  `@SimpleAnnotation`
2.   
3.  `public class Apply {`
4.   
5.  `    @SimpleAnnotation`
6.   
7.  `    private String aField;`
8.   
9.   
10. `    @SimpleAnnotation`
11.  
12. `    public Apply() {`
13.  
14. `        // ...`
15.  
16. `    }`
17.  
18. `}`

方法及其参数：

1.  `@SimpleAnnotation`
2.   
3.  `public void aMethod(@SimpleAnnotation String param) {`
4.   
5.  `    // ...`
6.   
7.  `}`

局部变量，包括循环和资源变量：

1.  `@SimpleAnnotation`
2.   
3.  `int i = 10;`
4.   
5.   
6.   
7.  `for (@SimpleAnnotation int j = 0; j < i; j++) {`
8.   
9.  `    // ...`
10.  
11. `}`
12.  
13.  
14.  
15. `try (@SimpleAnnotation FileWriter writer = getWriter())`
16.  
17. `    // ...`
18.  
19. `} catch (Exception ex) {`
20.  
21. `    // ...`
22.  
23. `}`

其他注释类型：

1.  `@SimpleAnnotation`
2.   
3.  `public @interface ComplexAnnotation {`
4.   
5.  `    // ...`
6.   
7.  `}`

甚至包，通过*package-info.java*文件：

1.  `@PackageAnnotation`
2.   
3.  `package com.baeldung.interview.annotations;`

从Java 8开始，它们也可以应用于类型的*使用*。为此，注释必须指定值为*ElementType.USE*的*@Target*注释：

1.  `@Target(ElementType.TYPE_USE)`
2.   
3.  `public @interface SimpleAnnotation {`
4.   
5.  `    // ...`
6.   
7.  `}`

现在，注释可以应用于类实例创建：

new @SimpleAnnotation Apply();

类型转换：

1.  `aString = (@SimpleAnnotation String) something;`
2.

实施条款：

1.  `public class SimpleList<T>`
2.   
3.  `  implements @SimpleAnnotation List<@SimpleAnnotation T> {`
4.   
5.  `    // ...`
6.   
7.  `}`

并*抛出*条款：

void aMethod() throws @SimpleAnnotation Exception {   // ...>}

### **Q6。有没有办法限制可以应用注释的元素？** ###

是的，*@ Target*注释可用于此目的。如果我们尝试在不适用的上下文中使用注释，编译器将发出错误。

以下是仅将*@SimpleAnnotation*批注的用法限制为字段声明的示例：

1.  `@Target(ElementType.FIELD)`
2.   
3.  `public @interface SimpleAnnotation {`
4.   
5.  `    // ...`
6.   
7.  `}`

如果我们想让它适用于更多的上下文，我们可以传递多个常量：

1.   
2.  `@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PACKAGE })`

我们甚至可以制作一个注释，因此它不能用于注释任何东西。当声明的类型仅用作复杂注释中的成员类型时，这可能会派上用场：

1.  `@Target({})`
2.   
3.  `public @interface NoTargetAnnotation {`
4.   
5.  `    // ...`
6.   
7.  `}`

### **Q7。什么是元注释？** ###

是否适用于其他注释的注释。

所有未标记为*@Target的*注释*，*或者使用它标记但包含*ANNOTATION\_TYPE*常量的注释也都是元注释：

1.  `@Target(ElementType.ANNOTATION_TYPE)`
2.   
3.  `public @interface SimpleAnnotation {`
4.   
5.  `    // ...`
6.   
7.  `}`

### **Q8。什么是重复注释？** ###

这些是可以多次应用于同一元素声明的注释。

出于兼容性原因，由于此功能是在Java 8中引入的，因此重复注释存储在由Java编译器自动生成的*容器注释*中。对于编译器来说，执行此操作有两个步骤来声明它们。

首先，我们需要声明一个可重复的注释：

1.  `@Repeatable(Schedules.class)`
2.   
3.  `public @interface Schedule {`
4.   
5.  `    String time() default "morning";`
6.   
7.  `}`

然后，我们使用强制*值*元素定义包含注释，其类型必须是可重复注释类型的数组：

1.  `public @interface Schedules {`
2.   
3.  `    Schedule[] value();`
4.  `}`

现在，我们可以多次使用@Schedule：

1.  `@Schedule`
2.   
3.  `@Schedule(time = "afternoon")`
4.   
5.  `@Schedule(time = "night")`
6.   
7.  `void scheduledMethod() {`
8.   
9.  `    // ...`
10.  
11. `}`

### **Q9。你怎么能检索注释？这与保留政策有何关系？** ###

您可以使用Reflection API或注释处理器来检索注释。

该*@Retention*注解和其*的RetentionPolicy*参数会影响您检索它们。*RetentionPolicy*枚举中有三个常量：

*  *RetentionPolicy.SOURCE* - 使注释被编译器丢弃，但注释处理器可以读取它们
 *  *RetentionPolicy.CLASS* - 表示注释已添加到类文件中，但无法通过反射访问
 *  *RetentionPolicy.RUNTIME* -Annotations由编译器记录在类文件中，并由JVM在运行时保留，以便可以反射性地读取它们

这是一个用于创建可在运行时读取的注释的示例代码：

1.  `@Retention(RetentionPolicy.RUNTIME)`
2.   
3.  `public @interface Description {`
4.   
5.  `    String value();`
6.   
7.  `}`

现在，可以通过反射检索注释：

1.  `Description description`
2.   
3.  `  = AnnotatedClass.class.getAnnotation(Description.class);`
4.   
5.  `System.out.println(description.value());`

注释处理器可以与*RetentionPolicy.SOURCE一起使用*，这在[Java Annotation Processing和Creating a Builder一][Java Annotation Processing_Creating a Builder]文中有所描述。

当您编写Java字节码解析器时，*RetentionPolicy.CLASS*可用。

### **Q10。下面的代码会编译吗？** ###

1.  `@Target({ ElementType.FIELD, ElementType.TYPE, ElementType.FIELD })`
2.   
3.  `public @interface TestAnnotation {`
4.   
5.  `    int[] value() default {};`
6.   
7.  `}`

不。如果在*@Target*注释中多次出现相同的枚举常量，那么这是一个编译时错误。

删除重复常量将使代码成功编译：

@Target({ ElementType.FIELD, ElementType.TYPE})

### **Q11。是否可以扩展注释？** ###

注释。注释总是扩展*java.lang.annotation.Annotation，*如[Java语言规范中所述][Java]。

如果我们尝试在注释声明中使用*extends*子句，我们将得到一个编译错误：

1.  `public @interface AnAnnotation extends OtherAnnotation {`
2.  `   // Compilation error}`

## **结论** ##

在本文中，我们介绍了Java开发人员关于注释的技术访谈中出现的一些常见问题。这绝不是一份详尽的清单，只应被视为进一步研究的开始。

在Baeldung，我们祝愿您在即将进行的任何采访中取得成功。

[Java Annotation Processing_Creating a Builder]: https://www.baeldung.com/java-annotation-processing-builder
[Java]: http://docs.oracle.com/javase/specs/jls/se7/html/jls-9.html#jls-9.6