Genera interfacce dattiloscritto dalle interfacce Java

Question

Possiedo un'applicazione server Java, che utilizza Jackson per serializzare genericamente DTO utilizzando l'API di reflection. Per esempio per questa interfaccia DTO:

package com.acme.library; 
public interface Book { 
    com.acme.library.Author getAuthor(); 
    String getTitle(); 
} 

Dal implementazione POJO di questa interfaccia, Jackson sarà genericamente serializzare i seguenti entità:

{ 
    "author": { "name": "F. Scott Fitzgerald"}, 
    "title": "The Great Gatsby" 
} 

Questo payload sarà essere ricevuto utilizzando un HTTP GET dalla mia applicazione dattiloscritto , che è AngularJS-based:

$http.get("http://localhost/books/0743273567") 
    .success((book: Book) => { ... }); 

modo che io sono in grado di utilizzare la natura fortemente tipizzato del dattiloscritto, mi ritrovo a mano codifica il seguente Interfaccia dattiloscritto:

module com.acme.library { 
    export interface Book { 
     author: com.acme.library.Author; 
     title: String; 
    } 
} 

Di conseguenza, devo mantenere due copie di questo stessa interfaccia - che è ingombrante al meglio. Ciò diventa particolarmente sgradevole, poiché mi piacerebbe avere gli stessi commenti javadoc/jsdoc su entrambe le interfacce, che coinvolge un intero heap di copia & incolla.

---

Mi piacerebbe trovare un meccanismo per automatizzare questo processo.

Java è il mio linguaggio di sviluppo principale. Come tale, mi piacerebbe trovare qualche strumento che sia in grado di convertire dalla dichiarazione dell'interfaccia Java (tramite la reflection API?) All'interfaccia TypeScript pertinente.

L'unico strumento che ho scoperto in questo dominio è il pacchetto NPM ts-java. Tuttavia, questo è troppo pesante per il mio caso d'uso. Aggiunge metodi dalla gerarchia Object a ciascuna interfaccia, ad es. hashCode(), wait(), getClass(),

Answer 1

Attualmente sto lavorando a un progetto con la stessa configurazione del tuo: un'API Java e un'applicazione web Typescript.

Stiamo utilizzando cz.habarta.typescript-generator.typescript-generator-maven-plugin per generare i file .d.ts durante la creazione dell'API. I file di definizione vengono quindi confezionati come artefatto con <type>d.ts</type>, utilizzando lo org.codehaus.mojo.build-helper-maven-plugin. Infine, l'artefatto viene importato come dipendenza nell'applicazione Web, in cui i file di definizione vengono decompressi nella directory target.

Questa configurazione richiede l'utilizzo di Maven per l'applicazione Web, che non è l'ideale, ma è un piccolo prezzo da pagare per i file di definizione generati automaticamente.

Answer 2

È possibile utilizzare typescript-generator come larslonne menzionato. Genera interfacce TypeScript da classi JSON Java.Alcune caratteristiche si possono trovare utili:

• Maven e plug Gradle (può anche essere invocato direttamente da Java)
• Jackson 1 e Jackson 2
• collezioni, enums, ereditarietà, farmaci generici
• commenti Javadoc per JSDoc commenta
• dettagliata documentazione (README, Wiki, Maven plugin)
• emissioni nella Maven repo centrale

.210

Ecco ad esempio come usarlo da Maven:

<plugin> 
    <groupId>cz.habarta.typescript-generator</groupId> 
    <artifactId>typescript-generator-maven-plugin</artifactId> 
    <version>1.25.322</version> 
    <executions> 
     <execution> 
      <id>generate</id> 
      <goals> 
       <goal>generate</goal> 
      </goals> 
      <phase>process-classes</phase> 
      <configuration> 
       <jsonLibrary>jackson2</jsonLibrary> 
       <classes> 
        <class>com.acme.library.Book</class> 
       </classes> 
       <outputFile>target/rest.d.ts</outputFile> 
       <outputKind>module</outputKind> 
      </configuration> 
     </execution> 
    </executions> 
</plugin> 

Edit: Eseguire utilizzando mvn process-classes o utilizzando successiva fase come mvn install.
È inoltre possibile aumentare il livello <configuration> elemento due ed eseguire mvn typescript-generator:generate.

Modifica: I am the author of typescript-generator.

Answer 3

ho avuto grande fortuna con Amdatu TypeScript Generator

Può funzionare in Gradle o autonomo dal terminale (io ho usato terminale, ed è quello che queste istruzioni sono qui)

sufficiente clonare il repo, eseguire ./gradlew per costruire esso.

Per eseguirlo, ho dovuto deviare un po 'dalle loro istruzioni perché non c'era alcun punto di ingresso nel jar (non avresti questo problema se si utilizza una build gradle, perché specificarebbe la classe di immissione).

ho usato:

java -cp build/libs/org.amdatu.typescriptgenerator-1.0-SNAPSHOT.jar org.amdatu.typescriptgenerator.standalone.TypeScriptGeneratorStarter 

Dovrebbe poi si lamentano che non c'è un file typescript.settings.json, che si aspetta nella directory si esegue il comando da.

io includo il mio esempio perché il file di esempio le impostazioni del repo collegato è un po 'poco chiaro:

{ 
    "folder" : "/projectsfolder/project", 
    "classFolder" : "target/classes", 
    "output" : "typscriptOutputDirectory", 
    "baseFolder" : "", 
    "clearOutput" : false, 
    "packages" : [ 
    ".*regexforwhatpackagesinsidetargetprojectshouldbeturnedintotypescript.*" 
    ], 
    "excludePackages" : [ ], 
    "excludePattern" : [ ], 
    "types" : { }, 
    "mapping" : { }, 
    "enumType" : "class", 
    "classType" : "interface", 
    "classPath" : [ ] 
} 

I campi più importanti nelle impostazioni sono:

• folder è dove il vostro Il progetto è già
• classFolder è dove questo generatore cercherà all'interno di quella cartella per le classi java compilate
• output è la directory in cui verranno posizionati i file di definizione tipografico, rispetto a dove si sta eseguendo il generatore
• packages è un regex Java per i pacchetti dovrebbero essere trasformati in dattiloscritto definizioni

Answer 4

As such, I'd like to find some tool which is capable of converting from the Java interface declaration (via the reflection API?) to the relevant TypeScript interface.

Puoi dare un'occhiata a these samples. Non ho portato la funzione java -> dattiloscritto a uno strumento CLI autonomo (dall'intero progetto) ma è facile farlo.