GNU/Linux >> Tutoriales Linux >  >> Linux

Cómo administrar varias versiones de Java con jEnv en Linux

Como desarrollador de Java, le gustaría probar su código con diferentes versiones de Java. O simplemente quería mantenerse al día con las características de una nueva versión de Java. La configuración de diferentes entornos Java a menudo puede ser una tarea desalentadora y que requiere mucho tiempo. ¡Aquí es donde los sistemas de gestión de versiones resultan útiles! Hoy hablaremos de uno de esos administradores de versiones llamado jEnv . jEnv es una herramienta de línea de comandos para administrar múltiples versiones de Java en Linux. Es como SDKMAN , pero solo para Java. jEnv es una bifurcación actualizada de jenv , que a su vez está adaptado de rbenv . jEnv es bastante útil para desarrollar aplicaciones Java que requieren una versión exacta de Java.

Usando jEnv, un desarrollador;

  • puede instalar y administrar varias instalaciones de Java en paralelo,
  • puede configurar la instalación de Java en un directorio global (específico de la aplicación) e incluso por nivel de shell (específico del shell),
  • puede cambiar entre diferentes versiones de Java fácil y rápidamente,
  • no es necesario configurar la variable de entorno JAVA_HOME para cada versión.

Instalar Java

Tenga en cuenta que jEnv no instalará Java para usted. Solo administrará las instalaciones de Java existentes. Debe instalar Java usando su administrador de paquetes o cualquier otra forma de su elección. Voy a instalar openjdk 13 y 14 en mi sistema Ubuntu:

$ sudo apt install openjdk-13-jdk
$ sudo apt install openjdk-14-jdk

Si ya ha instalado Java, simplemente ignore este paso.

Instalar jEnv en Linux

Git clona el repositorio jEnv usando el comando:

$ git clone https://github.com/jenv/jenv.git ~/.jenv

El comando anterior clonará el contenido de jEnv en un directorio local llamado .jenv .

Luego, agregue jEnv a su $PATH:

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.bash_profile

A continuación, inicialice jEnv:

$ echo 'eval "$(jenv init -)"' >> ~/.bash_profile

Finalmente, actualice los cambios que acabamos de hacer en ~/.bash_profile usando el comando.

$ source ~/.bash_profile

Si no funciona por algún motivo, simplemente use ~/.bashrc en lugar de ~/.bash_profile.

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.bashrc
$ echo 'eval "$(jenv init -)"' >> ~/.bashrc
$ source ~/.bashrc

Si estás en Zsh shell, los comandos para instalar jEnv son:

$ echo 'export PATH="$HOME/.jenv/bin:$PATH"' >> ~/.zshrc
$ echo 'eval "$(jenv init -)"' >> ~/.zshrc

Verificar la instalación de jEnv

Verifiquemos si jEnv está instalado con el comando:

$ jenv doctor

Salida de muestra:

[OK]	No JAVA_HOME set
[ERROR]	Java binary in path is not in the jenv shims.
[ERROR]	Please check your path, or try using /path/to/java/home is not a valid path to java installation.
	PATH : /home/ostechnix/.jenv/libexec:/home/ostechnix/.jenv/shims:/home/ostechnix/.jenv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
[OK]	Jenv is correctly loaded

Como puede ver, el resultado dice que la variable JAVA_HOME aún no está configurada y que jenv está cargado correctamente. No te preocupes por los otros errores. Desaparecerán después de que agreguemos Java en la siguiente sección.

Ahora configuremos la variable de entorno JAVA_HOME usando el comando:

$ jenv enable-plugin export

Debe reiniciar su sesión de shell actual para activar el complemento de exportación de eco de jenv activado. Para reiniciar la sesión de shell, ejecute:

$ exec $SHELL -l

¡Ahora, ejecute de nuevo el comando "jenv doctor" y vea lo que devuelve!

$ jenv doctor

Salida de muestra:

[OK]	JAVA_HOME variable probably set by jenv PROMPT
[ERROR]	Java binary in path is not in the jenv shims.
[ERROR]	Please check your path, or try using /path/to/java/home is not a valid path to java installation.
	PATH : /home/ostechnix/.jenv/libexec:/home/ostechnix/.jenv/shims:/home/ostechnix/.jenv/bin:/home/ostechnix/.jenv/shims:/home/ostechnix/.jenv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
[OK]	Jenv is correctly loaded

¡Hecho! jEnv establecerá automáticamente la variable JAVA_HOME según el entorno Java actualmente activo.

Administre varias versiones de Java con jEnv en Linux

Ejecutar jEnv sin ninguna opción mostrará la sección de ayuda:

$ jenv

Salida de muestra:

jenv 0.5.3-2-g78dbd7f
Usage: jenv <command> [<args>]

Some useful jenv commands are:
   commands    List all available jenv commands
   local       Set or show the local application-specific Java version
   global      Set or show the global Java version
   shell       Set or show the shell-specific Java version
   rehash      Rehash jenv shims (run this after installing executables)
   version     Show the current Java version and its origin
   versions    List all Java versions available to jenv
   which       Display the full path to an executable
   whence      List all Java versions that contain the given executable
   add         Add JDK into jenv. A alias name will be generated by parsing "java -version"

