¿Cómo ejecutar el progtwig JAVA haciendo doble clic en el ícono?

He escrito un progtwig de Java. Ahora me gustaría abrir mi aplicación java de consola sin IDE, Eclipse, etc., solo haciendo doble clic en la versión ejecutable de mi Escritorio.

He exportado el proyecto de Java en el archivo Runnable .JAR, pero no se puede abrir. Cuando intenté abrir la aplicación con cmd. java -jar ApplicatonName.jar y todo está bien. Pero este proceso es demasiado complicado y no es fácil de usar.

Entonces, ¿hay alguna forma posible de hacer tal cosa con JAVA?

Gracias por adelantado 🙂

Cree un archivo bat o sh , según el sistema operativo, y ponga java -jar ApplicationName.jar en ese archivo.

Puede hacer doble clic en ese archivo para iniciar su aplicación.

Ejemplo para Windows:

Crea un archivo MyProgram.bat . Abra el archivo en un editor de texto. Agregue java -jar MyApplicationName.jar (reemplace MyApplicationName por el nombre de su aplicación / el nombre del jar). Guarda el archivo. Haga doble clic en el archivo creado para abrir su progtwig.

Tuve el mismo problema esta mañana, busqué un poco y creo una clase estática a partir del conocimiento disponible. Resuelve el problema para Windows, pero los usuarios de otros sistemas deberían ser capaces de agregar fácilmente lo que es necesario, simplemente no sabía el comando correcto del sistema (si lo hay). Dejé el método printEnvironmentInfo () para obtener ayuda.

Que hace:

Permite hacer doble clic en el inicio para aplicaciones de consola Java estándar sin alterar el sistema operativo ni crear archivos. El procedimiento es este:

  1. Simplemente regresa en caso de que esté en el IDE.

  2. Simplemente regresa en caso de que tengas una consola.

  3. Inicia el archivo .jar que se está ejecutando actualmente en una consola nueva y se EXIT.

Cómo utilizar:

  1. Crear una aplicación de consola Java.

  2. Cree el archivo de clase AutoRunFromConsole y pegue el siguiente código debajo de la statement del paquete, reemplazando todo.

  3. Como (uno de) los primeros enunciados en su método principal, realice AutoRunFromConsole.runYourselfInConsole (true); (o falso si desea que la consola se cierre cuando finalice su aplicación).

Cómo funciona:

El nombre de archivo .jar de la aplicación Java en ejecución se determina y se comprueba si ese archivo existe realmente en el directorio actual y si en realidad es un archivo.

Si esto no funciona, debemos estar en el IDE y, por lo tanto, tener una consola. Esto debería ser confiable, pero hay un enfoque alternativo: una llamada diferente al método (sobrecargado) le permite entregar los argumentos de línea de comando de su método principal. Si el primer argumento es “ide” (caso se ignora), el método simplemente retorna. Cuando se utiliza esta otra llamada, si no se pudo determinar el nombre del ejecutable (para lo cual se puede dar un retorno), se muestra un mensaje (ver a continuación).

Comprueba si System.console () devuelve nulo. Si no, solo regresa.

Determina una cadena de línea de comando basada en el sistema operativo (TAN SOLO PARA WINDOWS, pero solo necesita completar los espacios en blanco) y luego la ejecuta con Runtime.getRuntime (). Exec () ;. En caso de que aún no se admita el sistema operativo, se muestra una ventana de mensaje que indica que el progtwig debe ejecutarse desde la consola, incl. la syntax

