Creazione classi nello stesso pacchetto in vasi separati

Question

Ho un'applicazione server e due applicazioni client basate su Swing. Li stiamo sviluppando in eclissi e c'è un progetto separato per ciascuno.

Molte classi sono condivise. Ad esempio, il pacchetto my.server ha alcune classi sia per il server che per i client mentre altre sono solo per il server. Anche se preferisco inserirli nello stesso pacchetto perché sono strettamente correlati e alcuni di essi si basano sulla visibilità del pacchetto, non voglio distribuire classi di cui un'applicazione non ha bisogno in quanto non solo aumenterebbero le dimensioni del file, ma anche sarebbe un rischio per la sicurezza.

Al momento, ciascuno dei server e dei client ha gli stessi barattoli, il che è un disastro. Idealmente, mi piacerebbe creare automaticamente i jar in base alla dipendenza come segue.

Server:

• server.jar: classi utilizzate dal server solo
• server client1-common.jar: classi condivise da server e client 1
• server client2-common.jar: classi condivise da server e client 2

client 1:

• client1.jar: classi utilizzate dal Cliente 1 solo
• server client1-common.jar: classi condivise da server e client 1
• client-common.jar: classi condivise da client 1 e 2 client, ma non Server

client 2:

• client2.jar: classi utilizzate dal Cliente 2 solo
• server client2-common.jar: classi condivise da server e client 2
• client-common.jar: classi condivise da Client 1 e Client 2, ma non Server

Mi rendo conto che è possibile farlo manualmente utilizzando formica, ma sarebbe un disastro di manutenzione. C'è uno strumento che si prende cura di tale dipendenza automaticamente?

Answer 1

Una delle migliori pratiche per quanto riguarda le applicazioni di costruzione consiste nell'avere un contenitore per progetto.
Maven, ad esempio, utilizza questo come predefinito. Puoi ingannarlo per fare altrimenti, ma è meglio unirti a loro invece di "combatterli".

http://maven.apache.org/guides/mini/guide-using-one-source-directory.html
http://www.sonatype.com/people/2010/01/how-to-create-two-jars-from-one-project-and-why-you-shouldnt/

Quindi, nel tuo caso è necessario creare 6 progetti: Server, client1, CLIENT2, ServerClient1Common, ServerClient2Common, ClientCommon

Al fine di selezionare le classi necessarie, ho non pensare che ci sia uno strumento, e probabilmente dovresti sapere meglio qual è la funzionalità comune. Creare i progetti comuni e aggiungerli al percorso di costruzione: le dipendenze. Quindi inizia a spostare le tue classi nel progetto Common, lasciandole nello stesso pacchetto.

Ad esempio, creare un progetto ServerClient1Common.
Per Client1, passare a Configura percorso di generazione -> Progetti. Aggiungi ServerClient1Common. Rimuovere tutti i riferimenti a Progetto server.
Per Server, vai a Configura percorso di creazione -> Progetti. Aggiungi ServerClient1Common. Rimuovere tutti i riferimenti al progetto Client1.

Ora dovresti avere un sacco di classi/importazioni mancanti. Cerca di risolverli uno a uno.

Alla fine, dovresti essere in grado di compilare i 3 progetti e ottenere i vasi che hai menzionato.

PS: Altre strategie (come un progetto uber con obiettivi di compilazione diversi o 3 progetti con costruttori di formiche/formiche intrecciate) sono più disordinati. C'è forse un'eccezione - un altro modo di dividere le classi, ma non so se si applica a te: client1.jar, client1-interface.jar, client2.jar, client2-interface.jar, server.jar, server- interface.jar.In questo modo è possibile utilizzare 3 progetti con ciascuno con due barattoli di destinazione. Per eseguire client2.jar è necessario il server-interface.jar

Answer 2

Cosa intendi per "disastro di manutenzione"? Se crei uno script ANT, eseguilo e compilerà e confezionerà i vasi per te.

Come alternativa più affidabile, è possibile utilizzare Maven. Per qualcosa di più leggero, lo strumento di esportazione di eclissi incorporato potrebbe funzionare.

Answer 3

Non riesco a presentarvi una soluzione pronta per l'uso. Ecco un'idea però: creare un'annotazione o un insieme di annotazioni come questa:

@jarselector(types='server') 
class ServerOnly { 
    ... 
} 

@jarselector(types='server,client1') 
class ServerAndClient { 
    ... 
} 

quindi creare il proprio compito formica estendendo il compito vaso (o plug-in Maven) o lascia la tua compito, che prende questa annotazione e classi di pacchetti in base all'annotazione, che useresti come filtro.

Dovresti solo creare il compito una volta - l'ho fatto in passato, è meno complicato di quanto suoni e il problema sembra abbastanza grande da giustificare lo sforzo.

Successivamente è necessario annotare tutte le classi una volta (o in base all'implementazione solo le classi richieste dai client o solo quelle non condivise da ogni jar ecc.). Chiunque veda una classe può vedere immediatamente a cosa serve. Quando si crea una nuova classe, è possibile aggiungere facilmente l'annotazione.

Realmente non penso che ci sia un task form o un plugin Maven pronto per fare questo.

In alternativa, se davvero non è possibile modificare la struttura del pacchetto, è possibile utilizzare più directory di origine per conservare i pacchetti ma suddividere i file in directory diverse. Eclipse non si cura di quante directory di sorgenti usi. Dovresti quindi adattare lo strumento di compilazione solo una volta per le directory di origine e quindi ordinare i file in questo modo.

Answer 4

Avere un progetto Eclipse separato per ogni JAR che si intende creare. Quindi imposta le dipendenze nella scheda "Progetti" del Percorso di creazione, per ciascuno dei progetti di livello superiore. Quindi, il progetto "server" avrà "server-client1-comune" e "server-client2-comune" elencati come progetti richiesti. E così via.

Ho visto questo modello utilizzato da un certo numero di organizzazioni diverse, e ho sempre pensato che questo fosse il modo "accettato dal settore" di farlo. Funziona!