A & D Ub-543 Blood Pressure Monitor Reviews

Experiment with lawmaking that uses the new jakarta.* APIs.

At present that the Jakarta EE project is planning to release its next version (Jakarta EE ix), where the major alter is the update of all its APIs to use jakarta.* instead of javax.* in the packet names, and hence the issue of breaking binary compatibility, I decided to experiment a little bit with how code that uses javax.* APIs tin can exist dynamically modified (without the demand to recompile) then that it runs confronting the target dki jakarta.* namespace.

You may also similar:  Dki jakarta EE and the Great Naming Debate

Information technology would likewise be a skillful opportunity to acquire more than nigh Javassist, which I'll be using to do the renaming at the bytecode level. Note that this postal service is not intended to propose a solution to this problem of API compatibility. It but shares experimentation related to the subject area.

A Little Bit of Background

Due to trademark restrictions imposed on the javax.* namespace, Jakarta EE volition rename all of its specifications to utilize djakarta.* in gild to motion frontwards with evolving the platform with features as the cloud-native Java platform. A major concern here is backward compatibility for existing applications and frameworks using the javax.* APIs in their code. So far, this business organization is not explicitly addressed equally part of the Jakarta EE specification.

About Javassist

Since this post deals with the dynamic manipulation of bytecode, ane popular tool for the job is Javassist. Information technology is a very powerful and well-maintained library for editing form files and is used past many popular projects in the Coffee ecosystem. Javassists provides both loftier-level and low-level APIs to manipulate bytecode. The low-level API is more flexible and allows editing the raw bytes of the class file, simply requires knowledge of the construction of a class file, following the JVM specification. In the instance that follows, the low-level API will be used. If you're not familiar with the structure of Coffee bytecode, hither'south an commodity that gives an introduction.

Sample Code Using `javax.*`

The starting indicate is some dummy code that uses an API nether the javax.* namespace (for instance, using a Dki jakarta EE 8 or Java EE viii API). Hither'due south a very simple program:

                      package case.jakartaee;  import javax.json.JsonString;  public class MyJsonString implements JsonString {      @Override     public ValueType getValueType() {         render ValueType.String;     }      @Override     public String getString() {         render "test";     }      @Override     public CharSequence getChars() {         return "test";     } }  packet example.jakartaee;  import javax.json.JsonString; import javax.json.JsonValue;  public form JakartaEESample {      static JsonValue jsonValue = new MyJsonString();      public static void master(String[] args) {         JsonValue jsonV = new MyJsonString();         Organization.out.println(((JsonString)jsonV).getString());     } }                  

