change sun.misc.Unsafe to jdk.internal.misc.Unsafe

Author: theshadowco

pom.xml

@@ -721,7 +721,7 @@
           <artifactId>maven-compiler-plugin</artifactId>
           <version>${version.plugin.maven.compiler}</version>
           <configuration>
-            <release>${version.java.target}</release>
+            <target>${version.java.target}</target>
           </configuration>
         </plugin>
         <plugin>

xstream/pom.xml

@@ -296,7 +296,7 @@
               <execution>
                 <id>compile-jdk16</id>
                 <configuration>
-                  <release>16</release>
+                  <target>16</target>
                   <testExcludes combine.self="override" />
                   <testIncludes>
                     <include>**/Record**</include>
@@ -330,7 +330,7 @@
               <execution>
                 <id>compile-jdk15</id>
                 <configuration>
-                  <release>15</release>
+                  <target>15</target>
                   <testExcludes combine.self="override" />
                   <testIncludes>
                     <include>**/Record**</include>
@@ -383,6 +383,8 @@
             <configuration>
               <compilerArgs>
                 <arg>-XDignore.symbol.file</arg>
+                <arg>--add-exports</arg>
+                <arg>java.base/jdk.internal.misc=ALL-UNNAMED</arg>
               </compilerArgs>
             </configuration>
           </plugin>
@@ -468,6 +470,7 @@
       --add-opens java.xml/com.sun.xml.internal.stream=ALL-UNNAMED
       --add-opens java.xml/com.sun.org.apache.xerces.internal.parsers=ALL-UNNAMED
       --add-opens java.xml/com.sun.org.apache.xerces.internal.util=ALL-UNNAMED
+      --add-opens java.base/jdk.internal.misc=ALL-UNNAMED
     </surefire.argline>
     <surefire.preview.arg/>
   </properties>

xstream/src/java/com/thoughtworks/xstream/converters/reflection/SunLimitedUnsafeReflectionProvider.java

@@ -12,15 +12,13 @@
 import com.thoughtworks.xstream.converters.ConversionException;
 import com.thoughtworks.xstream.converters.ErrorWritingException;
 
-import sun.misc.Unsafe;
-
+import jdk.internal.misc.Unsafe;
 
 /**
  * Instantiates a new object bypassing the constructor using undocumented internal JDK features.
  * <p>
  * The code in the constructor will never be executed and parameters do not have to be known. This is the same method
- * used by the internals of standard Java serialization, but relies on internal code (sun.misc.Unsafe) that may not be
- * present on all JVMs.
+ * used by the internals of standard Java serialization, but relies on internal code (jdk.internal.misc.Unsafe).
  * <p>
  * <p>
  * The implementation will use standard Java functionality to write any fields. This requires Java 5 as minimum runtime

xstream/src/java/com/thoughtworks/xstream/converters/reflection/SunUnsafeReflectionProvider.java

@@ -11,17 +11,19 @@
  */
 package com.thoughtworks.xstream.converters.reflection;
 
+import com.thoughtworks.xstream.core.JVM;
+
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
-
 /**
  * Instantiates a new object bypassing the constructor using undocumented internal JDK features.
  * <p>
  * The code in the constructor will never be executed and parameters do not have to be known. This is the same method
- * used by the internals of standard Java serialization, but relies on internal code (sun.misc.Unsafe) that may not be
- * present on all JVMs.
+ * used by the internals of standard Java serialization, but relies on internal code (jdk.internal.misc.Unsafe).
  * <p>
  * <p>
  * The implementation will use the same internals to write into fields. This is a lot faster and was additionally the
@@ -38,6 +40,7 @@ public class SunUnsafeReflectionProvider extends SunLimitedUnsafeReflectionProvi
     // references to the Field key are kept in the FieldDictionary
     private transient ConcurrentMap<Field, Long> fieldOffsetCache;
 
+    private static final Method PUT_REFERENCE_UNSAFE_METHOD = getPutReferenceMethod();
     /**
      * @since 1.4.7
      */
@@ -91,7 +94,7 @@ private void write(final Field field, final Object object, final Object value) {
                     throw ex;
                 }
             } else {
-                unsafe.putObject(object, offset, value);
+              putReferenceUnsafe(object, field, offset, value);
             }
 
         } catch (final IllegalArgumentException e) {
@@ -116,6 +119,29 @@ private Object readResolve() {
         return this;
     }
 
+    private static Method getPutReferenceMethod() {
+      Class<?> unsafeClass = unsafe.getClass();
+      String methodName = "putObject";
+      if(JVM.isVersion(12)) {
+        methodName = "putReference";
+      }
+      try {
+        return unsafeClass.getDeclaredMethod(methodName, Object.class, long.class, Object.class);
+      } catch (NoSuchMethodException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    private void putReferenceUnsafe(Object object, Field field, long offset, Object value) {
+      try {
+        PUT_REFERENCE_UNSAFE_METHOD.invoke(unsafe, object, offset, value);
+      } catch (IllegalAccessException | InvocationTargetException e) {
+        final ObjectAccessException ex = new ObjectAccessException("Cannot set field", e);
+        ex.add("field", object.getClass() + "." + field.getName());
+        throw ex;
+      }
+    }
+
     @Override
     protected void init() {
         super.init();

xstream/src/java/com/thoughtworks/xstream/core/JVM.java

@@ -95,7 +95,7 @@ static class Test {
         boolean test = true;
         Object unsafe = null;
         try {
-            final Class<?> unsafeClass = Class.forName("sun.misc.Unsafe");
+            final Class<?> unsafeClass = Class.forName("jdk.internal.misc.Unsafe");
             final Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
             unsafeField.setAccessible(true);
             unsafe = unsafeField.get(null);