带你入门Java注解

本文将从以下几点为你介绍java注解以及如何自定义

  • 引言
  • 注解定义
  • 注解意义
  • 注解分类
  • 自定义
  • 结束语

引言

Java注解在日常开发中经常遇到,但通常我们只是用它,难道你不会好奇注解是怎么实现的吗?为什么@Data的注解可以生成getter和setter呢?为什么@BindView可以做到不需要findViewById呢?为什么retrofit2只要写个接口就可以做网络请求呢?本文将为你一一解答其中的奥妙。另外注解依赖于反射,我相信绝大多数的Java开发者都写过反射,也都知道反射是咋回事,所以如果你还不理解反射,请先花几分钟熟悉后再阅读本文。

注解定义

Annotation也叫元数据,是代码层面的说明。它在JDK1.5以后被引入,与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素进行说明,注释。我们可以简单的理解注解只是一种语法标注,它是一种约束、标记。

注解意义

Java引入注解是想把某些元数据做到与代码强耦合。因为在JDK1.5以前,描述元数据都是使用xml的,但是xml总是表现出松耦合,导致文件过多时难以维护。比如Spring早期的注入xml,如今2.0大多转为注解注入。
虽然注解做到了强耦合,但是一些常量参数使用xml会显结构更加清晰,所以在日常使用时,总是会把xml和Annotation结合起来使用以达到最优使用。

注解分类

通常我们会按照注解的运行机制将其分类,但是在按照注解的运行机制分类之前,我们先按基本分类来看一遍注解。

基本分类

  • 内置注解(基本注解)
    内置注解只有三个,位于java.lang包下,他们分别是
    • @Override – 检查该方法是否是重载方法,如果发现其父类,或者是引用的接口中并没有该方法时,会报编译错误。
    • @Deprecated – 标记过时方法,如果使用该方法,会报编译警告。
    • @SuppressWarnings – 指示编译器去忽略注解中声明的警告。
  • 元注解
    元注解只有四个,位于java.lang.annotation包中
    • @Retention – 标识这个注解怎么保存,是只在代码中,还是编入class文件中,或者是在运行时可以通过反射访问
    • @Documented – 标记这些注解是否包含在用户文档中
    • @Target – 标记这个注解应该是哪种 Java 成员
      • ElementType.CONSTRUCTOR 构造方法声明
      • ElementType.FIELD 字段声明
      • ElementType.LOCAL_VARIABLE 局部变量声明
      • ElementType.METHOD 方法声明
      • ElementType.PACKAGE 包声明
      • ElementType.PARAMETER 参数声明
      • ElementType.TYPE 类、接口方法
    • @Inherited – 标记注解可继承
  • 自定义注解
    可以通过元注解来自定义

运行机制分类

主要是按照元注解中的@Retention参数将其分为三类

  • 源码注解(@Retention(RetentionPolicy.SOURCE))
    注解只在源码中存在,编译时丢弃,编译成.class文件就不存在了
  • 编译时注解(@Retention(RetentionPolicy.CLASS))
    编译时会记录到.class中,运行时忽略
  • 运行时注解(@Retention(RetentionPolicy.RUNTIME))
    运行时存在起作用,影响运行逻辑,可以通过反射读取

我们可以简单的把Java程序从源文件创建到程序运行的过程看作为两大步骤

  • 源文件由编译器编译成字节码
  • 字节码由java虚拟机解释运行

那么被标记为RetentionPolicy.SOURCE的注解只能保留在源码级别,即最多只能在源码中对其操作,被标记为RetentionPolicy.CLASS的被保留到字节码,所以最多只到字节码级别操作,那么对应的RetentionPolicy.RUNTIME可以在运行时操作。

自定义

前面的都是司空见惯的知识点,可能大家都知道或有有了解过,但是一说到自定义,估计够呛,那么下面就按运行机制的分类,每一类都自定义一个注解看下注解到底是怎么回事。

RetentionPolicy.RUNTIME