So we have some code that uses the JSON Processing API in a very dummy (it doesn't what it does for the moment — all it matters is that it uses some javax API).

Allow's detach the lawmaking to meet what the bytecode looks like, for case for MyJsonString:

                      javap -v MyJsonString.class                  

                      Classfile MyJsonString.class   Last modified Nov 2, 2019; size 800 bytes   MD5 checksum a1f98cde65900b434fd184c4980ea911   Compiled from "MyJsonString.java" public class example.jakartaee.MyJsonString implements javax.json.JsonString   modest version: 0   major version: 55   flags: (0x0021) ACC_PUBLIC, ACC_SUPER   this_class: #1                          // case/jakartaee/MyJsonString   super_class: #3                         // java/lang/Object   interfaces: one, fields: 0, methods: 4, attributes: ii Constant pool:    #1 = Course              #2             // instance/jakartaee/MyJsonString    #2 = Utf8               example/jakartaee/MyJsonString    #3 = Grade              #four             // java/lang/Object    #four = Utf8               coffee/lang/Object    #v = Class              #half-dozen             // javax/json/JsonString    #6 = Utf8               javax/json/JsonString    #7 = Utf8                   #eight = Utf8               ()V    #9 = Utf8               Code   #10 = Methodref          #3.#11         // java/lang/Object."":()V   #11 = NameAndType        #7:#8          // "":()V   #12 = Utf8               LineNumberTable   #13 = Utf8               LocalVariableTable   #14 = Utf8               this   #15 = Utf8               Lexample/jakartaee/MyJsonString;   #16 = Utf8               getValueType   #17 = Utf8               ()Ljavax/json/JsonValue$ValueType;   #18 = Fieldref           #nineteen.#21        // javax/json/JsonValue$ValueType.String:Ljavax/json/JsonValue$ValueType;   #19 = Class              #20            // javax/json/JsonValue$ValueType   #twenty = Utf8               javax/json/JsonValue$ValueType   #21 = NameAndType        #22:#23        // STRING:Ljavax/json/JsonValue$ValueType;   #22 = Utf8               Cord   #23 = Utf8               Ljavax/json/JsonValue$ValueType;   #24 = Utf8               getString   #25 = Utf8               ()Ljava/lang/String;   #26 = String             #27            // test   #27 = Utf8               exam   #28 = Utf8               getChars   #29 = Utf8               ()Ljava/lang/CharSequence;   #30 = Utf8               SourceFile   #31 = Utf8               MyJsonString.java   #32 = Utf8               InnerClasses   #33 = Class              #34            // javax/json/JsonValue   #34 = Utf8               javax/json/JsonValue   #35 = Utf8               ValueType {   public example.jakartaee.MyJsonString();     descriptor: ()V     flags: (0x0001) ACC_PUBLIC     Code:       stack=one, locals=1, args_size=i          0: aload_0          i: invokespecial #10                 // Method java/lang/Object."":()5          four: return       LineNumberTable:         line 5: 0       LocalVariableTable:         Outset  Length  Slot  Proper noun   Signature             0       v     0  this   Lexample/jakartaee/MyJsonString;    public javax.json.JsonValue$ValueType getValueType();     descriptor: ()Ljavax/json/JsonValue$ValueType;     flags: (0x0001) ACC_PUBLIC     Code:       stack=1, locals=1, args_size=one          0: getstatic     #eighteen                 // Field javax/json/JsonValue$ValueType.STRING:Ljavax/json/JsonValue$ValueType;          3: areturn       LineNumberTable:         line ix: 0       LocalVariableTable:         Beginning  Length  Slot  Name   Signature             0       4     0  this   Lexample/jakartaee/MyJsonString;    public coffee.lang.Cord getString();     descriptor: ()Ljava/lang/Cord;     flags: (0x0001) ACC_PUBLIC     Lawmaking:       stack=1, locals=1, args_size=one          0: ldc           #26                 // String examination          2: areturn       LineNumberTable:         line 14: 0       LocalVariableTable:         Start  Length  Slot  Proper noun   Signature             0       3     0  this   Lexample/jakartaee/MyJsonString;    public java.lang.CharSequence getChars();     descriptor: ()Ljava/lang/CharSequence;     flags: (0x0001) ACC_PUBLIC     Code:       stack=1, locals=ane, args_size=1          0: ldc           #26                 // Cord test          2: areturn       LineNumberTable:         line xix: 0       LocalVariableTable:         Outset  Length  Slot  Proper noun   Signature             0       3     0  this   Lexample/jakartaee/MyJsonString; } SourceFile: "MyJsonString.java" InnerClasses:   public static concluding #35= #19 of #33;    // ValueType=course javax/json/JsonValue$ValueType of class javax/json/JsonValue                  

I've shown the total bytecode, but the important thing here is that you can see references to javax.json.JsonString and javax.json.JsonValue.ValueType (a nested enum) in the constant puddle, which is the long list of shared constants that are used inside method bodies. The constants for these classes are javax/json/JsonString in constant #6, and javax/json/JsonValue$ValueType in constant #20 (this is how the JVM names these types).

In that location is likewise another reference to javax.* in the bytecode, specifically in the method public javax.json.JsonValue$ValueType getValueType().

If we want to convert this form to employ jakarta.*, we demand to practise two things:

1. Rename occurrences of javax/json/JsonString and javax/json/JsonValue$ValueType in the constant pool
2. Change the descriptor of the method getValueType() and then that its render type becomes dki jakarta.json.JsonValue$ValueType.

Nosotros can practise this using Javassist as follows:

                      import javassist.*; import javassist.bytecode.*;   ClassPool classPool = ClassPool.getDefault();  CtClass ctClass = classPool.become("example.jakartaee.MyJsonString"); ClassFile classFile = ctClass.getClassFile();  ConstPool constPool = classFile.getConstPool(); constPool.renameClass("javax/json/JsonString", "jakarta/json/JsonString"); constPool.renameClass("javax/json/JsonValue$ValueType", "jakarta/json/JsonValue$ValueType");  MethodInfo getValueTypeMethod = classFile.getMethod("getValueType"); getValueTypeMethod.setDescriptor("()Ljakarta/json/JsonValue$ValueType;");  // overwrite the course file classFile.write(new DataOutputStream(new FileOutputStream("MyJsonString.course")));                  

The ConstPool.renameClass() handles the renaming within the abiding pool, while the MethodInfo.setDescriptor() modifies the descriptor of the method so that the render type is renamed. Finally, we overwrite the class file (we could also save it to a separate file).

Later on executing the in a higher place code, the new MyJsonString.class file has the updated bytecode. You can see that information technology now has new constants for the djakarta.* class and descriptor names, and the method descriptor is also updated:

                      ... #36 = Utf8               djakarta/json/JsonString #37 = Utf8               djakarta/json/JsonValue$ValueType #38 = Utf8               Ljakarta/json/JsonValue$ValueType; #39 = Utf8               ()Ljakarta/json/JsonValue$ValueType;  ...  public dki jakarta.json.JsonValue$ValueType getValueType();   descriptor: ()Ljakarta/json/JsonValue$ValueType;                  

Let'southward expect now at the other class file to modify, JakartaEESample.form. In this grade, nosotros have a field of blazon javax.json.JsonValue, and a local variable within the `main` method of the same type. Nosotros too do a cast to javax.json.JsonString.

Similar to what we did for MyJsonString.class, we tin can rename these classes in the constant puddle using ConstPool.renameClass(), and nosotros still take to modify the descriptor of the field (like we did for the method getValueType() in MyJsonString.grade:

                      CtClass ctClass = classPool.go("instance.jakartaee.JakartaEESample");         ClassFile classFile = ctClass.getClassFile();  ConstPool constPool = classFile.getConstPool(); constPool.renameClass("javax/json/JsonString", "dki jakarta/json/JsonString"); constPool.renameClass("javax/json/JsonValue", "djakarta/json/JsonValue");  FieldInfo fieldInfo = classFile.getFields().go(0); fieldInfo.setDescriptor("Ljakarta/json/JsonValue;");  // overwrite the class file classFile.write(new DataOutputStream(new FileOutputStream("JakartaEESample.grade")));                  

After executing the higher up code, the bytecode of JakartaEESample.class is updated with new constants for the jakarta.* types (which are in turn referenced in the master method) and with an updated field descriptor:

                      ... #30 = Grade              #47            // jakarta/json/JsonString #31 = Utf8               javax/json/JsonString #32 = InterfaceMethodref #30.#33        // jakarta/json/JsonString.getString:()Ljava/lang/String; ... #47 = Utf8               jakarta/json/JsonString #48 = Utf8               Ljakarta/json/JsonValue;  static dki jakarta.json.JsonValue jsonValue;     descriptor: Ljakarta/json/JsonValue;     flags: (0x0008) ACC_STATIC  ... public static void main(java.lang.String[]);     descriptor: ([Ljava/lang/String;)Five     flags: (0x0009) ACC_PUBLIC, ACC_STATIC     Lawmaking:       stack=2, locals=2, args_size=ane          0: new           #10                 // class case/jakartaee/MyJsonString          3: dup          4: invokespecial #12                 // Method example/jakartaee/MyJsonString."":()Five          7: astore_1          viii: getstatic     #24                 // Field java/lang/Organisation.out:Ljava/io/PrintStream;         11: aload_1         12: checkcast     #30                 // form djakarta/json/JsonString         15: invokeinterface #32,  1           // InterfaceMethod jakarta/json/JsonString.getString:()Ljava/lang/String;         20: invokevirtual #36                 // Method java/io/PrintStream.println:(Ljava/lang/String;)Five         23: return                  

Verifying That the Updated Code Runs!

Plain, nosotros want to make certain that the updated course files tin can run without any JVM fault. To do this, since nosotros don't take the real dki jakarta.* API released, we can create dummy versions of them:

                      package jakarta.json;  public interface JsonString {      Cord getString(); }  parcel jakarta.json;  public interface JsonValue {      public enum ValueType {         Array,         OBJECT,         STRING,         NUMBER,         Truthful,         FALSE,         NULL     } }                  

And we tin run provide these dummy interfaces on the classpath when running the form files that were updated past Javassist.

Conclusion

Using powerful libraries like Javassist, dynamic conversion of javax.* referencing lawmaking to the new jakarta.* packaging is doable. Yous can view the full lawmaking here.

Farther Reading

Jakarta EE and the Great Naming Debate

Jakarta Going Frontwards

Java EE Without javax: The Globe Won't Terminate This Time Either

millerseentrusels.blogspot.com

Source: https://dzone.com/articles/from-javax-to-jakarta-a-simple-proof-of-concept

Share this post