Install JDK 23.0.2 and Gradle 8.10.2 on Linux (x86_64, apt or dnf)

install-java-gradle.sh

#!/bin/bash
set -eo pipefail

JDK_VERSION="23.0.2"
JDK_SHA="017f4ed8e8234d85e5bc1e490bb86f23599eadb6cfc9937ee87007b977a7d762"
JDK_URL="https://download.java.net/java/GA/jdk23.0.2/6da2a6609d6e406f85c491fcb119101b/7/GPL/openjdk-23.0.2_linux-x64_bin.tar.gz"

GRADLE_VERSION="8.10.2"
GRADLE_SHA="31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26"
GRADLE_URL="https://services.gradle.org/distributions/gradle-8.10.2-bin.zip"

# Installation paths
INSTALL_DIR="/opt"
JAVA_HOME="${INSTALL_DIR}/jdk-${JDK_VERSION}"
GRADLE_HOME="${INSTALL_DIR}/gradle-${GRADLE_VERSION}"
TMP_DIR="/tmp/java-install-$(date +%s)"

# Detect OS type
detect_os() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS_TYPE=$ID
        
        # Handle direct matches first
        case $ID in
            debian|ubuntu|linuxmint|pop|elementary|zorin|kali|parrot|deepin|mxlinux|devuan|neon)
                OS_FAMILY="debian"
                return
                ;;
            rhel|centos|fedora|almalinux|rocky|ol)  # ol is Oracle Linux
                OS_FAMILY="rhel"
                return
                ;;
        esac

        # Check ID_LIKE if no direct match
        if [ -n "$ID_LIKE" ]; then
            case $ID_LIKE in
                *debian*)
                    OS_FAMILY="debian"
                    return
                    ;;
                *rhel*|*fedora*)
                    OS_FAMILY="rhel"
                    return
                    ;;
            esac
        fi
        
        echo "Unsupported Linux distribution: $ID"
        echo "ID_LIKE: $ID_LIKE"
        exit 1
    else
        echo "Cannot detect OS type: /etc/os-release file not found"
        exit 1
    fi
}

# Install package using the appropriate package manager
install_package() {
    local package=$1
    echo "Installing $package..."
    case $OS_FAMILY in
        debian)
            apt-get update && apt-get install -y "$package"
            ;;
        rhel)
            dnf install -y "$package"
            ;;
        *)
            echo "Unsupported OS family: $OS_FAMILY"
            exit 1
            ;;
    esac
}

# Check prerequisites
check_commands() {
    local packages_to_install=()
    
    for cmd in curl unzip tar; do
        if ! command -v $cmd &> /dev/null; then
            case $cmd in
                curl)
                    packages_to_install+=("curl")
                    ;;
                unzip)
                    packages_to_install+=("unzip")
                    ;;
                tar)
                    packages_to_install+=("tar")
                    ;;
            esac
        fi
    done

    if [ ${#packages_to_install[@]} -ne 0 ]; then
        echo "Installing required packages: ${packages_to_install[*]}"
        for package in "${packages_to_install[@]}"; do
            install_package "$package"
        done
    fi
}

# Clean previous installations
clean_install() {
    echo "Removing previous installations..."
    rm -rf "${JAVA_HOME}" "${GRADLE_HOME}" "${TMP_DIR}"
    rm -f /usr/bin/java /usr/bin/javac /usr/bin/gradle
    rm -f /etc/alternatives/java /etc/alternatives/javac /etc/alternatives/gradle
}

# Download with checksum verification
download_verify() {
    local url=$1
    local sha=$2
    local dest=$3
    
    echo "Downloading ${url}..."
    if ! curl -L --progress-bar "${url}" -o "${dest}"; then
        echo "Download failed for ${url}"
        exit 1
    fi
    
    echo "Verifying checksum..."
    if ! echo "${sha}  ${dest}" | sha256sum -c -; then
        echo "Checksum verification failed for ${dest}"
        exit 1
    fi
}

# Setup environment for different init systems
setup_environment() {
    local env_file
    case $OS_FAMILY in
        debian)
            env_file="/etc/profile.d/java-env.sh"
            ;;
        rhel)
            env_file="/etc/profile.d/java-env.sh"
            # Additional RHEL-specific environment setup if needed
            ;;
    esac

    echo "Configuring environment in $env_file..."
    cat > "$env_file" << EOF
export JAVA_HOME="${JAVA_HOME}"
export GRADLE_HOME="${GRADLE_HOME}"
export PATH="\${PATH}:\${JAVA_HOME}/bin:\${GRADLE_HOME}/bin"
EOF

    chmod 644 "$env_file"
}

main() {
    # Check root privileges
    if [ "$(id -u)" -ne 0 ]; then
        echo "Please run with sudo"
        exit 1
    fi

    detect_os
    check_commands
    clean_install
    mkdir -p "${TMP_DIR}"

    # Install JDK 23
    JDK_TAR="${TMP_DIR}/jdk.tar.gz"
    download_verify "${JDK_URL}" "${JDK_SHA}" "${JDK_TAR}"
    echo "Installing JDK to ${JAVA_HOME}..."
    
    EXTRACT_TMP="${TMP_DIR}/jdk-extract"
    mkdir -p "${EXTRACT_TMP}"
    tar xzf "${JDK_TAR}" -C "${EXTRACT_TMP}" --strip-components=1
    mv "${EXTRACT_TMP}" "${JAVA_HOME}"

    # Install Gradle
    GRADLE_ZIP="${TMP_DIR}/gradle.zip"
    download_verify "${GRADLE_URL}" "${GRADLE_SHA}" "${GRADLE_ZIP}"
    echo "Installing Gradle to ${GRADLE_HOME}..."
    
    EXTRACT_TMP="${TMP_DIR}/gradle-extract"
    mkdir -p "${EXTRACT_TMP}"
    unzip -q "${GRADLE_ZIP}" -d "${EXTRACT_TMP}"
    mv "${EXTRACT_TMP}/gradle-${GRADLE_VERSION}" "${GRADLE_HOME}"

    # Configure system alternatives
    echo "Configuring system alternatives..."
    for cmd in java javac; do
        if [ -f "${JAVA_HOME}/bin/${cmd}" ]; then
            update-alternatives --install "/usr/bin/${cmd}" "${cmd}" "${JAVA_HOME}/bin/${cmd}" 2000
            update-alternatives --set "${cmd}" "${JAVA_HOME}/bin/${cmd}"
        fi
    done

    if [ -f "${GRADLE_HOME}/bin/gradle" ]; then
        update-alternatives --install "/usr/bin/gradle" "gradle" "${GRADLE_HOME}/bin/gradle" 2000
        update-alternatives --set "gradle" "${GRADLE_HOME}/bin/gradle"
    fi

    # Setup environment
    setup_environment

    # Cleanup
    rm -rf "${TMP_DIR}"

    # Verification
    echo -e "\n\e[32mInstallation complete!\e[0m"
    echo -e "\nJava version:"
    "${JAVA_HOME}/bin/java" -version
    echo -e "\nJavac version:"
    "${JAVA_HOME}/bin/javac" -version
    echo -e "\nGradle version:"
    "${GRADLE_HOME}/bin/gradle" --version
    echo -e "\nEnvironment configured in /etc/profile.d/java-env.sh"
    echo -e "Please log out and log back in, or run:\n  source /etc/profile.d/java-env.sh"
}

main "$@"