Java 11 Removed/Deprecated Features & Migration

    jakarta.xml.bind
    jakarta.xml.bind-api
    4.0.2


    org.glassfish.jaxb
    jaxb-runtime
    4.0.5
    runtime

    javax.xml.bind
    jaxb-api
    2.3.1


    org.glassfish.jaxb
    jaxb-runtime
    2.3.9
    runtime

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.StringWriter;

@XmlRootElement
public class Employee {
    private String name;
    private String department;

    // Default constructor required by JAXB
    public Employee() {}

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getDepartment() { return department; }
    public void setDepartment(String department) { this.department = department; }

    public static void main(String[] args) throws Exception {
        Employee emp = new Employee("Alice", "Engineering");

        JAXBContext context = JAXBContext.newInstance(Employee.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

        StringWriter writer = new StringWriter();
        marshaller.marshal(emp, writer);
        System.out.println(writer.toString());
    }
}

// Output (after adding JAXB dependency):
// 
// 
//     Engineering
//     Alice
// 

    jakarta.xml.ws
    jakarta.xml.ws-api
    4.0.2


    com.sun.xml.ws
    jaxws-rt
    4.0.3
    runtime

    jakarta.activation
    jakarta.activation-api
    2.1.3

    jakarta.annotation
    jakarta.annotation-api
    3.0.0




    javax.annotation
    javax.annotation-api
    1.3.2

    org.openjfx
    javafx-controls
    21.0.5


    org.openjfx
    javafx-fxml
    21.0.5




    org.openjfx
    javafx-maven-plugin
    0.0.8
    
        com.example.App
    

// build.gradle
plugins {
    id 'org.openjfx.javafxplugin' version '0.1.0'
}

javafx {
    version = "21.0.5"
    modules = ['javafx.controls', 'javafx.fxml']
}

    org.graalvm.js
    js
    23.0.3


    org.graalvm.js
    js-scriptengine
    23.0.3

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class JavaScriptExample {
    public static void main(String[] args) throws Exception {
        // With GraalJS on the classpath, this uses GraalJS instead of Nashorn
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("graal.js");

        if (engine != null) {
            Object result = engine.eval("1 + 2 + 3");
            System.out.println("Result: " + result);  // Result: 6
        } else {
            System.out.println("GraalJS engine not found. Add graaljs dependency.");
        }
    }
}

// This worked in Java 8 but may not in Java 11:
// Accessing internal JDK APIs
import sun.misc.Unsafe;           // Encapsulated in java.base
import sun.misc.BASE64Encoder;     // Removed entirely

// Fix: Use the public API equivalents
import java.util.Base64;           // Replacement for BASE64Encoder/Decoder
// For Unsafe, use VarHandle (Java 9+) or MethodHandles

// Warning you may see at runtime:
// WARNING: An illegal reflective access operation has occurred
// WARNING: Illegal reflective access by org.springframework.core.io.support...
// WARNING: Please consider reporting this to the maintainers of org.springframework...

// Fix: Add --add-opens flags to your JVM startup
// For Spring Boot applications, add to your startup script or JAVA_OPTS:
// java --add-opens java.base/java.lang=ALL-UNNAMED \
//      --add-opens java.base/java.lang.reflect=ALL-UNNAMED \
//      --add-opens java.base/java.util=ALL-UNNAMED \
//      -jar myapp.jar

// For Maven Surefire plugin (test execution):
// 
//     org.apache.maven.plugins
//     maven-surefire-plugin
//     3.2.5
//     
//         
//             --add-opens java.base/java.lang=ALL-UNNAMED
//             --add-opens java.base/java.util=ALL-UNNAMED
//         
//     
// 

import java.util.Base64;

public class Base64Migration {
    public static void main(String[] args) {
        String original = "Hello, Java 11!";

        // --- BEFORE: Java 8 internal API (REMOVED in Java 11) ---
        // sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
        // String encoded = encoder.encode(original.getBytes());
        // sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
        // byte[] decoded = decoder.decodeBuffer(encoded);

        // --- AFTER: Standard API (Java 8+) ---
        // Encode
        String encoded = Base64.getEncoder().encodeToString(original.getBytes());
        System.out.println("Encoded: " + encoded);

        // Decode
        byte[] decodedBytes = Base64.getDecoder().decode(encoded);
        String decoded = new String(decodedBytes);
        System.out.println("Decoded: " + decoded);

        // URL-safe encoding (for URLs and filenames)
        String urlEncoded = Base64.getUrlEncoder().encodeToString(original.getBytes());
        System.out.println("URL-safe: " + urlEncoded);

        // MIME encoding (with line breaks every 76 chars)
        String mimeEncoded = Base64.getMimeEncoder().encodeToString(
                "A longer string that would benefit from MIME line wrapping".getBytes());
        System.out.println("MIME: " + mimeEncoded);
    }
}

// Output:
// Encoded: SGVsbG8sIEphdmEgMTEh
// Decoded: Hello, Java 11!
// URL-safe: SGVsbG8sIEphdmEgMTEh
// MIME: QSBsb25nZXIgc3RyaW5nIHRoYXQgd291bGQgYmVuZWZpdCBmcm9tIE1JTUUgbGluZSB3cmFw
// cGluZw==

// Command: scan a JAR for internal API dependencies
// jdeps --jdk-internals myapp.jar
//
// Example output:
// myapp.jar -> java.base
//    com.myapp.util.Encoder -> sun.misc.BASE64Encoder  JDK internal API (removed)
//    com.myapp.security.Crypto -> sun.security.ssl.SSLSessionImpl  JDK internal API
//
// Command: check module dependencies
// jdeps --module-path libs --print-module-deps myapp.jar
//
// Example output:
// java.base,java.logging,java.sql,java.xml

