java注解是怎么实现的？

Posted 2023-05-15

我一直很奇怪，拿junit4来讲，用注解@Before和@After 就可以代替setUp和tearDown这两个方法。方法名字都是继承来的啊……为什么用注解就可以随便叫方法名呢？我记得有本书说过注解都是用的反射机制，一句话概括了，但具体是怎么个原理？

//每个注解就是一个类
@注解接口类(接口属性=值)
//创建一个自定义注解
@Retention(RetentionPolicy.RUNTIME)    //运行时获得
@Target(ElementType.METHOD) //针对方法的注解
public @interface 自注标
       int 属性1();

//注解加在自己的普通类上
class A
  @自注标(属性1=123)   
   public void hello()
   

//在自己框架操作下游开发者的代码时，通过反射得到该注解的值123
自注标 a=A.getClass().getMethod("hello").getAnnotation(自注标.class);
int i=a.属性1();//就能获得用户注解值。进行相应的动作

参考技术A 写一个使用该注解的类：
import java.io.IOException;

/**
* Created by Administrator on 2015/1/18.
*/
@TestAnnotation(count = 0x7fffffff)
public class TestMain

public static void main(String[] args) throws InterruptedException, NoSuchFieldException, IllegalAccessException, IOException
TestAnnotation annotation = TestMain.class.getAnnotation(TestAnnotation.class);
System.out.println(annotation.count());
System.in.read();




反编译一下这段代码：
Classfile /e:/workspace/intellij/SpringTest/target/classes/TestMain.class
Last modified 2015-1-20; size 1006 bytes
MD5 checksum a2d5367ea568240f078d5fb1de917550
Compiled from "TestMain.java"
public class TestMain
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #10.#34 // java/lang/Object."<init>":()V
#2 = Class #35 // TestMain
#3 = Class #36 // TestAnnotation
#4 = Methodref #37.#38 // java/lang/Class.getAnnotation:(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
#5 = Fieldref #39.#40 // java/lang/System.out:Ljava/io/PrintStream;
#6 = InterfaceMethodref #3.#41 // TestAnnotation.count:()I
#7 = Methodref #42.#43 // java/io/PrintStream.println:(I)V
#8 = Fieldref #39.#44 // java/lang/System.in:Ljava/io/InputStream;
#9 = Methodref #45.#46 // java/io/InputStream.read:()I
#10 = Class #47 // java/lang/Object
#11 = Utf8 <init>
#12 = Utf8 ()V
#13 = Utf8 Code
#14 = Utf8 LineNumberTable
#15 = Utf8 LocalVariableTable
#16 = Utf8 this
#17 = Utf8 LTestMain;
#18 = Utf8 main
#19 = Utf8 ([Ljava/lang/String;)V
#20 = Utf8 args
#21 = Utf8 [Ljava/lang/String;
#22 = Utf8 annotation
#23 = Utf8 LTestAnnotation;
#24 = Utf8 Exceptions
#25 = Class #48 // java/lang/InterruptedException
#26 = Class #49 // java/lang/NoSuchFieldException
#27 = Class #50 // java/lang/IllegalAccessException
#28 = Class #51 // java/io/IOException
#29 = Utf8 SourceFile
#30 = Utf8 TestMain.java
#31 = Utf8 RuntimeVisibleAnnotations
#32 = Utf8 count
#33 = Integer 2147483647
#34 = NameAndType #11:#12 // "<init>":()V
#35 = Utf8 TestMain
#36 = Utf8 TestAnnotation
#37 = Class #52 // java/lang/Class
#38 = NameAndType #53:#54 // getAnnotation:(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
#39 = Class #55 // java/lang/System
#40 = NameAndType #56:#57 // out:Ljava/io/PrintStream;
#41 = NameAndType #32:#58 // count:()I
#42 = Class #59 // java/io/PrintStream
#43 = NameAndType #60:#61 // println:(I)V
#44 = NameAndType #62:#63 // in:Ljava/io/InputStream;
#45 = Class #64 // java/io/InputStream
#46 = NameAndType #65:#58 // read:()I
#47 = Utf8 java/lang/Object
#48 = Utf8 java/lang/InterruptedException
#49 = Utf8 java/lang/NoSuchFieldException
#50 = Utf8 java/lang/IllegalAccessException
#51 = Utf8 java/io/IOException
#52 = Utf8 java/lang/Class
#53 = Utf8 getAnnotation
#54 = Utf8 (Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
#55 = Utf8 java/lang/System
#56 = Utf8 out
#57 = Utf8 Ljava/io/PrintStream;
#58 = Utf8 ()I
#59 = Utf8 java/io/PrintStream
#60 = Utf8 println
#61 = Utf8 (I)V
#62 = Utf8 in
#63 = Utf8 Ljava/io/InputStream;
#64 = Utf8 java/io/InputStream
#65 = Utf8 read

public TestMain();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this LTestMain;

