注解是 Java 中非常重要的一部分，但经常被忽视也是真的。之所以这么说是因为我们更倾向成为一名注解的使用者而不是创建者。@Override 注解用过吧？@Servi# n & nce 注解用过吧？但你知道怎么自定义一个注解吗？

恐怕你会摇摇头，摆摆手，不好意思地承认自己的确没有自定义过。

01、S { q注解是什么

注解（Annotation）是在 Java 1.5 时引入的概念，同 class 和 interface 一样，也属于一种类型。注解提供了一系列数据用来装饰程序代码（类、方法、字段等），但是注解并不是所装饰代码的一部分，它对代码的运行效果没有直接影响（这句话怎么理解呢？），由编译器决定该执行哪些操作。

来看一段代码，我随便写的，除了打印到控制台的那句宣传语，其他都不重要，嘻嘻。

public class AutowiredTest {
    @Autowired
    private String name;

    public static void main(String[] args) {
        System.out.println(\"王二，一枚有趣的程序员\");
    }
}

注意到 @Autowired 这个注解了吧？它本M ? t u , 0 : t来是为 Spring 容器注入 Bean 的，现在被我无情地扔在了成员变量 name 的身上，但这段代码所在的项目中并没有启用 Spring，意味着 @Autowired 注解此时只是一个摆设。

我之所以举这个无聊的例子就是为了证明一个观点：注解对代码的运行效果没有直Q M s b T L (接影响，明白我的用意了吧？

02、注解的生命周期

注解的生命周期有 3 种策略，定义在 Retend U } { d $tionPolicy 枚举中。

1）SOURCE：在源文件中有效，被编译器丢弃。

2）CLASS：在编译器生成的字节码文件中有效，但在运行时会被处理类文件的 JVM 丢弃。

3）RUNTIME：在运行时有效。这也是注解生命周期中最常用的一种策略，它允许程序通过反射s @ ? s %的方式访问注解，并根据S y k R e A |注解的定义执行相Q 6 F % Q s y [应的代码。

03、注解装2 g d M 9 `饰的目标

注解的目标定义了注解将适T 2 m d / Z F用b x %于哪一种级别的 Java 代码上，有些注解只适用于方法，有些只适用于成员变量] o v R 2 6 2 . n，有些只适用于% b X O # J y类，有V k - {些则都适用。

截止到 Java 9，注解c q W ^ L r的类型一共有 11 种，定义在 ElementType 枚举中。

1p v + ` p h @）TYPEF N ?：用于类、接口、注解、枚举

2）FIELD：用于字段（类的成员变量），或者枚举常量

3）METHOD：用于方法

4）PJ M V l 1 VARAMETER：用于普通方法或者构造方法的参数

5）CONSTRUCTOR：用p h { d a / Z d于构造方法

6）LOCAL_VARIABLE：用于变量

7）ANNOTATION_TYPE：用于注解

8）PACKAGE：用a + Y 1 ` s l Q y于包

9）TYPE_PARAMEb c - FTER：用于泛型参数

10）TYPES = n 7 R q 2_USE：用于声明语句、泛型或者强制转换语句中的类型

11A R Z N , 1）MODULE：用于模块

04、开始撸注解

说再多，都不如撸个注解来得让人心动。撸个什么样$ ~ `的注解呢？一个字段注解吧，它用来标记对象在序d q 0 } 3 c R A F列化成 JSON 的时候要不要包含这个字段。

@Retention(RetentionPolicy.RUNTIME)
@Target(Elemenx ] 1 t T @tType.FIELD)
public @interface JsonField {
    public String value()y : S n ` default \"x k { K B\";
}

1）JsonField 注解的生命周期是 RUNTK r H PIME，也就是运行时有效。

2）JsonField 注解装饰p C W 6 #的目标是 FIELD，也Q r s x X !就是针对字段的。

3）创建注解需要用到 @interface 关键字。

4）JsonField 注解有一个参数，名字为 value，类型为 String，默认值为一个空字符串。

为什么参数名要为 value 呢？有什么特殊的含义吗？

当然是Q P /有的，value 允许注解的使用者提供一个无需指定名字的参数。举个B v O R = Z d 3 B例子o ! u ] W f X ，我们可以在一个字段上使用 @Jm & M 0 s @sonField(value = \"沉默王二\")，也可以把 value = 省略，变成 @JsonField(\"沉默王二\")。

那 default \"\" 有什么特殊含义吗？

当然也是有的，它允许我们在一个字段上9 S [ * ] R 2直接使用 @{ V j 2 R ] Z OJsonField，而无需指定参数的名和值。

05、使用注解

是骡子是马拉出来遛遛，对吧？现在 @JsonField 注解已经撸好了，接下来就到C F 了怎么使用它的环节。

假设有一个作者类，他有 3 个字段，分别是 age、name 和 bookName，后 2 个是必须序列化的字段。

public class Writer {
    private int age;

    @JsonField(\"writerName\")
    private String name;

    @JsonField
    private String bK ! : u { QookName;

    public Writer(int age,_ s + String name, String bookName) {
        this.age = age;
        th, E | Q g # w cis.name = name;
        this.bookName = bookName;
    }

    // getter / set} i & p _ y 6ter

    @Override
    pb m J M / ] @ublic String toString() {
        return \"Writer{\" +
                \"age=\i 4 I s . A o T L@ j ! ^ | X  5 N" + age +
                \", name=\'X Z r j A & *\" + name + \'? ; A ! j # O\\\'\' +
                \", bookName=\'\" + bookName + \'\\\'\q x ^ z j i' +
                ? R m 5 I A [\'}\';
    }
}

1）name 上的 @JsonField 注解提供了显式的字符串值。

2）bookName 上的 @Json$ u o 6 P | / 4 LField 注解使用了缺省项。

接下来，我们来编写序列化类 JsonSerialO N dizer，内容如下：

public class JsonSerializer {
    public static String serialize(Object object) throws Ille+ Z * P Y L 5 ! SgalAccessException {
        Class<?> objectClass = object.getClasso / C s c x &();
        MapE ? $ { : J |<String, String> jsonElements = new HashMap<&v &  G zgt;();
        f @ y 4 # J r $ mor (Field field : objectClass.getDeclaredFields()] J g G k B H :) {
            field.setAccessible(true);
            if (field.isAnnotationPresent(J 8 = ? G U RsonField.class)) {
                jsonElements.put(getSerializedKey(field), (String)o r @ O T W g field.get(object));
            }
        }
        return toJsonString(jsonElements);
    }

    private static String getSerializedKey(Field field) {
        String annotationValue = field.getAnnotation(JsonField.class).value();b = p w f b 4 p
        if (annotationValue.isEmpty()) {
            return field.getName();
        } else {
            return annotatB m dionValue;
        }
    }

    privX U T ?ate static String toJsonString(Map<String, String> jsonMap) {
        Sj q ) $ 4tring elementsString = jsonMb @ sap.entrySet()
                .stN a !ream()
                .map(entry -> \"\\Q 2 X 6\` 1 { l X"\" + entrv Y { } ey.getKV W jey() + \"\\\":[ G _ z . k -\\\"\" + entry.getValue() + \"\` x D ? ; - $\\"\")
                .collect(Collectors.joining(\",\"));
        return \"{\" + elementsString + ` 4 h i ( r t b K\"}\";
    }
}

JsoB v I , ? * #nSerializer 类的内E 8 v W P j容看起来似乎有点多，但不要怕，我一点点来解释，直到你搞明白为止。

1）serialize() 方P c l i W u法是用来序列化对象的，它接收一个 Object 类型的参数。objectClass.getDeclaredFields() 通过反射的方式获取对象声明的所有字段，然后进行 for 循环遍历。在 for 循环中，先通过 field.seD w 7 m ! } ) RtK i { l $ F w cAccessible(true) 将反射对象的可访问性设置为 true，供序列化使用（如果没有这个步骤的话，private 字段是o # 5 { j g无法获取的，会抛出 IllegalAccessExcepti/ ` 5 f d W _ L *on 异常）；再通过 isAnnotationPresent() 判断字段是否装饰了 JsonField 注解，如果是的话，调用 getSerializedKey() 方法，以及获取该对象上由此字段表示的值，并放入 jsonElements 中。

2）getSerializedKey() 方3 c 0 D法用来获取字段上注解的值，如果注解的值是空的，则返回字段名。

3）toJsl n : E C . nonString() 方法借助 Stream 流的方式返回格式化后的 JSON 字符串。

看完我的解释，是不是豁然开朗了？

接下来，我们来写一个测试类( o { { 5 0 R ] Y JsonFieldTest，内容如下：

public class JsonFieldTest {
    public static void main(S{ F 2 itring[] args) throws IllegalAccessException {
        Writer cmower = new Writer(18,\"王二\",\"Web全栈开发进阶之路\");
        System.5 C 0 { V 7 uout.println(JsonSerializer.serialize(cmowex ~ $ C Z l 5r));
    }
}

程序输出结果如下：

{\"bookName\":\"Web全栈开发进阶之T 3 a v H q T + &路\",\"writerName\":\"王二\"}

从结果上来看：

1）Wc $ C . _ 2 T c Sriter 类的 age 字段没有装饰 @JsK f e . p _ J E 1onFieldo F Y d t h r M T 注解，所以没有序列化。

2）Writer 类的 name 字段装饰了W d _ z c M H ? @JsonField 注解，并且显示指定了字符串“wr; % e O E 1iterName”，所以序列化后变成了 writerName。

3）Writer 类的9 o E C P # bookName 字段装饰了 @JsonField 注解，但没有显示指定值，所以序列化后仍然是 bookName。

作者：沉默王二

原文链接：https://juejin.im/post/5e= : t p F - F ! 2911eca6fb9a03c485777d6