Java注解是如何玩转的,面试官和我聊了半个小时

·  阅读 172
原文链接: mp.weixin.qq.com

面试官:自定义的Java注解是如何生效的? 

小白:自定义注解后,需要定义这个注解的注解解析及处理器,在这个注解解析及处理器的内部,通过反射使用Class、Method、Field对象的getAnnotation()方法可以获取各自位置上的注解信息,进而完成注解所需要的行为,例如给属性赋值、查找依赖的对象实例等。

面试官:你说的是运行时的自定义注解解析处理,如果要自定义一个编译期生效的注解,如何实现? 

小白:自定义注解的生命周期在编译期的,声明这个注解时@Retention的值为RetentionPolicy.CLASS,需要明确的是此时注解信息保留在源文件和字节码文件中,在JVM加载class文件后,注解信息不会存在内存中。声明一个类,这个类继承javax.annotation.processing.AbstractProcessor抽象类,然后重写这个抽象类的process方法,在这个方法中完成注解所需要的行为。

面试官:你刚刚说的这种方式的实现原理是什么? 

小白:在使用javac编译源代码的时候,编译器会自动查找所有继承自AbstractProcessor的类,然后调用它们的process方法,通过RoundEnvironment#getElementsAnnotatedWith方法可以获取所有标注某注解的元素,进而执行相关的行为动作。

面试官:有如下的一个自定义注解,在使用这个注解的时候,它的value值是存在哪的?

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Test {     String value() default "";}复制代码

小白:使用javap -verbose命令查看这个注解的class文件,发现这个注解被编译成了接口,并且继承了java.lang.annotation.Annotation接口,接口是不能直接实例化使用的,当在代码中使用这个注解,并使用getAnnotation方法获取注解信息时,JVM通过动态代理的方式生成一个实现了Test接口的代理对象实例,然后对该实例的属性赋值,value值就存在这个代理对象实例中。

Classfile /Test/bin/Test.class    Last modified 2020-3-23; size 423 bytes  MD5 checksum be9fb08ef7e5f2c4a1bca7d6f856cfa5  Compiled from "Test.java"public interface Test extends java.lang.annotation.Annotation  minor version: 0  major version: 52  flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATIONConstant pool:   #1 = Class              #2             // Test   #2 = Utf8               Test   #3 = Class              #4             // java/lang/Object   #4 = Utf8               java/lang/Object   #5 = Class              #6             // java/lang/annotation/Annotation   #6 = Utf8               java/lang/annotation/Annotation   #7 = Utf8               value   #8 = Utf8               ()Ljava/lang/String;   #9 = Utf8               AnnotationDefault  #10 = Utf8               T  #11 = Utf8               SourceFile  #12 = Utf8               Test.java  #13 = Utf8               RuntimeVisibleAnnotations  #14 = Utf8               Ljava/lang/annotation/Target;  #15 = Utf8               Ljava/lang/annotation/ElementType;  #16 = Utf8               TYPE  #17 = Utf8               Ljava/lang/annotation/Retention;  #18 = Utf8               Ljava/lang/annotation/RetentionPolicy;  #19 = Utf8               RUNTIME{  public abstract java.lang.String value();    descriptor: ()Ljava/lang/String;    flags: ACC_PUBLIC, ACC_ABSTRACT    AnnotationDefault:      default_value: s#10}SourceFile: "Test.java"RuntimeVisibleAnnotations:  0: #14(#7=[e#15.#16])  1: #17(#7=e#18.#19)复制代码

面试官:有没有看过这部分的实现源代码? 

小白:看过,如果顺着getAnnotation方法继续跟踪源代码,会发现创建代理对象是在AnnotationParser.java中实现的,这个类中有一个annotationForMap方法,它的具体代码如下:

    public static Annotation annotationForMap(        Class type, Map<String, Object>memberValues) {        return (Annotation) Proxy.newProxyInstance(            type.getClassLoader(), newClass[] { type },            new AnnotationInvocationHandler(type, memberValues));    }复制代码