运行时注解通常需要先通过类的实例反射拿到类的属性、方法等,然后再遍历属性、方法获取位于其上方的注解,然后就可以做相应的操作了。
比如现在有一个Person的接口以及其实现类Student。

public interface Person {
    @PrintContent("来自注解 PrintContent 唱歌")
    void sing(String value);

    @PrintContent("来自注解 PrintContent 跑步")
    void run(String value);

    @PrintContent("来自注解 PrintContent 吃饭")
    void eat(String value);

    @PrintContent("来自注解 PrintContent 工作")
    void work(String value);
}
复制代码

实现类

public class Student implements Person {
    @Override
    public void sing(String value) {
        System.out.println(value == null ? "这是音乐课,我们在唱歌" : value);
    }

    @Override
    public void run(String value) {
        System.out.println(value == null ? "这是体育课,我们在跑步" : value);
    }

    @Override
    public void eat(String value) {
        System.out.println(value == null ? "中午我们在食堂吃饭" : value);
    }

    @Override
    public void work(String value) {
        System.out.println(value == null ? "我们的工作是学习" : value);
    }
}
复制代码

执行逻辑

@Autowired
    private Person person;

    public void student() {
        person.eat(null);
        person.run(null);
        person.sing(null);
        person.work(null);
    }
复制代码

我们需要实现的点

  1. 自定义属性注解@Autowired表示自动注入Student对象给person。
  2. 提供方法注解@PrintContent表示当value为null时打印的默认值,并在调用的方法前后插入自己想做的操作。

因为这是一个运行时的注解,所以我们需要反射先拿到这个注解,然后再对其进行操作。
Autowired的实现,可以看到非常简单,仅仅是先拿到类的所有属性,然后对其遍历,发现属性使用了Autowired注解并且是Person类型,那么就new一个Student为其赋值,这样就做到了自动注入的效果。

private static void inject(Object obj) {
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.getType() == Person.class) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    try {
                        Person student = new Student();
                        field.set(obj, student);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }}}
        }}
复制代码

如果是想当value为null时打印的注解的默认值,并在调用的方法前后插入自己想做的操作。这种对接口方法进行拦截并操作的称为动态代理,java提供Proxy.newProxyInstance支持。

private static void inject(Object obj) {
        Field[] declaredFields = obj.getClass().getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.getType() == Person.class) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    try {
                        Person student = new Student();
                        Class<?> cls = student.getClass();
                        Person person = (Person) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new DynamicSubject(student));
                        field.set(obj, person);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }}}
        }}
复制代码

其中需要自定义DynamicSubject,即对方法的真实拦截操作。这样就会把@PrintContent注解的值作为参数打印处理。

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.isAnnotationPresent(PrintContent.class)) {
            PrintContent printContent = method.getAnnotation(PrintContent.class);
            System.out.println(String.format("----- 调用 %s 之前 -----", method.getName()));
            method.invoke(object, printContent.value());
            System.out.println(String.format("----- 调用 %s 之后 -----/n", method.getName()));
            return proxy;
        }
        return null;
    }
复制代码

最后附上两个自定义的注解

@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintContent {
    String value();
}
复制代码

以上可以帮助你对retorfit2的理解,因为动态代理就是它的核心之一。如果你想学习更多,可以参考 仿retorfit2设计实现的Activity参数注入

RetentionPolicy.SOURCE

大家或许对@BindView生成代码有所怀疑,对@Data如何生成代码有所好奇,那么我们就自定义个@Data来看看怎么注解是怎么生成代码的。本文依赖于idea工具,并非google提供的@AutoService实现。
bean是开发中经常被使用的,getter、setter方法是被我们所厌弃写的,idea帮我们做了一键生成的插件工具,但是如果这一步都都不想操作呢?我只想用一个注解生成,比如下面的User类。

@Data
public class User {
    private Integer age;

    private Boolean sex;

    private String address;

    private String name;
}
复制代码

通过@Data就可以生成这样的类,是不是很神奇?

public class User{
    private Integer age;
    private Boolean sex;
    private String address;
    private String name;

    public User() {
    }