public static void main(java.lang.String[]) throws java.lang.InterruptedException, java.lang.NoSuchFieldException, java.lang.IllegalAccessException, java.io.IOException;
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: ldc #2 // class TestMain
2: ldc #3 // class TestAnnotation
4: invokevirtual #4 // Method java/lang/Class.getAnnotation:(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
7: checkcast #3 // class TestAnnotation
10: astore_1
11: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
14: aload_1
15: invokeinterface #6, 1 // InterfaceMethod TestAnnotation.count:()I
20: invokevirtual #7 // Method java/io/PrintStream.println:(I)V
23: getstatic #8 // Field java/lang/System.in:Ljava/io/InputStream;
26: invokevirtual #9 // Method java/io/InputStream.read:()I
29: pop
30: return
LineNumberTable:
line 10: 0
line 11: 11
line 12: 23
line 13: 30
LocalVariableTable:
Start Length Slot Name Signature
0 31 0 args [Ljava/lang/String;
11 20 1 annotation LTestAnnotation;
Exceptions:
throws java.lang.InterruptedException, java.lang.NoSuchFieldException, java.lang.IllegalAccessException, java.io.IOException

SourceFile: "TestMain.java"
RuntimeVisibleAnnotations:
0: #23(#32=I#33)

最后一行的代码说明，注解`TestAnnotation`的属性设置是在编译时就确定了的。（对属性的说明在[这里][1]）。

然后，运行上面的程序，通过CLHSDB在eden区找到注解实例，

hsdb> scanoops 0x00000000e1b80000 0x00000000e3300000 TestAnnotation
0x00000000e1d6c360 com/sun/proxy/$Proxy1

类型`com/sun/proxy/$Proxy1`是jdk动态代理生成对象时的默认类型，其中
`com.sun.proxy`是默认的包名，定义于`ReflectUtil`类的`PROXY_PACKAGE`字段中。代理类名`$PROXY1`
包含两部分，其中前缀`$PROXY`是jdk种默认的代理类类名前缀（参见`java.lang.reflect.Proxy`类的javadoc），
后的1是自增的结果。 参考技术B eclipse
ctrl 点进去 before 可以看到源码的吧

怎么动态给java注解参数赋值？

@WebService(name="", targetNamespace="，wsdlLocation="")
比如给上面name targetNamespace wsdlLocation赋值

动态赋值指的是在配置文件配置好然后在项目中动态读取？如果是这样的话：
1.在xml文件中使用<context:property-placeholder location="”/>
这种方式可以读取location指定位置对应的文件，引用的话使用$key可以获取对应的数据
和这种写法相同的还有
<bean class=“com.spring….config.PropertyPlaceholderConfigurer”>
<property name=“locations">
<array><value></value></array>
</property>
<bean>
这种是用bean来加载配置文件，看起来更直观
2.通过@Value注解读取配置
这种方法也需要预先在xml文件中设定好配置文件的位置
<bean id=“prop” class=“org.springframework.beans.factory.config.PropertiesFactoryBean”>
<property name=“locations”>
<array>
<value>classpath:.properties</value>
</array>
</property>
</bean>
之后在java代码里面可以用#prop.key来获取对应的数据prop是bean的名字，key是配置文件的键。
3.使用@PropertySource
在springboot中，可以不需要xml文件来设置配置文件，在需要使用配置文件的类名字前加上
@PropertySource(“locations")就可以读取指定位置的配置，在代码中使用@Value注解可以获取这些数据
@Value(value = “$key”)
4.使用@ConfigurationProperties(prefix=“”)
SpringBoot项目有时候会使用application.yml来存储配置信息，一般情况下这些数据的存储格式是
a:
key1:value1
key2:value2
这种嵌套方式，当然可以多层嵌套
在需要使用配置文件的类上面使用@ConfigurationProperties(prefix=“a”)可以获取a标签下一层所有的配置的键值对。 参考技术A 首先，你没有明白java注解的原理，java注解是元数据，在编译前固定的，因此，不能出现动态，如果你要动态，那么必须在程序中。 参考技术B Java运行时会维护一个String Pool（String池, String常量池, 字符串缓冲区)

String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。

而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区

String s = "accp";
创建s之前系统会先在"池子"中查找是否已经存在这个字符串, 如果存在则直接符号该字符串的句柄
如果不存在, 系统会创建一个新"accp"字符串, 并返回句柄, 以后再有"accp"被要求创建, 系统不会创建新的,而是直接返回已经存在的字符串的句柄

String s = new String("accp");
系统不会去"池子"中查找, 直接在内存中新开辟一块空间, 初始化为"accp",并返回句柄 参考技术C Java运行时会维护一个String Pool（String池, String常量池, 字符串缓冲区)

String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。

而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区

String s = "accp";
创建s之前系统会先在"池子"中查找是否已经存在这个字符串, 如果存在则直接符号该字符串的句柄
如果不存在, 系统会创建一个新"accp"字符串, 并返回句柄, 以后再有"accp"被要求创建, 系统不会创建新的,而是直接返回已经存在的字符串的句柄

String s = new String("accp");
系统不会去"池子"中查找, 直接在内存中新开辟一块空间, 初始化为"accp",并返回句柄 参考技术D 把引号换成变量