这里使用Proxy.newProxyInstance方法在运行时动态创建代理,AnnotationInvocationHandler实现了InvocationHandler接口,当调用代理对象的value()方法获取注解的value值,就会进入AnnotationInvocationHandler类中的invoke方法,深入invoke方法会发现,获取value值最终是从AnnotationInvocationHandler类的memberValues属性中获取的,memberValues是一个Map类型,key是注解的属性名,这里就是“value”,value是使用注解时设置的值。

    public Object invoke(Object var1, Method var2, Object[] var3) {        String var4 = var2.getName();        Class[] var5 = var2.getParameterTypes();        if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {            return this.equalsImpl(var3[0]);        } else if (var5.length != 0) {            throw new AssertionError("Too many parameters for an annotation method");        } else {            byte var7 = -1;            switch(var4.hashCode()) {            case -1776922004:                if (var4.equals("toString")) {                    var7 = 0;                }                break;            case 147696667:                if (var4.equals("hashCode")) {                    var7 = 1;                }                break;            case 1444986633:                if (var4.equals("annotationType")) {                    var7 = 2;                }            }            switch(var7) {            case 0:                return this.toStringImpl();            case 1:                return this.hashCodeImpl();            case 2:                return this.type;            default:                Object var6 = this.memberValues.get(var4);                if (var6 == null) {                    throw new IncompleteAnnotationException(this.type, var4);                } else if (var6 instanceof ExceptionProxy) {                    throw ((ExceptionProxy)var6).generateException();                } else {                    if (var6.getClass().isArray() && Array.getLength(var6) != 0) {                        var6 = this.cloneArray(var6);                    }                    return var6;                }            }        }    }复制代码

面试官:JDK动态代理创建中的InvocationHandler充当什么样的角色? 

小白:InvocationHandler是一个接口,代理类的调用处理器,每个代理对象都具有一个关联的调用处理器,用于指定动态生成的代理类需要完成的具体操作。该接口中有一个invoke方法,代理对象调用任何目标接口的方法时都会调用这个invoke方法,在这个方法中进行目标类的目标方法的调用。

面试官:对于JDK动态代理,生成的代理类是什么样的?为什么调用代理类的任何方法时都一定会调用invoke方法? 

小白:假设有一个LoginService接口,这个接口中只有一个login方法,LoginServiceImpl实现了LoginService接口,同时使用Proxy.newProxyInstance创建代理,具体代码如下:

public interface LoginService {    voidlogin();}public class LoginServiceImpl implements LoginService {    @Override    public void login() {        System.out.println("login");    }}public class ProxyInvocationHandler implements InvocationHandler {    private LoginService loginService;    public ProxyInvocationHandler (LoginService loginService) {        this.loginService = loginService;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        beforeLogin();        Object invokeResult = method.invoke(loginService, args);        afterLogin();        return invokeResult;    }    private void beforeLogin() {        System.out.println("before login");    }    private void afterLogin() {        System.out.println("after login");    }}public classClient{    @Test    public voidt est() {        LoginService loginService = new LoginServiceImpl();        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler(loginService);        LoginService loginServiceProxy = (LoginService) Proxy.newProxyInstance(loginService.getClass().getClassLoader(), loginService.getClass().getInterfaces(), proxyInvocationHandler);        loginServiceProxy.login();        createProxyClassFile();    }    public static void createProxyClassFile() {        String name = "LoginServiceProxy";        byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{LoginService.class});        try {            FileOutputStream out = new FileOutputStream("/Users/" + name + ".class");            out.write(data);            out.close();        } catch (Exception e) {            e.printStackTrace();        }    }}复制代码

这个要从Proxy.newProxyInstance方法的源码开始分析,这个方法用于创建代理类对象,具体代码段如下:

        Class<?> cl = getProxyClass0(loader, intfs);        /*         * Invoke its constructor with the designated invocation handler.         */        try {            final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {                // create proxy instance with doPrivilege as the proxy class may                // implement non-public interfaces that requires a special permission                return AccessController.doPrivileged(new PrivilegedAction<Object>() {                    public Object run() {                        return newInstance(cons, ih);                    }                });            } else {                return newInstance(cons, ih);            }        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString());        }复制代码

上面的代码段中,先关注一下如下代码:

final Constructor<?> cons = cl.getConstructor(constructorParams);复制代码

用于获取代理类的构造函数,constructorParams参数其实就是一个InvocationHandler,所以从这里猜测代理类中有一个InvocationHandler类型的属性,并且作为构造函数的参数。那这个代理类是在哪里创建的?注意看上面的代码段中有:

Class<?> cl = getProxyClass0(loader, intfs);复制代码

这里就是动态创建代理类的地方,继续深入到getProxyClass0方法中,方法如下:

private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }        // If the proxy class defined by the given loader implementing        // the given interfaces exists, this will simply return the cached copy;        // otherwise, it will create the proxy class via the ProxyClassFactory        return proxyClassCache.get(loader, interfaces);    }复制代码

继续跟踪代码,进入proxyClassCache.get(loader, interfaces),这个方法中重点关注如下代码:

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));复制代码