    public Integer getAge() {
        return this.age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean hasSex() {
        return this.sex;
    }

    public void isSex(Boolean sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return this.address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
复制代码

要实现这样的神奇操作,大概的思路是先自定义某个RetentionPolicy.SOURCE级别的注解,然后实现一个注解处理器并设置SupportedAnnotationTypes为当前的注解,最后在META-INF注册该注解处理器。所以首先我们定义Data注解。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
@Documented
public @interface Data {
}
复制代码

然后需要自定义注解处理器来处理Data注解

@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
}
复制代码

然后在resources/META-INF文件夹下新建services文件夹,如果没有META-INF也新建。然后在services文件夹里新建javax.annotation.processing.Processor文件,注意名字是固定的,打开文件后写上前面定义的注解处理器全称,比如com.data.DataProcessor,这样就表示该注解处理器被注册了。
待程序要执行的时候,编译器会先读取这里的文件然后扫描整个工程,如果工程中有使用已注册的注解处理器中的SupportedAnnotationTypes里的注解,那么就会执行对应的注解处理中的process方法。下面重点处理注解处理器AbstractProcessor,把大部分的解释都写在注解里。

@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----开始自动生成源代码");
        try {
            // 返回被注释的节点
            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Data.class);
            for (Element e : elements) {
                // 如果注释在类上
                if (e.getKind() == ElementKind.CLASS && e instanceof TypeElement) {
                    TypeElement element = (TypeElement) e;
                    // 类的全限定名
                    String classAllName = element.getQualifiedName().toString() + "New";
                    // 返回类内的所有节点
                    List<? extends Element> enclosedElements = element.getEnclosedElements();
                    // 保存字段的集合
                    Map<Name, TypeMirror> fieldMap = new HashMap<>();
                    for (Element ele : enclosedElements) {
                        if (ele.getKind() == ElementKind.FIELD) {
                            //字段的类型
                            TypeMirror typeMirror = ele.asType();
                            //字段的名称
                            Name simpleName = ele.getSimpleName();
                            fieldMap.put(simpleName, typeMirror);
                        }
                    }
                    // 生成一个Java源文件
                    String targetClassName = classAllName;
                    if (classAllName.contains(".")) {
                        targetClassName = classAllName.substring(classAllName.lastIndexOf(".") + 1);
                    }
                    JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(targetClassName);
                    // 写入代码
                    createSourceFile(classAllName, fieldMap, sourceFile.openWriter());
                } else {
                    return false;
                }
            }
        } catch (IOException e) {
            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage());
        }
        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----完成自动生成源代码");
        return true;
    }

  /**
  * 属性首字母大写
  */
    private String humpString(String name) {
        String result = name;
        if (name.length() == 1) {
            result = name.toUpperCase();
        }
        if (name.length() > 1) {
            result = name.substring(0, 1).toUpperCase() + name.substring(1);
        }
        return result;
    }

    private void createSourceFile(String className, Map<Name, TypeMirror> fieldMap, Writer writer) throws IOException {
        // 检查属性是否以 "get", "set", "is", "has" 这样的关键字开头,如果有这样的 属性就报错
        String[] errorPrefixes = {"get", "set", "is", "has"};
        for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
            String name = map.getKey().toString();
            for (String prefix : errorPrefixes) {
                if (name.startsWith(prefix)) {
                    throw new RuntimeException("Properties do not begin with 'get'、'set'、'is'、'has' in " + name);
                }
            }
        }
        String packageName;
        String targetClassName = className;
        if (className.contains(".")) {
            packageName = className.substring(0, className.lastIndexOf("."));
            targetClassName = className.substring(className.lastIndexOf(".") + 1);
        } else {
            packageName = "";
        }
        // 生成源代码
        JavaWriter jw = new JavaWriter(writer);
        jw.emitPackage(packageName);
        jw.beginType(targetClassName, "class", EnumSet.of(Modifier.PUBLIC));
        jw.emitEmptyLine();
        for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
            String name = map.getKey().toString();
            String type = map.getValue().toString();
            //字段
            jw.emitField(type, name, EnumSet.of(Modifier.PRIVATE));
            jw.emitEmptyLine();
        }
        for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
            String name = map.getKey().toString();
            String type = map.getValue().toString();
            String prefixGet = "get";
            String prefixSet = "set";
            if (type.equals("java.lang.Boolean")) {
                prefixGet = "has";
                prefixSet = "is";
            }
            //getter
            jw.beginMethod(type, prefixGet + humpString(name), EnumSet.of(Modifier.PUBLIC))
                    .emitStatement("return " + name)
                    .endMethod();
            jw.emitEmptyLine();
            //setter
            jw.beginMethod("void", prefixSet + humpString(name), EnumSet.of(Modifier.PUBLIC), type, name)
                    .emitStatement("this." + name + " = " + name)
                    .endMethod();
            jw.emitEmptyLine();
        }
        jw.endType().close();
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }
}
复制代码