    11
    11
    11



    
        
        
            org.apache.maven.plugins
            maven-compiler-plugin
            3.12.1
            
                11
            
        

        
        
            org.apache.maven.plugins
            maven-surefire-plugin
            3.2.5
            
                
                
                    --add-opens java.base/java.lang=ALL-UNNAMED
                    --add-opens java.base/java.util=ALL-UNNAMED
                
            
        
    

plugins {
    id 'java'
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

// Or using toolchains (Gradle 6.7+, preferred approach):
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

// Add module opens for tests if needed
tasks.withType(Test).configureEach {
    jvmArgs(
        '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
        '--add-opens', 'java.base/java.util=ALL-UNNAMED'
    )
}

// Dockerfile -- BEFORE (Java 8)
// FROM openjdk:8-jdk-slim
// COPY target/myapp.jar /app/myapp.jar
// CMD ["java", "-jar", "/app/myapp.jar"]

// Dockerfile -- AFTER (Java 11)
// FROM eclipse-temurin:11-jdk-jammy
// COPY target/myapp.jar /app/myapp.jar
// CMD ["java", \
//      "--add-opens", "java.base/java.lang=ALL-UNNAMED", \
//      "-jar", "/app/myapp.jar"]

// For production, use JRE instead of JDK:
// FROM eclipse-temurin:11-jre-jammy
// COPY target/myapp.jar /app/myapp.jar
// CMD ["java", "-jar", "/app/myapp.jar"]

import java.util.Base64;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Collectors;

/**
 * This class demonstrates code AFTER migration to Java 11.
 * Comments show what the Java 8 version looked like.
 */
public class MigrationExample {

    // BEFORE (Java 8): Used sun.misc.BASE64Encoder
    // private static String encodeBase64(byte[] data) {
    //     return new sun.misc.BASE64Encoder().encode(data);
    // }

    // AFTER (Java 11): Use java.util.Base64
    private static String encodeBase64(byte[] data) {
        return Base64.getEncoder().encodeToString(data);
    }

    // BEFORE (Java 8): Used javax.xml.bind for hex encoding
    // private static String bytesToHex(byte[] bytes) {
    //     return javax.xml.bind.DatatypeConverter.printHexBinary(bytes);
    // }

    // AFTER (Java 11): Manual hex conversion or HexFormat (Java 17+)
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    // BEFORE (Java 8): Verbose file reading
    // private static String readFile(String path) throws Exception {
    //     byte[] bytes = java.nio.file.Files.readAllBytes(
    //         java.nio.file.Paths.get(path));
    //     return new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
    // }

    // AFTER (Java 11): One-line file reading
    private static String readFile(String path) throws Exception {
        return Files.readString(Path.of(path));
    }

    // BEFORE (Java 8): Verbose blank check
    // private static boolean isNullOrBlank(String str) {
    //     return str == null || str.trim().isEmpty();
    // }

    // AFTER (Java 11): Using isBlank()
    private static boolean isNullOrBlank(String str) {
        return str == null || str.isBlank();
    }

    // BEFORE (Java 8): Collection to typed array
    // private static String[] toArray(List list) {
    //     return list.toArray(new String[0]);
    // }

    // AFTER (Java 11): Cleaner toArray
    private static String[] toArray(List list) {
        return list.toArray(String[]::new);
    }

    public static void main(String[] args) throws Exception {
        // Demonstrate all migrated methods
        System.out.println("Base64: " + encodeBase64("Hello Java 11".getBytes()));
        System.out.println("Hex: " + bytesToHex("Hi".getBytes()));
        System.out.println("isNullOrBlank(null): " + isNullOrBlank(null));
        System.out.println("isNullOrBlank(\"  \"): " + isNullOrBlank("  "));
        System.out.println("isNullOrBlank(\"hi\"): " + isNullOrBlank("hi"));

        // Write and read a file using Java 11 APIs
        Path tempFile = Path.of("migration-test.txt");
        Files.writeString(tempFile, "Java 11 migration successful!");
        System.out.println("File content: " + readFile("migration-test.txt"));

        // Cleanup
        Files.deleteIfExists(tempFile);

        // Type-safe toArray
        List names = List.of("Alice", "Bob", "Charlie");
        String[] array = toArray(names);
        System.out.println("Array: " + java.util.Arrays.toString(array));
    }
}

// Output:
// Base64: SGVsbG8gSmF2YSAxMQ==
// Hex: 4869
// isNullOrBlank(null): true
// isNullOrBlank("  "): true
// isNullOrBlank("hi"): false
// File content: Java 11 migration successful!
// Array: [Alice, Bob, Charlie]

// Use Parallel GC (Java 8 behavior)
// java -XX:+UseParallelGC -jar myapp.jar

// Use G1 GC (Java 11 default, explicit for clarity)
// java -XX:+UseG1GC -jar myapp.jar

// Tune G1 pause target (default 200ms)
// java -XX:+UseG1GC -XX:MaxGCPauseMillis=100 -jar myapp.jar

// Epsilon GC (no-op collector, Java 11+) -- for benchmarking only
// java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC -jar myapp.jar

// ZGC (experimental in Java 11, production-ready in Java 15)
// java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -jar myapp.jar

// 1. Check current Java version
// java -version

// 2. Scan JARs for internal API usage
// jdeps --jdk-internals myapp.jar
// jdeps --jdk-internals --multi-release 11 myapp.jar

// 3. Find module dependencies
// jdeps --print-module-deps myapp.jar

// 4. Search codebase for removed APIs
// grep -r "import javax.xml.bind" src/
// grep -r "import javax.xml.ws" src/
// grep -r "import javax.annotation" src/
// grep -r "import sun.misc" src/
// grep -r "import com.sun" src/

// 5. Check Maven dependency tree for conflicts
// mvn dependency:tree
// mvn dependency:analyze

// 6. Run tests with Java 11
// mvn clean test -Dmaven.compiler.release=11

// 7. Create custom runtime image (optional, reduces deployment size)
// jlink --add-modules java.base,java.sql,java.logging \
//        --output custom-jre \
//        --strip-debug \
//        --compress 2