Come esprimere dipendenze progetto interregionale in Eclipse PDE

Question

Sto cercando la migliore pratica di gestire dipendenze progetto interregionale tra i tipi di progetto misti in cui alcuni dei progetti sono progetti / OSGI pacco plug-in Eclipse (un'applicazione RCP) e altri sono semplicemente vecchi progetti Java (moduli servizi web ). Pochi dei plug-in Eclipse hanno dipendenze su progetti Java.

Il mio problema è che, almeno per quanto ho guardato, non v'è alcun modo di esprimere in modo pulito una tale dipendenza in ambiente Eclipse PDE. Posso avere progetti plug-in dipendono da altri progetti plug-in (via Import-Package o Require-Bundle intestazioni manifesto), ma non di progetti java pianura.

Mi sembra di essere in grado di avere progetti dichiarare una dipendenza da un barattolo da un altro progetto in un'area di lavoro, ma questi file jar non vengo preso da né la configurazione di esportazione né di lancio (anche se, modifica il codice Java vede le librerie proprio bene ).

I "progetti Java" sono utilizzati per i servizi di costruzione per essere distribuiti su un contenitore J2EE (JBoss 4.2.2 per il momento) e producono, in alcuni casi più Jar - uno per la distribuzione per l'orecchio JBoss e un altro per l'utilizzo da parte del cliente codice (un'applicazione RCP).

Il modo in cui abbiamo "risolto" il problema per ora è che abbiamo più di 2 strumenti esterni launcher configurazioni - uno per la costruzione di tutto il vaso e di un altro per la copia di questi barattolo di ai progetti plug-in. Questo funziona (o quasi), ma il "intera costruzione" e "giare copia" bersagli incorrere piuttosto un grande passaggio di generazione, bypassando la funzione di generazione incrementale intero Eclipse e copiando i vasi invece di riferimento ai progetti che sto disaccoppiamento le informazioni sulle dipendenze e chiedendo piuttosto un massiccio aggiornamento di lavoro che divora il tempo di sviluppo come se fosse caramelle.

Quello che mi piacerebbe avere è molto più di installazione spazio di lavoro "naturale" che avrebbe gestire le dipendenze tra i progetti e richiedere incrementale ricostruisce solo in quanto sono necessari, essere in grado di utilizzare il codice cliente da librerie di servizio in un'applicazione RCP plug-in ed essere in grado di avviare l'applicazione RCP con tutte le classi necessarie dove sono necessari.

Così posso avere la mia torta e mangiare troppo;)

NOTE

Per essere chiari, non si tratta tanto di gestione delle dipendenze e la gestione del modulo in questo momento come si tratta di configurazione di Eclipse PDE.

Sono ben consapevole di prodotti come [Maven], [Ivy] e [Buckminster] e risolvere un problema del tutto diverso (una volta che ho risolto il problema di configurazione di lavoro, questi prodotti possono effettivamente rivelarsi utile per materializzare lo spazio di lavoro e creare il prodotto)

Answer 1

Non ho mai fatto così questo è un approccio teorico. Ma mi piacerebbe provare un sistema di gestione delle dipendenze come l'edera o maven2.

Dal maven2 fa molto di più, quindi solo la dipendenza gestione, io consiglierei di edera in questo caso.

Answer 2

progetti Eclipse dipendono l'uno dall'altro, in virtù della casella di controllo nelle proprietà del progetto (progetti dipendenti?) Che è come Eclipse decide quale costruire. È possibile impostare da soli, ma di solito è impostato quando si cambia il percorso di generazione Java. Memorizza i dati nel file .project IIRC così una volta che sei andato attraverso la GUI e visto quello modifiche, è possibile essere più flessibili nel modo in cui si applica agli altri.

Tuttavia, sembra che si desidera combinare Vasi e bundle. Il modo più semplice per farlo è solo trattare tutti i progetti come progetti Java. Nel progetto PDE, si può effettivamente entrare e modificare il percorso di generazione Java; che sarà lamentarsi e dire che non è il modo giusto per farlo, ma vi permetterà di avere un progetto PDE dipendere da un progetto Java senza tutto quel soffice jaring up. Detto questo, non mi sorprenderebbe se ci sono stati problemi di runtime con questo approccio - il runtime PDE è probabile che non vedere in questo modo

.

L'altro approccio è quello di rendere i vostri stessi JAR fasci PDE / OSGi. Dopo tutto, un fascio di OSGi non è altro che un barattolo con un po 'di cruft in più nel manifesto, e vi permetterà di sviluppare e riunire i vostri progetti banalmente utilizzando la gestione automatica delle dipendenze. Questo è probabilmente il più facile da andare per, anche se non si ha realmente bisogno il manifesto di essere presente nei vostri pacchi. Ma fare questo significherà la tua PDE applicazione può essere fornito con un approccio più modulare anziché incorporare le librerie in ogni plugin, se necessario.

Quindi, PDE può generare fasci OSGi, e questo è solo un altro nome per JAR + roba manifesto. È possibile utilizzare un JAR esattamente nello stesso modo in altri ambienti (ad esempio per l'orecchio o altro client utilizza) ed è possibile usufruire dello strato OSGi nella vostra app. Non c'è davvero alcun motivo per non farlo dato il tipo di pacchetto ibrido che si sta parlando.

Answer 3

La nostra soluzione utilizza un generatore di Ant per copiare le "classi" directory dei progetti Java semplici direttamente nella directory principale del progetto di plugin. Tralasciamo la fase di costruzione JAR per risparmiare tempo, e funziona abbastanza bene. Se il progetto plug dipende JAR esterni that're già costruite, copiamo quelle troppo.

Ecco esattamente come configurarlo in Eclipse 3.5 (scusate per la formattazione strano, ma questo è l'unico modo che ho trovato per conservare indentazione):

Create empty "classes" dir in plugin project
Select plugin project, hit F5 to refresh resources
Create new Ant build file in plugin project to copy dependencies (ours is shown below)

Right-click plugin project, select Properties
  Select Builders
  Click "New..." (brings up Edit Configuration dialog)
    Select Ant Builder and click "OK"
    Name your builder (ours is called "PluginProject externals")
    Browse workspace for Buildfile (ours is ${workspace_loc:/PluginProject/copyDependencies.xml})
    click Refresh tab
      check "Refresh resources upon completion", click "Specific resources"
      click "Specify Resources...", check box for the classes dir, click "Finish"
  Click "OK" (closes Edit Configuration dialog)
  Click "Up" to move "PluginProject externals" to top of builder list
Click "OK" (closes Properties dialog)

Open your plugin project's MANIFEST.MF
Click "Runtime" tab
Click "Add..." under "Classpath", select your the "classes" dir and JARs and click "OK"

La creazione manuale della directory vuota "classi" nel progetto plugin è così si può dire al vostro nuovo costruttore per aggiornare quella risorsa (che non esiste ancora prima che il nuovo costruttore viene eseguito). Ecco cosa c'è nel nostro file copyDependencies.xml:

<project name="Copy dependencies" default="copyDependencies" basedir=".">
  <!--
    This copying is needed because it appears that Eclipse plugins can't
    depend directly on external Eclipse projects.
  -->
  <description>
    Copies external dependency class andd JAR files into this plugin's directory.
  </description>

  <target name="copyDependencies">
    <copy file="../External/JDOM/jdom-1.0/build/jdom.jar" todir="." preservelastmodified="true"/>
    <copy file="../External/Xalan/xalan-j_2_6_0/bin/xalan.jar" todir="." preservelastmodified="true"/>
    <copy file="../External/Xalan/xalan-j_2_6_0/bin/xercesImpl.jar" todir="." preservelastmodified="true"/>
    <copy file="../External/Xalan/xalan-j_2_6_0/bin/xml-apis.jar" todir="." preservelastmodified="true"/>
    <copy todir="./classes/com/arm" preservelastmodified="true">
      <fileset dir="../Utilities/src/com/arm" excludes="**/*.java"/>
    </copy>
  </target>
  <target name="clean" description="Deletes local copies of external classes and JARs.">
    <delete file="jdom.jar" quiet="true"/>
    <delete file="xalan.jar" quiet="true"/>
    <delete file="xercesImpl.jar" quiet="true"/>
    <delete file="xml-apis.jar" quiet="true"/>
    <delete dir="./classes/com/arm/utilities" quiet="true"/>
  </target>
</project>

L'unico inconveniente di questo metodo sembra essere che Eclipse non è perfetto al 100% circa invocando il costruttore esterno quando ha bisogno di essere invocato, in modo a volte si deve fare un "Progetto> Clean ..." in Eclipse per forzarlo lungo.

Answer 4

Hai le mie simpatie. Anch'io ho combattuto con questo problema e il muro-di-silenzio dalle sviluppatori Eclipse su una semplice, ovvia domanda così: come dichiarare una dipendenza da un plugin per un progetto Java normale (in modo tale che funziona in fase di esecuzione)

Non penso che lo supportano. L'unico modo Ive ha ottenuto intorno al problema è quello di creare cartelle all'interno i miei progetti di plugin che sono in realtà i collegamenti alle cartelle bin / dei progetti Java, e quindi includere queste cartelle nel plugin. Questo almeno funziona, ma la sua fragile a causa dei percorsi filesystem assoluti necessari.

Answer 5

forse è possibile utilizzare "le proprietà del progetto" -> "assemblea di distribuzione" a Eclipse, e aggiungere altri progetti al progetto principale. Gli altri progetti stanno vedendo come "vasi", che automaticamente vengono aggiunti al file di distribuzione (la guerra, l'orecchio o qualsiasi altra cosa). Forse questo può essere opere. Almeno per me funziona. In bocca al lupo !!

Ariesandes.

Answer 6

C'è un'opzione "fonte Link" nelle proprietà percorso di generazione che consente di definire cartelle di origine aggiuntive per un progetto. È possibile selezionato la cartella "src" di un altro progetto di lavoro e rinominarlo in "SRC2" o quello che volete. Questo modo classi sono compilati e distribuiti nella cartella di output progetto plug-in e possono essere caricati in fase di esecuzione.

Answer 7

Con una complessa serie di dipendenze di creazione, ho trovato Maven2 e Hudson (per CI) di essere una bella bella combinazione. C'è voluto un po 'per creare le infrastrutture e ottenere la mia testa intorno configurazione, ma dopo di che, appena finito di lavorare.

Naturalmente, siete dipendenti poi Maven2 (o Hudson) supporto per il meccanismo di costruzione. Non sono sicuro di quanto bene Eclipse Headless generazioni sono supportati. Ma se l'unica ragione che si sta utilizzando Eclipse senza testa è quello di consentire le dipendenze per essere espressi in un unico luogo, fatevi un favore e l'interruttore.

Answer 8

Sto avendo gli stessi problemi esatti. Abbiamo una serie di multipli normali progetti Java che può essere costruito da Maven e dovrebbe (attualmente) tutti condividono la stessa classpath per funzionare correttamente. Questi progetti possono essere utilizzati per avviare un server in un ambiente non-OSGi. Poi abbiamo anche un client Eclipse RCP che usa questi progetti come un pacco. Sono perfettamente in grado di costruire questo uno-big-fascio con Maven usando l'Apache Maven Felix Bundle Plugin e tutto funziona bene. Ma ogni volta che cambia una classe nel progetto normale che devo ricostruire l'intero pacchetto. generazione incrementale e il collegamento delle risorse non funziona.

Ho provato la "soluzione" con il collegamento binari / directory di origine di questi progetti nel classpath Manifesto del one-big-fagotto e sembra funzionare ma sarebbe un vero e proprio incubo per la manutenzione perché ho nemmeno bisogno di collegare qualche individuo file.

Quindi, per ironia della sorte a causa dell'uso di OSGi nel client Sono in realtà pensando di crollare la nostra struttura bella e modulare con moduli Maven in sottopacchetti di un solo progetto plugin. Questa è un'alternativa meglio che avere sviluppo estremamente lento.

L'altro e migliore alternativa (secondo i ragazzi OSGi), che mi indagare primo è quello di rendere tutti i miei moduli Maven in fasci OSGi. Ma questo può essere un vero e proprio PITA perché dipendo scansione classpath e combinare più file di configurazione da più fasci (con volte lo stesso nome) per formare una configurazione.

(In particolare si usa il framework Spring e unire più file persistence.xml in un contesto di persistenza. Abbiamo anche unire più file di contesto primavera XML da diversi moduli (tutte dotate di un aspetto diverso) che dovrebbe insieme formano un contesto Primavera di essere utilizzato entro la primavera-DM.)