See `jenv help <command>' for information on a specific command.
For full documentation, see: https://github.com/jenv/jenv/blob/master/README.md

Añadir diferentes entornos Java

Ahora tenemos que decirle a jenv dónde se encuentran nuestros entornos Java.

Primero, agreguemos el entorno openjdk-13 usando el comando:

$ jenv add /usr/lib/jvm/java-13-openjdk-amd64/

Salida de muestra:

openjdk64-13.0.3 added
13.0.3 added
13.0 added
13 added

Luego, agregue openjdk-14 usando el comando:

$ jenv add /usr/lib/jvm/java-14-openjdk-amd64/
openjdk64-14.0.1 added
14.0.1 added
14.0 added
14 added

Ahora verifique todas las versiones de Java disponibles para jenv usando el comando:

$ jenv versions

Salida de muestra:

* system (set by /home/ostechnix/.jenv/version)
  13
  13.0
  13.0.3
  14
  14.0
  14.0.1
  openjdk64-13.0.3
  openjdk64-14.0.1

Como puede ver en el resultado anterior, actualmente se están administrando dos entornos Java, es decir, openjdk 13 y openjdk 14. No importa los otros números en la salida. Son solo alias que se refieren a la misma versión.

Establecer entorno Java global

Como ya dije, jenv puede permitirle configurar la instalación de Java en global o por directorio/proyecto, o por shell y cambiar entre ellos sin cambiar la versión global.

Veamos la versión actual de Java:

$ java --version
openjdk 14.0.1 2020-04-14
OpenJDK Runtime Environment (build 14.0.1+7-Ubuntu-1ubuntu1)
OpenJDK 64-Bit Server VM (build 14.0.1+7-Ubuntu-1ubuntu1, mixed mode, sharing)

Como puede ver en el resultado, la versión global actual se ha establecido en openjdk-14.

Para configurar openjdk-13 como versión global, ejecute:

$ jenv global openjdk64-13.0.3

Ahora comprueba la versión de Java:

$ java --version
openjdk 13.0.3 2020-04-14
OpenJDK Runtime Environment (build 13.0.3+3-Ubuntu-1ubuntu2)
OpenJDK 64-Bit Server VM (build 13.0.3+3-Ubuntu-1ubuntu2, mixed mode)

También puede usar los números de alias en lugar de la versión completa como se muestra a continuación:

$ jenv global 13
$ jenv global 13.0
$ jenv global 13.0.3

Todos estos tres comandos establecerán openjdk-13 como versión global.

Establecer entorno Java local o por directorio

A veces, es posible que desee configurar el entorno Java para un proyecto específico, sin cambiar la versión global.

Por ejemplo, los siguientes pasos establecerán openjdk-14 como versión local para nuestro proyecto llamado "ostechnix-java", pero no cambiarán la versión global.

$ mkdir ostechnix-java
$ cd ostechnix-java
$ jenv local openjdk64-14.0.1

Ahora nuestro entorno local es openjdk-14, pero el entorno java global es openjdk-13. Del mismo modo, puede configurar varios entornos Java diferentes para cada aplicación. Simplemente vaya al directorio del proyecto y configure el entorno Java deseado de su elección y comience a construir o probar la aplicación. ¡Es así de simple!

Establecer entorno Java específico de shell

Para configurar el entorno Java para la sesión de shell actual, ejecute:

$ jenv shell openjdk64-14.0.1

Openjdk-14 es la versión de Java utilizada en este shell en particular. Una vez que salga de la sesión de shell actual, la versión anterior de Java utilizada globalmente entrará en vigencia.

¡No es necesario configurar $JAVA_HOME!

¿Se dio cuenta de que nunca establecí la variable $JAVA_HOME al cambiar a diferentes versiones de Java? ¡No, ni siquiera una vez! Jenv se encargará de ello y lo configurará automáticamente según el entorno Java en el que se encuentre.

Puede ver la configuración actual de la variable JAVA_HOME usando el comando:

$ echo $JAVA_HOME
/home/ostechnix/.jenv/versions/openjdk64-13.0.3

Simplemente olvide cómo configurar la variable de entorno JAVA_HOME y concéntrese en su desarrollo.

Lectura relacionada:

  • Pyenv:gestión de versiones de Python simplificada

Linux
  1. Cómo administrar los servicios de Systemd con Systemctl en Linux

  2. Cómo administrar versiones de NodeJS con n en Ubuntu 20.04

  3. Cómo administrar múltiples versiones de Python con Pyenv en Linux

  4. Cómo instalar y administrar versiones de Java en Rocky Linux 8

  5. ¿Cómo ejecutar varias versiones de PHP con Nginx en Ubuntu?

Cómo administrar el almacenamiento en Linux con LVM

Cómo administrar sus contraseñas con Enpass en Linux

Cómo administrar versiones de Nodejs con n en Linux

Cómo instalar varias versiones de Java en CentOS 8

Cómo administrar de forma remota un servidor Linux con SSH

Cómo administrar el almacenamiento con GParted Linux