每日一问 | 当Unsafe遇上final，超神奇的事情发生了？

首先，能替换，替换的方式是使用sun.misc.Unsafe，方法如下：

class TKt {
    private static Unsafe unsafe;

    static {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void replaceObject(Object obj, String fieldName, Object newField) {

        try {
            Field nameField = Test.class.getDeclaredField(fieldName);
            long fieldOffset = unsafe.objectFieldOffset(nameField);
            System.out.println(fieldOffset);
            unsafe.putObject(obj, fieldOffset, newField);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

    }
}

Unsafe类是已经灰飞烟灭了的sun公司留下来的，这个类很强大，能够直接操作到内存，借助它能实现很多超脱java语言认知的事情，更多可参考https://mp.weixin.qq.com/s/h3MB8p0sEA7VnrMXFq9NBA

然后，替换之后的方法调用以及字段调用的返回是啥？

回答这个问题前，先来补充下知识：

1. 我们在代码上写下了一个方法调用之后，那个方法是怎样被调用的？
2. java的属性调用是咋处理的？

方法调用

先来看这段代码：

test.a.selfIntroduction()

这就是一个简单的方法调用，这个方法调用对应到字节码上是长什么样子了？

INVOKEVIRTUAL art/bytecode/yuan/A.selfIntroduction ()Ljava/lang/String;

可以看到这个调用具体写了调用哪一个类的哪一个方法，这个方法调用的简单流程是，找到这个方法，将调用这个方法的对象以及输入参数传进去，然后执行字节码指令。

字段引用

然后对于字段的调用，首先，对于一个java对象来说，其在内存中占的内存大小是确定的，如此我们才能够在new指令执行的时候为这个对象分配确定大小的内存空间，之后再创建的对象能够直接分配在这个内存空间的后面，这也是数组不能够自动扩容的原因，因为后面的内存可能已经被占用了。

然后，每一个对象，由于他的类结构是确定的，所以他所占的内存空间里，每一个字段的值存储的位置的偏移是确定的。

例如对于类：

class C {
    int i;
    double d;
    String s;
    int[] ints;
}

偏移分别为：

12
16
24
28

然后当调用时：

test.a.testField

其对应的字节码如下：

GETFIELD art/bytecode/yuan/A.testField : Ljava/lang/String;

他的基本流程是，根据这个类的信息，也就是art/bytecode/yuan/A类，计算出其testField 属性所对应的偏移，然后在当前对象去这个偏移值。

结果解析

然后回到我们最初的问题，看如下代码：

final class A {

    String selfIntroduction() {
        return "I'm A " + getClass().getName();
    }

    String testField = "I'm A field";
}

class B {

    String selfIntroduction() {
        return "I'm B " + getClass().getName();
    }

    String testField2 = "I'm B field22222222222";
    String testField = "I'm B field";

}

class Test {
    public final A a = new A();
}

public class TestMain {

    public static void main(String[] args) {
        Test test = new Test();
        B b = new B();

        System.out.println("替换前");
        System.out.println(test.a.selfIntroduction());

        TKt.replaceObject(test, "a", b);

        System.out.println("强转前");
        System.out.println(test.a.selfIntroduction());
        System.out.println(test.a.testField);
        System.out.println(test.a.getClass());

        System.out.println("强转后");
        Object obb = test.a;
        System.out.println(((B) obb).selfIntroduction());
        System.out.println(((B) obb).testField);

    }
}

他对应的结果如下：

替换前
I'm A art.bytecode.yuan.A
强转前
I'm A art.bytecode.yuan.B
I'm B field22222222222
class art.bytecode.yuan.B
强转后
I'm B art.bytecode.yuan.B
I'm B field

先看强转前的结果，由于方法调用的是A类的方法，前面的字符串就很好理解，然后，由于当前的对象以及被强制换成了B，所以类名是art.bytecode.yuan.B。

然后看field，testField是A类的第一个属性（偏移不为0，因为有对象头，存储GC信息hash等），所以逻辑是取当前传入的对象的第一个属性，由于传入的对象是B，所以取B的第一个属性，也就是I'm B field22222222222。

至于为啥能强转为B，很好理解，因为这个内存地址的对象真的是B。

然后强转后的打印的结果，就很好理解了。

然后如果把B换成如下：

class B {

    String selfIntroduction() {
        return "I'm B " + getClass().getName();
    }

    int i = 1;
    String testField2 = "I'm B field22222222222";
    String testField = "I'm B field";

}

在System.out.println(test.a.testField);这段代码处会报错，空指针，因为在打印的时候，是走的如下方法：

public void println(String x) {
    if (getClass() == PrintStream.class) {
        writeln(String.valueOf(x));
    } else {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
}

然后看

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

首先这个对象不是空的，因为有值1，然后就对他掉toString，显然1这个内存地址没有指向对象，所以空指针了。

如果把i的默认值改为0，这里就会打印null了。

其实你在这里也能看出为啥要叫Unsafe类了，因为判空了但还是报了空指针的情况都是有可能发生的。。。。。。。。。。。

然后对于这7个问题，你要是能读懂到这里，相信你已经有答案了。

补充：

看问题3：

当使用Unsafe把Test.a替换成B的对象实例之后，调用Test.a.selfIntroduction方法，返回的是什么？

按道理，既然已经替换成了B对象，调用其selfIntroduction方法，返回值肯定就是"I'm B"了吧？

写代码测试下：

final class A {
    String selfIntroduction() {
        return "I'm A";
    }
}

class B {
    String selfIntroduction() {
        return "I'm B";
    }
}

class Test {
    public final A a = new A();
}

public class TestMain {

    public static void main(String[] args) {
        Test test = new Test();
        B b = new B();

        System.out.println("替换前：");
        String toString = test.a.toString();
        String selfIntroduction = test.a.selfIntroduction();
        System.out.println("test.a = " + toString);
        System.out.println("test.a.selfIntroduction() = " + selfIntroduction);

        replaceObject(test, "a", b);

        System.out.println("替换后：");
        toString = test.a.toString();
        selfIntroduction = test.a.selfIntroduction();
        System.out.println("test.a = " + toString);
        System.out.println("test.a.selfIntroduction() = " + selfIntroduction);
    }

    private static boolean replaceObject(Object target, String fieldName, Object newObject) {
        try {
            Object unsafe = getUnsafe();
            long offset = objectFieldOffset(unsafe, target, fieldName);
            putObject(unsafe, target, offset, newObject);
            return true;
        } catch (Throwable t) {
            t.printStackTrace();
        }
        return false;
    }

    private static Object getUnsafe() throws Throwable {
        Class unsafeClass = Class.forName("sun.misc.Unsafe");
        Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        return unsafeField.get(null);
    }

    private static long objectFieldOffset(Object unsafe, Object target, String fieldName) throws Throwable {
        Method objectFieldOffsetMethod = unsafe.getClass().getDeclaredMethod("objectFieldOffset", Field.class);
        objectFieldOffsetMethod.setAccessible(true);
        return (long) objectFieldOffsetMethod.invoke(unsafe, target.getClass().getDeclaredField(fieldName));
    }

    private static void putObject(Object unsafe, Object target, long fieldOffset, Object newObject) throws Throwable {
        Method putObjectMethod = unsafe.getClass().getDeclaredMethod("putObject", Object.class, long.class, Object.class);
        putObjectMethod.setAccessible(true);
        putObjectMethod.invoke(unsafe, target, fieldOffset, newObject);
    }
}

我们在替换Test.a的前后，分别打印了一次它的toString和selfIntroduction方法的返回值。

运行结果：

！！！！！为什么？！！test.a明明已经变成了B的实例了，为什么此时调用selfIntroduction返回的还是 I'm A 呢？

看下字节码：

这是对象替换前的：

对象替换之后：

根本没区别嘛！

仔细看一下上面class A的代码，是用final修饰的，如果把它去掉，重新编译运行：

会发现，这次的结果是 "正常" 的。

去掉final之后，在替换对象后面的指令会发生什么变化吗？看看：

咦？调用的还是A类的selfIntroduction方法啊！

同样的指令，为什么有final修饰时，返回值是"I'm A"（也就是最终调用了A类的selfIntroduction方法），无final时就是"I'm B"呢？

其实是这样的：

熟悉java字节码的同学会知道，调用方法的指令有invokestatic、invokespecial、invokevirtual等，前面两个指令调用的方法，会在类加载时就钉死了，比如静态方法、private修饰的方法，还有构造函数等，因为它们都不会因为继承而改变原来的逻辑（非虚方法）。

invokevirtual就是调用常规的实例方法（虚方法），比如上面的a.selfIntroduction。

在执行invokevirtual指令（调用虚方法）时，考虑到子类的重写，会进行一个【动态分派】的流程：JVM会从目标类的【虚方法表】中找到对应方法的地址，如果目标类有重写父类方法，那么对应方法的地址会变成子类重写的那个方法的地址，其他没有被重写的方法，地址跟父类中的一样。

但是有一种情况例外！就是当这个方法被final修饰的时候！想想就知道了，final方法同样不会因为继承重写而覆盖原来的逻辑，所以它也是在类加载时确定的！也就是不管它当前引用的是哪个类的实例，最终调用的都是声明时的那个类的final方法！

现在可以解释，为什么a被替换B的对象实例之后，调用的仍然是A的final方法了：

因为final方法跟static、private方法一样，不会因为继承重写而改变原来的逻辑，所以在类加载时就能确定它的地址，当它被调用时，就不需要走【动态分派】流程（不需要查【虚方法表】）了。

问题4、6、7 @xujiafeng 同学已经讲了，就是因为字段偏移量的原因。这也能解释上面为什么去掉final后，明明字节码写着还是调用A类的selfIntroduction，最终却走了B类selfIntroduction的逻辑：因为【虚方法表】也是通过索引来排序的。

问题5，为什么B类没有了selfIntroduction方法依然不会报错？

如果你还是不明白，那我这个夜就白熬了。

每日一问:

看到答案还不懂,是不是可以退出开发圈了.

答案区,神仙打架啊