至此整个Data的注解生成器就写完了,由于我们的idea没有对应的插件帮助我们做一些操作,所以生成的类编译生成字节码时会报已存在异常,所以如果你想更进一步,可以考虑写个插件,本文仅限注解,未提供这样的插件。
以上完成后,只要在data class头添加@Data注解,在编译程序之前,就可以看到target/classes中存在了我们生成的代码。至此你应该了解@BindView或者@Data的原理,或许你也可以尝试自定义一个ButterKnife框架。

RetentionPolicy.CLASS

字节码级别的实际上对应用程序员来说没多大作用,因为此类注解一般是在字节码文件上进行操作,我们一般理解整个过程是在.java编译为.class后在将要被加载到虚拟机之前。那么很显然RetentionPolicy.CLASS类别的注解是直接修改字节码文件的。所以一般用此注解需要底层开发人员的配合,或者当你需要造轮子了可以考虑用一下,不过需要ASM的配合来使用的,如果仅仅是开发应用基本用不到。
不过这里还是介绍下它的使用,先造场景:现在有个People类,其中有个size属性等于9,观察到上方的类注解是@Prinln(12),现在想在字节码层面把size的9替换为12。

@Prinln(12)
public class People {
    int size = 9;

    double phone = 12.0;

    Boolean sex;

    String name;
}
复制代码

由于我们并不知道字节码文件是怎么写的,所以需要先通过Show Bytecode的插件来查看类的字节码是啥样子的

// class version 52.0 (52)
// access flags 0x21
public class com/People {

  // compiled from: People.java

  @Lcom/ann/Prinln;(value=12) // invisible

  // access flags 0x0
  I size

  // access flags 0x2
  private D phone

  // access flags 0x2
  private Ljava/lang/Boolean; sex

  // access flags 0x2
  private Ljava/lang/String; name

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 12 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 14 L1
    ALOAD 0
    BIPUSH 9
    PUTFIELD com/People.size : I
   L2
    LINENUMBER 16 L2
    ALOAD 0
    LDC 12.0
    PUTFIELD com/People.phone : D
    RETURN
   L3
    LOCALVARIABLE this Lcom/People; L0 L3 0
    MAXSTACK = 3
    MAXLOCALS = 1
}
复制代码

虽然知道了是这样的,但还是看不懂啊,咋整呢?没关系,我们看ASMified。ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件,也可以在类被加载入 Java 虚拟机之前动态改变类行为。而且ASMified我们是可以看得懂的,虽然没学过,但是很好理解。比如上面的People的ASMified就是这样的。

public class PeopleDump implements Opcodes {

