Cómo iniciar un programa JAVA según la configuración del usuario
La reimpresión de dos artículos puede realizar el inicio automático de combinaciones de programas Java
Puede haber otros buenos métodos, este es solo uno de ellos
La idea es El programa Java se empaqueta en un archivo .jar y luego se convierte en un .exe. Se agrega al elemento de eliminación de inicio modificando el registro, es decir, agregando el archivo ejecutable .exe instalado al registro. Agregue el archivo ejecutable .exe al registro;
Primero, empaquete la aplicación java en un archivo .jar. Puede usar el siguiente código para encontrar la ruta absoluta del archivo .jar. También puede encontrar el archivo ejecutable .exe instalado
Reimprimir:
Para programas Java, ya sean archivos JAR o WAR empaquetados o sin empaquetar, a veces necesita obtener el directorio donde se están ejecutando. Información del directorio, ¿cómo hacer esto?
En el sistema de archivos procesado por Java, hay dos formas de representar el directorio:
(1) Directorio absoluto, representado por el carácter inicial "/", que significa comenzar desde el directorio raíz para comenzar a buscar el directorio dado, por ejemplo, /c:/java//p>
(2) Ruta relativa, representada por el nombre del directorio sin "/", significa buscar el directorio dado en la ubicación actual. Si el nombre del directorio no contiene "/", significa que el directorio donde se está ejecutando el programa Java actual se utiliza como directorio de inicio para encontrar el directorio dado. Por ejemplo, java/clases. En las rutas relativas, hay algunos caracteres específicos que pueden representar directorios especiales, por ejemplo, "." representa el directorio actual, "." representa el directorio actual y "..." representa el directorio encima del directorio actual. En muchos ejemplos que aparecen en la web, "." se utiliza como el nombre del directorio a partir del cual se crean los objetos Archivo. Como nombre del directorio, construya una instancia del objeto Archivo y luego use los métodos del objeto Archivo para obtener el directorio en el que se está ejecutando el programa actual.
Aunque este método es simple, a veces no puede deducir correctamente el directorio en el que se está ejecutando el programa actual. La razón es que para ejecutar un programa Java, no es necesario ir al directorio donde se encuentra el archivo de clase o el archivo JAR del programa. Siempre que especifique la información de ruta de clase correcta en el tiempo de ejecución, puede ejecutar el programa Java. en cualquier directorio En este momento, solo necesita Puede utilizar este método para obtener información sobre el directorio en el que se emitió el comando de ejecución.
Del análisis anterior, se puede ver que para muchos programas Java, especialmente programas WEB, el uso de "." en la ruta actual para representar la ruta actual no puede cumplir con los requisitos. Entonces, ¿cómo obtener la información correcta del directorio de tiempo de ejecución?
En un programa web, puede utilizar la API de Servlet para obtener información de ruta, como el método getRealPath definido en la interfaz HttpServletRequest. Sin embargo, estos métodos similares dependen del entorno de Servlet y no son convenientes. pruebas unitarias del programa.
En este artículo, proporcionaremos una forma de detectar rutas utilizando solo la API estándar de Java (es decir, aprovechando la clase abstracta ClassLoader).
Usando el método getClassLoader de java.lang.Class, puede obtener la instancia de ClassLoader de una clase determinada, y su método getResource puede obtener la ubicación del recurso en el cargador de clases actual. nombre del archivo de clase como el recurso luego se procesa para obtener información sobre la ubicación actual del programa Java. Podemos usar el nombre del archivo de clase como recurso para buscar.
El pseudocódigo es el siguiente:
Obtener el nombre de clase del parámetro de clase
Obtener el nombre del paquete de la clase
Convertir el nombre del paquete en una ruta
Usar getResource Obtiene la URL del archivo de clase actual
Usa la URL para resolver la ruta del programa Java actual
Usa la URL para resolver la ruta de el programa Java actual.
El código específico es el siguiente:
Código Java:
Código Java
/**------- --- ----------------------------------------------- --- -----------
*getAppPath recibe los parámetros de atributo de clase de la clase Java utilizada por el programa actual y devuelve el paquete
* El sistema donde se encuentra el archivo ejecutable de Java El nombre del directorio del sistema donde se encuentra el nombre del directorio (jar, war) o el nombre del directorio donde se encuentra el programa Java desempaquetado
*@param cls es el tipo de clase
*@return El valor de retorno es el valor de ejecutar el directorio donde se encuentra el programa Java de la clase
-------------- -------------------------- ------------------------ -*/
public static String getAppPath (Class cls){
// Comprobar si los parámetros pasados por el usuario está vacío
if(cls==null)
throw new java.lang IllegalArgumentException("¡El parámetro no puede ser nulo!")
Paquete pack=cls.getPackage();
String path=""
// Si no es un paquete anónimo, convierte el nombre del paquete en una ruta
if(pack!=null){
String packName=pack .getName();
//Esto simplemente determina si es una biblioteca base de Java, evitando que el usuario la pase. las bibliotecas integradas del JDK
if(packName.startsWith("java.")||packName.startsWith( "javax."))
throw new java.lang.IllegalArgumentException ("¡No transmitas la clase del sistema! ");
// En el nombre de la clase, elimina la parte del nombre del paquete para obtener el nombre del archivo de la clase
clsName=clsName.substring(packName.length()+1 )
Determine si el nombre del paquete es un nombre de paquete simple. Si es así, convierta directamente el nombre del paquete en una ruta,
if(packName.indexOf(".") <0) path=packName+"/"
else{/de lo contrario, convierta el nombre del paquete en ruta según los componentes del nombre del paquete
int inicio=0,end=0
end=packName.indexOf(".")
while(end!=-1){
ruta=ruta+nombredelpaquete.subcadena(inicio,fin)+"
/";
start=end+1;
end=packName.indexOf("."
java.net.URL url =loader.getResource( path+clsName);
//Obtener la información de la ruta del objeto URL
String realPath=url.getPath()
//Eliminar la ruta información en el nombre del protocolo "archivo:".
int pos=realPath.indexOf("archivo:"
if(pos>-1) realPath=realPath.substring( pos+5);
// Elimina la última parte de la ruta que contiene la información del archivo de clase y obtiene la ruta donde se encuentra la clase
// Elimina la última parte de la ruta que contiene la información del archivo de clase
pos=realPath.indexOf(path+clsName
realPath=realPath.substring(0,pos-1); >
//Si el archivo de clase está empaquetado en un archivo JAR, etc., elimine el JAR correspondiente, etc.
if(realPath.endsWith("!"))
realPath=realPath.substring(0, realPath.realPath=realPath.substring(0,realPath.lastIndexOf("/"));
/*------------- -------- ------------------------------------ ---
Método getResource de ClassLoader Utilice utf-8 para codificar la información de la ruta. Cuando hay caracteres chinos y espacios en la ruta, convertirá estos caracteres, por lo que lo que obtenemos a menudo no es lo que queremos.
En este caso, la ruta real En este caso, debe llamar al método de decodificación de URLDecoder para decodificar la ruta
Utilice el método de decodificación para obtener el
chino y el espacio originales. ruta.
----- ------------------------------------ -------------- ------*/
prueba{
realPath =java.net.URLDecoder.decode(realPath, "utf-8");
}catch(Exception e){throw new RuntimeException(e);}
Devuelve realPath.
Devuelve realPath;
}//Fin de la definición de getAppPath
//----------------- -----------------------------------------------
Este método se puede utilizar con archivos JAR o WAR, así como con archivos que no sean JAR.
Pero preste atención a los dos puntos siguientes:
No pase clases del sistema como parámetros de getAppPath, como java.lang.String.class. Por supuesto, no pase clases que ya existen en el JDK. , como los relacionados con xml. Algunas clases, etc.
Lo que se debe pasar debe ser la clase principal en ejecución en el programa. No pase los archivos de clase en la biblioteca de soporte del programa (es decir, esas bibliotecas de terceros), de lo contrario obtendrá la ubicación de. estas bibliotecas.
Luego, puede agregar elementos de inicio modificando el registro:
Reimprimir:
Elementos del registro a modificar
[HKEY_LOCAL_MACHINE/ Software/Microsoft/Windows/CurrentVersion/Run] Ejecuta programas automáticamente al iniciar
[HKEY_LOCAL_MACHINE/Software/Microsoft/Windows/CurrentVersion/RunOnce]. Ejecuta programas automáticamente al inicio y solo una vez
[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices] (p>
Se proporciona JDK para Windows desde la versión 1.4 Una API para preferencias La API de 4 también es multiplataforma, pero su función es ligeramente más débil y solo se puede usar en Win32. Solo se puede usar para operar HKCU\Software\ en Win32 Data bajo JavaSoft y HKLM\Software. \JavaSoft y sus subnodos.
No se puede acceder libremente a los valores de otras claves en el registro utilizando únicamente Java. La solución inevitable es JNI. Aquí utilicé la API del Registro de Windows. .3.zip (contiene código fuente) en Interfaz nativa /java/jnireg/index.shtml Puede usarlo para acceder, modificar y exportar claves de registro a un archivo zip, puede ver dos archivos ICE_JNIRegistry.dll y registro.jar. en el directorio bin. La biblioteca dinámica es la implementación del código local.
com.ice.jni.registry.Registry.main() es el código de muestra para la tabla, la biblioteca dinámica ICE_JNIRegistry. .dll, también se carga en el bloque estático de la clase, así que recuerde colocar ICE_JNIRegistry.dll en una ubicación donde pueda cargarse, por ejemplo, si descomprime el registro-3.1.3.zip en c:\registry. -3.1.3, luego puedes ir a ese directorio desde la línea de comando y ejecutarlo.
Código:
Código Java
paquete org.zh.ss.util;
importar com.ice.jni.registry. *;
importar java.text.SimpleDateFormat;
/** */**
* registro de operaciones de java
* @ autor Li Zhiyuan
*/
clase pública RegeditTool {
static SimpleDateFormat shortDateFormat = new SimpleDateFormat("aaaa-MM-dd"
);/** *//** */
/** *//** Crear una nueva instancia de prueba*/
// En el registro Información de almacenamiento Cadena subKeyValue) {
prueba {
software RegistryKey = Registry.HKEY_LOCAL_MACHINE
.openSubKey(carpeta
subclave RegistryKey = software). createSubKey(subKeyNode, "");
subKey
.setValue(new RegStringValue(subKey, subKeyName,
subKeyValue)); > subKey.closeKey();
.openSubKey(carpeta)closeKey();
devuelve verdadero
} catch ( NoSuchKeyException e) {
e.printStackTrace();
} captura (NoSuchValueException e) {
e.printStackTrace()
} captura (RegistroException e) {
e.printStackTrace();
}
Devuelve falso.
Devuelve falso;
}
// Elimina la variable debajo del nodo en el registro
public static boolean deleteValue(String carpeta , String subKeyNode,
String subKeyName) {
prueba {
software RegistryKey = Registry.HKEY_LOCAL_MACHINE
.openSubKey(carpeta);
SubClave de Registro = software.createSubKey(subKeyNode, "");
subKey.deleteValue(subKeyNode,"").
eliminarValue(subKeyName);
subKey.closeKey();
devuelve verdadero
} catch (NoSuchKeyException e) {
Sistema .out.println("NOsuchKey_delete");
} catch (NoSuchValueException e) {
System.out.
return false
}
// Eliminar un nodo debajo de un nodo en el registro
public static boolean deleteSubKey(String carpeta, String subKeyNode) {
try {
Software RegistryKey = Registry.HKEY_LOCAL_MACHINE
.openSubKey(carpeta);
software.deleteSubKey(subKeyNode);
software.closeKey (