En caso de que tenga mejoras (especialmente las cadenas de línea de comando que funcionan para otros sistemas), hágamelo saber.

 import javax.swing.*; import java.io.File; import java.io.IOException; import java.security.CodeSource; import java.util.Map; import java.util.Properties; /** * Created by Reddit user king_of_the_universe / StackOverflow user Dreamspace President / dreamspace-president.com * 

* v[(2), 2015-11-13 13:00 UTC] *

* One static method call will start a new instance of *THIS* application in the console and will EXIT the current * instance. SO FAR ONLY WORKS ON WINDOWS! Users of other systems need to assist here. The methods are all in place. */ final public class AutoRunFromConsole { final private static String FAILMESSAGE_TITLE = "Please run in console."; final private static String FAILMESSAGE_BODY = "This application must be run in the console (or \"command box\").\n\nIn there, you have to type:\n\njava -jar nameofprogram.jar"; private static void showFailMessageAndExit() { JOptionPane.showMessageDialog(null, FAILMESSAGE_BODY, FAILMESSAGE_TITLE, JOptionPane.INFORMATION_MESSAGE); System.exit(0); } private enum OSType { UNDETERMINED, WINDOWS, LINUX, MACOS } private static OSType getOsType() { // final String osName = System.getProperty("os.name"); // final String osVersion = System.getProperty("os.version"); // final String osArchitecture = System.getProperty("os.arch"); // System.out.println("\n\nOSNAME: " + osName); // System.out.println("\n\nOSVERSION: " + osVersion); // System.out.println("\n\nOSARCHITECTURE: " + osArchitecture); final String osName = System.getProperty("os.name", "").toLowerCase(); if (osName.startsWith("windows")) { return OSType.WINDOWS; } else if (osName.startsWith("linux")) { return OSType.LINUX; } else if (osName.startsWith("mac os") || osName.startsWith("macos") || osName.startsWith("darwin")) { return OSType.MACOS; } return OSType.UNDETERMINED; } /** * Checks if the program is currently running in console, and if not, starts the program from console and EXITS this * instance of the program. Should be (one of) the first calls in your program. *

* This is the less safe variant of the method: To check if you're currently in the IDE, it just tries to find the * executable name and if it exists in the current path. This should word perfectly at all times in IntelliJ - I * don't know what values getExecutableName() returns inside Eclipse, but I suspect it will work just as well. *

* It's also less safe because you can't give a fallback executable name, but I believe it should do the trick in * all situations. *

* If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. SEE startExecutableInConsole(); */ public static void runYourselfInConsole(final boolean stayOpenAfterEnd) { runYourselfInConsole(false, stayOpenAfterEnd, null, null); } /** * Checks if the program is currently running in console, and if not, starts the program from console and EXITS this * instance of the program. Should be (one of) the first calls in your program. *

* This is the safer variant of the method: The first command line argument GIVEN BY THE IDE'S RUN CONFIGURATION * should be "ide" (Case is ignored.), which this method will use to determine if it's running from the IDE. *

* It is also safer because you can give a fallback executable name in case getExecutableName() could not determine * it. *

* Ultimately, it is safer because if the executable could not be determined, it shows a message box telling the * user to start the program from the console. *

* You will probably never make use of this variant. It's meant to be a solution if all else seems to fail (eg * customer calls and you need a quick fix). *

* If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. SEE startExecutableInConsole(); * * @param psvmArguments The arguments given to the main method. * @param fallbackExecutableName Can be null. In case getExecutableName() can't determine the proper name, the * fallback is used. */ public static void runYourselfInConsole(final String[] psvmArguments, final String fallbackExecutableName, final boolean stayOpenAfterEnd) { runYourselfInConsole(true, stayOpenAfterEnd, psvmArguments, fallbackExecutableName); } /** * see the other two methods */ private static void runYourselfInConsole(final boolean useSaferApproach, final boolean stayOpenAfterEnd, final String[] psvmArguments, final String fallbackExecutableName) { String executableName = getExecutableName(fallbackExecutableName); if (useSaferApproach) { if (isRunFromIDE(psvmArguments)) { return; } } else { if (executableName == null) { // Running from IDE. return; } } if (isRunningInConsole()) { return; } if (executableName == null) { showFailMessageAndExit(); } startExecutableInConsole(executableName, stayOpenAfterEnd); System.exit(0); } /** * Opens a console window and starts the Java executable there. *

* If this is used on a system other than Windows, a message box is shown telling the user to start the program from * the console. BECAUSE I DON'T KNOW HOW TO OPEN A CONSOLE ON OTHER SYSTEMS. * * @param executableName the full file name of the executable (without path) * @param stayOpenAfterEnd If true (and if someone can figure out the necessary parameters for other systems than * Windows), the console will not close once the executable has terminated. This is useful * eg if you want to give some kind of bye bye message because you actually assumed that * people start the program from console manually. */ private static void startExecutableInConsole(final String executableName, final boolean stayOpenAfterEnd) { String launchString = null; switch (getOsType()) { case UNDETERMINED: break; case WINDOWS: if (stayOpenAfterEnd) { launchString = "cmd /c start cmd /k java -jar \"" + executableName+"\""; // No, using /k directly here DOES NOT do the trick. } else { launchString = "cmd /c start java -jar \"" + executableName+"\""; } break; case LINUX: break; case MACOS: // launchString="/usr/bin/open -a Terminal /path/to/the/executable"; break; } if (launchString == null) { showFailMessageAndExit(); } try { Runtime.getRuntime().exec(launchString); } catch (IOException e) { e.printStackTrace(); } } /** * @param args the args as given to PSVM * @return whether the first command line argument was "ide" (ignoring case). Don't forget to change your IDE's run * configuration accordingly. */ private static boolean isRunFromIDE(final String[] args) { return args != null && args.length > 0 && args[0].equalsIgnoreCase("ide"); } /** * @return if System.console() is available. DOES NOT WORK properly from IDE, will return false then even though it * should be true. Use isRunFromIDE or other means additionally. */ private static boolean isRunningInConsole() { return System.console() != null; } /** * @param fallbackExecutableName Can be null. In the very unlikely case this method can't determine the executable, * the fallback will also be checked. But if the fallback also doesn't exist AS A FILE * in the CURRENT path, null will be returned regardless, even if you're sure that * your fallback should be correct. * @return the name of the running jar file, OR NULL if it could not be determined (which should be a certainty * while in IDE, hence can be abused for determining that). */ public static String getExecutableName(final String fallbackExecutableName) { // APPROACH 1 - THE ONE EVERYBODY ON STACKOVERFLOW IS REPEATING String executableNameFromClass = null; final CodeSource codeSource = AutoRunFromConsole.class.getProtectionDomain().getCodeSource(); if (codeSource == null) { System.err.println("UNEXPECTED: Main.class.getProtectionDomain().getCodeSource() returned null"); } else { final String path = codeSource.getLocation().getPath(); if (path == null || path.isEmpty()) { System.err.println("UNEXPECTED: codeSource.getLocation().getPath() returned null or empty"); } else { executableNameFromClass = new File(path).getName(); } } // APPROACH 2 - QUERY SYSTEM PROPERTIES final Properties properties = System.getProperties(); final String executableNameFromJavaClassPathProperty = properties.getProperty("java.class.path"); final String executableNameFromSunJavaCommandProperty = properties.getProperty("sun.java.command"); // System.out.println("\n\nexecutableNameFromClass:\n" + executableNameFromClass); // System.out.println("\n\nexecutableNameFromJavaClassPathProperty:\n" + executableNameFromJavaClassPathProperty); // System.out.println("\n\nexecutableNameFromSunJavaCommandProperty:\n" + executableNameFromSunJavaCommandProperty); // System.out.println("\n\nfallbackExecutableName:\n" + fallbackExecutableName); if (isThisProbablyTheExecutable(executableNameFromClass)) { return executableNameFromClass; } if (isThisProbablyTheExecutable(executableNameFromJavaClassPathProperty)) { return executableNameFromJavaClassPathProperty; } if (isThisProbablyTheExecutable(executableNameFromSunJavaCommandProperty)) { return executableNameFromSunJavaCommandProperty; } if (isThisProbablyTheExecutable(fallbackExecutableName)) { return fallbackExecutableName; } return null; } /** * @param candidateName suspected name of the running java executable * @return if name is not null, ends with ".jar" (Case is ignored.), and points to a FILE existing in the CURRENT * directory. */ private static boolean isThisProbablyTheExecutable(final String candidateName) { if (candidateName == null || !candidateName.toLowerCase().endsWith(".jar")) { return false; } final File file = new File(candidateName); return file.exists() && file.isFile(); } public static void main(final String[] args) { AutoRunFromConsole.runYourselfInConsole(true); printEnvironmentInfo(); } /** * for debugging purposes */ public static void printEnvironmentInfo() { System.out.println("\n\n\n\n-------------------------- System.getProperties() --------------------------"); final Properties properties = System.getProperties(); for (final Map.Entry entry : properties.entrySet()) { System.out.println(entry); } System.out.println("\n\n\n\n----------------------------- System.getenv() ------------------------------"); final Map env = System.getenv(); for (final Map.Entry entry : env.entrySet()) { System.out.println(entry); } System.out.print("\n\n\n\n"); } }