O NPM é um repositório de pacotes exclusivo do mundo JavaScript. Basicamente, aqui estão as bibliotecas JS que podem ser usadas no frontend / no navegador, mas também existem bibliotecas do lado do servidor para uso em node.js e não apenas. Se você é um programador Java e precisa se integrar ao repositório NPM, provavelmente você tem um dos seguintes casos:
- Você está escrevendo um aplicativo da Web em uma das estruturas Java e certos pacotes NPM são necessários para o lado do cliente
- Você tem um aplicativo Java (por exemplo, para Android), que precisa ser capaz de solicitar dependências e recursos / pacotes próprios do NPM
Vamos ver como isso pode ser feito em Java.
Recursos NPM para um aplicativo da web
Você tem 2 opções:
- Empacote os recursos NPM necessários dentro de seu WAR / JAR
- Use o CDN para carregar os recursos necessários em tempo de execução
Empacotando recursos NPM em WAR / JAR
Em primeiro lugar, você precisa aprender mais sobre algo como WebJars . Ele permite que você "espelhe" pacotes NPM (e não apenas) para o repositório Maven. Desta forma, você pode trabalhar com pacotes NPM como faria com pacotes Java regulares no Maven. Por exemplo, para incluir recursos do conhecido Boostrap em seu WAR, é suficiente adicionar a seguinte dependência a pom.xml:
<dependency>
<groupId>org.webjars.npm</groupId>
<artifactId>bootstrap</artifactId>
<version>4.5.0</version>
</dependency>
WebJars reflete pacotes de NPM para Maven junto com todas as dependências necessárias, de forma que ao conectar um JAR por dependências, todos os outros pacotes necessários serão conectados.
WebJars também possui um grande conjunto de bibliotecas para diferentes estruturas Java para facilitar o trabalho com recursos compactados e conectados. Leia mais na documentação .
WebJars é uma ótima ferramenta para qualquer desenvolvedor Java Backend. Mas também existem alternativas mais leves: empacotar os pacotes necessários do NPM usando plug-ins Maven. Aqui está uma lista talvez não completa:
Por exemplo, para incluir os pacotes vue e vuex das versões necessárias usando o jnpm-maven-plugin, adicione as seguintes linhas ao pom.xml:
<plugin>
<groupId>org.orienteer.jnpm</groupId>
<artifactId>jnpm-maven-plugin</artifactId>
<version>1.0</version>
<executions>
<execution>
<goals>
<goal>install</goal>
</goals>
<configuration>
<packages>
<package>vue@2.6.11</package>
<package>vuex@~3.4.0</package>
</packages>
</configuration>
</execution>
</executions>
</plugin>
Você pode usar a notação NPM para definir o intervalo de versões necessárias:
- Asterisco (* | X | x) - 1. * equivalente a> = 1.0.0 & <2.0.0
- Til (~) - ~ 1,5 é equivalente a> = 1.5.0 e <1.6.0
- Hífen (-) - 1,0-2,0 é equivalente a> = 1.0.0 & <= 2.0.0
- Acento circunflexo (^) - ^ 0.2.3 é equivalente a> = 0.2.3 & <0.3.0
- Intervalo parcial - 1 é equivalente a 1.X ou> = 1.0.0 & <2.0.0
- Negação -! (1.x) é equivalente a <1.0.0 &> = 2.0.0
- Difícil - ~ 1,3 | (1.4. * &! = 1.4.5) | ~ 2
Além disso, você pode especificar quais arquivos incluir de pacotes usando inclui e exclui. Por exemplo, geralmente um pacote NPM contém os arquivos "compilados" no diretório / dist. Outros arquivos são arquivos de origem e provavelmente não serão necessários ou úteis em um aplicativo da Web Java. Para incluir apenas o conteúdo do diretório dist /, basta adicionar o seguinte à seção:
<includes>
<include>dist/*</include>
</includes>
Por padrão, jnpm-maven-plugin empacota recursos exatamente nos mesmos caminhos que WebJars. Isso permite que as bibliotecas WebJars mencionadas acima sejam usadas em diferentes estruturas para acessar recursos. Se você precisar de qualquer outro formato de embalagem específico, consulte a documentação .
Usando CDN
Existem muitos CDNs disponíveis publicamente com recursos NPM. Os mais famosos e usados:
Você também pode usar seu próprio CDN (por exemplo, gerado por meio do docker) ou até mesmo incorporar a funcionalidade de CDN em seu Web-App. Por exemplo, adicione o seguinte servlet ao web.xml para habilitar o JNPM CDN. Edite conforme necessário:
<servlet>
<servlet-name>CDNServlet</servlet-name>
<servlet-class>org.orienteer.jnpm.cdn.CDNServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CDNServlet</servlet-name>
<url-pattern>/cdn/*</url-pattern>
</servlet-mapping>
Depois de baixar o servlet NPM, os recursos estarão disponíveis por meio do seguinte formato de URL: http (s): // <domínio>: <porta> / <caminho para o aplicativo da web> / cdn / <pacote NPM> / <caminho para o arquivo>.
Por exemplo:
localhost : 8080/cdn/vue@2.6.11/dist/vue.js
Trabalhar com NPM REST API de Java
É claro que você pode usar a API REST do NPM Registry diretamente, digamos, via Retrofit . A documentação correspondente o ajudará com isso . Mas é mais conveniente usar a biblioteca JNPM , que fornece um wrapper Java para esta API REST e muito mais.
Inclua o JNPM Jar no pom.xml:
<dependency>
<groupId>org.orienteer.jnpm</groupId>
<artifactId>jnpm</artifactId>
<version>1.0</version>
</dependency>
Vamos inicializar a API JNPM:
JNPMService.configure(JNPMSettings.builder()
.homeDirectory(Paths.get("/home/myuser/.jnpm")) //
.downloadDirectory(Paths.get("/tmp")) //
// - .
.build());
A API JNPM oferece 2 opções: API síncrona e API assíncrona via RXJava. O que usar exatamente depende de você:
JNPMService jnpmService = JNPMService.instance(); //Synchronous Java API
RxJNPMService rxJnpmService = JNPMService.instance().getRxService() //RXJava API
Exemplo de uso:
// NPM
System.out.println(JNPMService.instance().getRegistryInfo());
// VUE
System.out.println(JNPMService.instance().getPackageInfo("vue").getLatest());
// vue@2.6.11
System.out.println(JNPMService.instance().getVersionInfo("vue", "2.6.11").getDescription());
//
System.out.println(JNPMService.instance().bestMatch("vue@<2").getVersionAsString());
// vue@2.6.11
VersionInfo vueVersion = JNPMService.instance().getVersionInfo("vue", "2.6.11");
vueVersion.downloadTarball().blockingAwait();
System.out.println(vueVersion.getLocalTarball().getAbsolutePath());
// "vue"
System.out.println(JNPMService.instance().search("vue").getObjects().get(0).getSearchPackage().getDescription());
// dev vue
// NPM (node_modules/vue ..)
JNPMService.instance().getRxService()
.traverse(TraverseDirection.WIDER, TraversalRule.DEV_DEPENDENCIES, "vue")
.subscribe(t -> {System.out.println(t); t.install(Paths.get("target", "readme"), InstallationStrategy.NPM);});
Se você tiver um caso específico que não foi descrito aqui, avise-me!