继续跟踪代码,进入subKeyFactory.apply(key, parameter),进入apply方法,这个方法中有很多重要的信息,如生成的代理类所在的包名,发现重要代码:

long num = nextUniqueNumber.getAndIncrement();String proxyName = proxyPkg + proxyClassNamePrefix + num;复制代码

上面代码用于生成代理类名称,nextUniqueNumber是AtomicLong类型,是一个全局变量,所以nextUniqueNumber.getAndIncrement()会使用当前的值加一得到新值;proxyClassNamePrefix声明如下:

private static final String proxyClassNamePrefix = "$Proxy";复制代码

所以,这里生成的代理类类名格式为:包名+$Proxy+num,如jdkproxy.$Proxy12。

代理类的类名已经构造完成了,那可以开始创建代理类了,继续看代码,

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);复制代码

这里就是真正创建代理类的地方,继续分析代码,进入generateProxyClass方法,

public static byte[] generateProxyClass(final String var0, Class[] var1) {        ProxyGenerator var2 = new ProxyGenerator(var0, var1);        final byte[] var3 = var2.generateClassFile();        if(saveGeneratedFiles) {            AccessController.doPrivileged(new PrivilegedAction() {                public Void run() {                    try {                        FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");                        var1.write(var3);                        var1.close();                        return null;                    } catch (IOException var2) {                        throw new InternalError("I/O exception saving generated file: " + var2);                    }                }            });        }        return var3;    }复制代码

从这里可以很直白的看到,生成的代理类字节码文件被输出到某个目录下了,这里可能很难找到这个字节码文件,没关系,仔细查看这个方法,generateProxyClass方法可以重用,可以在外面调用generateProxyClass方法,把生成的字节码文件输出到指定位置。写到这里,终于可以解释上面实例代码中的createProxyClassFile方法了,这个方法把代理类的字节码文件输出到了/Users路径下,直接到路径下查看LoginServiceProxy文件,使用反编译工具查看,得到的代码如下,

public final class LoginServiceProxy extends Proxy  implements LoginService{  private static Method m1;  private static Method m3;  private static Method m0;  private static Method m2;  public LoginServiceProxy(InvocationHandler paramInvocationHandler)    throws   {    super(paramInvocationHandler);  }  public final boolean equals(Object paramObject)    throws   {    try    {      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final void login()    throws   {    try    {      this.h.invoke(this, m3, null);      return;    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final int hashCode()    throws   {    try    {      return ((Integer)this.h.invoke(this, m0, null)).intValue();    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final String toString()    throws   {    try    {      return (String)this.h.invoke(this, m2, null);    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  static  {    try    {      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });      m3 = Class.forName("jdkproxy.LoginService").getMethod("login", new Class[0]);      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);      return;    }    catch (NoSuchMethodException localNoSuchMethodException)    {      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());    }    catch (ClassNotFoundException localClassNotFoundException)    {      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());    }  }}复制代码

从上面的代码可以看到,当代理类调用目标方法时,会调用InvocationHandler接口实现类的invoke方法,很明了的解释了为什么调用目标方法时一定会调用invoke方法。


推荐阅读:

String引发的提问,我差点跪了

就写了一行代码,被问了这么多问题

面试官:JVM对锁进行了优化,都优化了啥?

synchronized连环问

高并发编程-ExecutorCompletionService深入解析

如何去除代码中的多次if而引发的一连串面试问题

点点底部右下角" 在看 "呗

分类:
后端
标签:
分类:
后端
标签: