Créer de la croix-plate-forme Java SWT Application

J'ai un travail de mise en œuvre qui est maintenant référencé à partir de la SWT FAQ.

Cette approche est maintenant disponible pour l'utiliser comme une tâche ANT: SWTJar

[MODIFIER] SWTJar a maintenant été mis à jour pour utiliser Alexey Romanov solution comme décrit ci-dessus.

build.xml

J'ai d'abord construire un bocal contenant l'ensemble de mes classes de l'application.

<!-- UI (Stage 1) -->   
<jarjar jarfile="./build/tmp/intrace-ui-wrapper.jar">
  <fileset dir="./build/classes" includes="**/shared/*.class" />
  <fileset dir="./build/classes" includes="**/client/gui/**/*.class" />
  <zipfileset excludes="META-INF/*.MF" src="lib/miglayout-3.7.3.1-swt.jar"/>
</jarjar>

Ensuite, je construis un pot pour contenir tous les éléments suivants:

• Pots
  • Le pot qui je viens de construire
  • Tous les SWT pots
• Classes
  • Le "Pot-En-Pot" chargeur de classe classes
  • Spécial du chargeur de classe - voir ci-dessous

Voici le fragment de build.xml.

<!-- UI (Stage 2) -->
<jarjar jarfile="./build/jars/intrace-ui.jar">
  <manifest>
    <attribute name="Main-Class" value="org.intrace.client.loader.TraceClientLoader" />
    <attribute name="Class-Path" value="." />
  </manifest>
  <fileset dir="./build/classes" includes="**/client/loader/*.class" />
  <fileset dir="./build/tmp" includes="intrace-ui-wrapper.jar" />
  <fileset dir="./lib" includes="swt-*.jar" />
  <zipfileset excludes="META-INF/*.MF" src="lib/jar-in-jar-loader.jar"/>
</jarjar>

TraceClientLoader.java

Cette classe loader utilise le pot-en-pot-chargeur pour créer un chargeur de classe qui charge les classes de deux pots.

• Le bon SWT pot
• L'application wrapper pot

Une fois que nous avons ce chargeur de classe, nous pouvons lancer l'application principale méthode à l'aide de la réflexion.

public class TraceClientLoader
{
public static void main(String[] args) throws Throwable
{    
ClassLoader cl = getSWTClassloader();
Thread.currentThread().setContextClassLoader(cl);    
try
{
try
{
System.err.println("Launching InTrace UI ...");
Class<?> c = Class.forName("org.intrace.client.gui.TraceClient", true, cl);
Method main = c.getMethod("main", new Class[]{args.getClass()});
main.invoke((Object)null, new Object[]{args});
}
catch (InvocationTargetException ex)
{
if (ex.getCause() instanceof UnsatisfiedLinkError)
{
System.err.println("Launch failed: (UnsatisfiedLinkError)");
String arch = getArch();
if ("32".equals(arch))
{
System.err.println("Try adding '-d64' to your command line arguments");
}
else if ("64".equals(arch))
{
System.err.println("Try adding '-d32' to your command line arguments");
}
}
else
{
throw ex;
}
}
}
catch (ClassNotFoundException ex)
{
System.err.println("Launch failed: Failed to find main class - org.intrace.client.gui.TraceClient");
}
catch (NoSuchMethodException ex)
{
System.err.println("Launch failed: Failed to find main method");
}
catch (InvocationTargetException ex)
{
Throwable th = ex.getCause();
if ((th.getMessage() != null) &&
th.getMessage().toLowerCase().contains("invalid thread access"))
{
System.err.println("Launch failed: (SWTException: Invalid thread access)");
System.err.println("Try adding '-XstartOnFirstThread' to your command line arguments");
}
else
{
throw th;
}
}
}
private static ClassLoader getSWTClassloader()
{
ClassLoader parent = TraceClientLoader.class.getClassLoader();    
URL.setURLStreamHandlerFactory(new RsrcURLStreamHandlerFactory(parent));
String swtFileName = getSwtJarName();      
try
{
URL intraceFileUrl = new URL("rsrc:intrace-ui-wrapper.jar");
URL swtFileUrl = new URL("rsrc:" + swtFileName);
System.err.println("Using SWT Jar: " + swtFileName);
ClassLoader cl = new URLClassLoader(new URL[] {intraceFileUrl, swtFileUrl}, parent);
try
{
//Check we can now load the SWT class
Class.forName("org.eclipse.swt.widgets.Layout", true, cl);
}
catch (ClassNotFoundException exx)
{
System.err.println("Launch failed: Failed to load SWT class from jar: " + swtFileName);
throw new RuntimeException(exx);
}
return cl;
}
catch (MalformedURLException exx)
{
throw new RuntimeException(exx);
}                   
}
private static String getSwtJarName()
{
//Detect OS
String osName = System.getProperty("os.name").toLowerCase();    
String swtFileNameOsPart = osName.contains("win") ? "win" : osName
.contains("mac") ? "osx" : osName.contains("linux")
|| osName.contains("nix") ? "linux" : "";
if ("".equals(swtFileNameOsPart))
{
throw new RuntimeException("Launch failed: Unknown OS name: " + osName);
}
//Detect 32bit vs 64 bit
String swtFileNameArchPart = getArch();
String swtFileName = "swt-" + swtFileNameOsPart + swtFileNameArchPart
+ "-3.6.2.jar";
return swtFileName;
}
private static String getArch()
{
//Detect 32bit vs 64 bit
String jvmArch = System.getProperty("os.arch").toLowerCase();
String arch = (jvmArch.contains("64") ? "64" : "32");
return arch;
}
}

[EDIT] Comme indiqué ci-dessus, pour ceux qui recherchent le "pot-en-pot chargeur de classe": Il est inclus dans l'Éclipse du JDT (Java IDE construit sur Eclipse). Open org.eclipse.jdt.ui_*version*.pot avec un outil d'archivage et vous trouverez un fichier jar-in-jar-loader.zip à l'intérieur. J'ai renommé ce jar-in-jar-loader.jar.

intrace-ui.jar - c'est le pot que j'ai construit à l'aide de la procédure décrite ci-dessus. Vous devriez être en mesure de l'exécuter seul bocal sur l'un de win32/64, linux32/64 et osx32/64.

[MODIFIER] Cette réponse est maintenant référencé à partir de la SWT FAQ.

Il est très étrange que toutes les réponses ici juste conseille pour emballer tous SWT Bocaux dans un seul géant application fichier JAR. À mon humble avis, c'est strictement l'encontre de l'objet de SWT: il y a un SWT bibliothèque pour chaque plate-forme, de sorte qu'il est censé paquet seul le SWT bibliothèque pour chaque plate-forme. C'est très facile à faire, il suffit de définir 5 de créer des profils dans votre ANT: win32, win64, linux32, linux64 et mac64 (vous pouvez le faire mac32 ainsi, mais tous les Macs sont de 64 bits).

De toute façon, si vous voulez avoir une bonne intégration de l'application dans l'OS, alors vous aurez à faire quelques OS spécifique de choses et vous êtes à établir des profils de nouveau. Pour l'application de bureau c'est pas pratique pour un package d'application pour toutes les plates-formes à la fois pour les développeurs et pour ses utilisateurs.