    public static byte[] dump() throws Exception {

        ClassWriter cw = new ClassWriter(0);
        FieldVisitor fv;
        MethodVisitor mv;
        AnnotationVisitor av0;

        cw.visit(52, ACC_PUBLIC + ACC_SUPER, "com/People", null, "java/lang/Object", null);

        cw.visitSource("People.java", null);
        {
            av0 = cw.visitAnnotation("Lcom/ann/Prinln;", false);
            av0.visit("value", new Integer(12));
            av0.visitEnd();
        }
        {
            fv = cw.visitField(0, "size", "I", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(ACC_PRIVATE, "phone", "D", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(ACC_PRIVATE, "sex", "Ljava/lang/Boolean;", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(ACC_PRIVATE, "name", "Ljava/lang/String;", null, null);
            fv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(12, l0);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLineNumber(14, l1);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitIntInsn(BIPUSH, 9);
            mv.visitFieldInsn(PUTFIELD, "com/People", "size", "I");
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitLineNumber(16, l2);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitLdcInsn(new Double("12.0"));
            mv.visitFieldInsn(PUTFIELD, "com/People", "phone", "D");
            mv.visitInsn(RETURN);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
            mv.visitMaxs(3, 1);
            mv.visitEnd();
        }
        cw.visitEnd();

        return cw.toByteArray();
    }
}
复制代码

这样的话,我们大概可以知道如果要改size=12,就只要把mv.visitIntInsn(BIPUSH, 9);这句话的9改为12就好了。不过ASM在原有的字节码文件中插入或删除或更改,本文未仔细研究。本文是简单粗暴的用新的字节码替换原字节码文件。

public void asm() {
        try {
            ClassReader classReader = new ClassReader(new FileInputStream("target/classes/com/People.class"));
            ClassNode classNode = new ClassNode();
            classReader.accept(classNode, ClassReader.SKIP_DEBUG);
            System.out.println("Class Name: " + classNode.name);
            AnnotationNode anNode = null;
            if (classNode.invisibleAnnotations.size() == 1) {
                anNode = classNode.invisibleAnnotations.get(0);
                System.out.println("Annotation Descriptor : " + anNode.desc);
                System.out.println("Annotation attribute pairs : " + anNode.values);
            }

            File file = new File("target/classes/com/People.class");
            FileOutputStream outputStream = new FileOutputStream(file);
            outputStream.write(copyFromBytecode(anNode == null ? 0 : (int) anNode.values.get(1)));

        } catch (IOException e) {
            e.printStackTrace();
        }

        People people = new People();
        System.out.println("people : " + people.size);
    }

    private byte[] copyFromBytecode(int value) {

        ClassWriter cw = new ClassWriter(0);
        FieldVisitor fv;
        MethodVisitor mv;
        AnnotationVisitor av0;

        cw.visit(52, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "com/People", null, "java/lang/Object", null);

        cw.visitSource("People.java", null);

        {
            av0 = cw.visitAnnotation("Lcom.ann.Prinln;", false);
            av0.visit("value", new Integer(12));
            av0.visitEnd();
        }
        {
            fv = cw.visitField(0, "size", "I", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(0, "phone", "D", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(0, "sex", "Ljava/lang/Boolean;", null, null);
            fv.visitEnd();
        }
        {
            fv = cw.visitField(0, "name", "Ljava/lang/String;", null, null);
            fv.visitEnd();
        }
        {
            mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(10, l0);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLineNumber(12, l1);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitIntInsn(Opcodes.BIPUSH, value);
            mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "size", "I");
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitLineNumber(14, l2);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitLdcInsn(new Double("12.0"));
            mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "phone", "D");
            mv.visitInsn(Opcodes.RETURN);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
            mv.visitMaxs(3, 1);
            mv.visitEnd();
        }
        cw.visitEnd();

        return cw.toByteArray();
    }
复制代码

实际上RetentionPolicy.CLASS的使用,ASM的配合很重要,所以当你在自己的框架中需要使用这种类型的注解的时候,建议还是学好ASM再尝试写此类注解,而不是像我这样全部替换。

结束语

本文注解虽然讲解的多,但是如果你能看完到这里,相信通过了几个例子的描述,你已经知道了几类注解的基本操作过程,已经让你对各种类型的注解有基本的认识,或许看了本文你真的理解了retrofit2、ButterKnife,甚至可以自己写个简单的retrofit2或ButterKnife的框架,那就再好不过了。
最后附上 源码
,感谢阅读。

原文 

https://juejin.im/post/5c529abb6fb9a04a0a5f9b81

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 带你入门Java注解

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址