Como construir corretamente flasks do IntelliJ?

Eu tenho um projeto que contém um único módulo e algumas dependencies. Eu gostaria de criar um jar, em um diretório separado, que contém o módulo compilado. Além disso, gostaria de ter as dependencies presentes ao lado do meu módulo.

Não importa como eu torço o processo “build jar” do IntelliJ, a saída do meu módulo aparece vazia (além de um arquivo META-INF).

   

Veja como construir um flask com o IntelliJ 10 http://blogs.jetbrains.com/idea/2010/08/quickly-create-jar-artifact/

Arquivo -> Estrutura do Projeto -> Configurações do Projeto -> Artefatos -> Clique em sinal de mais verde -> Jar -> De módulos com dependencies …

O acima define o “esqueleto” para onde o jarro será salvo. Para realmente construir e salvar, faça o seguinte:

Extrair para o flask de destino

Está bem

Construir | Construir Artefato

Recentemente, tive esse problema e acho que essas etapas são fáceis de seguir se qualquer solução ou link anterior não tiver detalhes.

Como criar um .jar usando o IntelliJ IDEA 14.1.5:

  1. Arquivo> Salvar tudo.
  2. Execute o driver ou a class com o método principal.
  3. Arquivo> Estrutura do Projeto.
  4. Selecione a aba “Artefatos”.
  5. Clique no botão verde mais perto da parte superior da janela.
  6. Selecione JAR no menu suspenso Adicionar. Selecione “De módulos com dependencies”
  7. Selecione a turma principal.
  8. O botão de opção deve estar selecionando “extrair para o JAR de destino”. Pressione OK.
  9. Marque a checkbox “Build on make”
  10. Pressione aplicar e OK.
  11. No menu principal, selecione o menu suspenso de criação.
  12. Selecione a opção construir artefatos.

Este ainda é um problema em 2017, espero que ajude alguém lá fora! Eu encontrei 2 possibilidades para criar jarras de trabalho sob o IntelliJ 2017.2

1. Criando artefato do IntelliJ:

  • Vá para a estrutura do projeto:

Menu de arquivo

  • Crie um novo artefato:

Crie um novo artefato

  • Selecione a class principal e certifique-se de alterar a pasta do manifesto:

insira a descrição da imagem aqui

Você precisa alterar o diretório do manifesto:

 \src\main\java 

mudar java para resources

 \src\main\resources 

É assim que deve ser:

caminho correto para o novo manifesto

  • Então você escolhe as dependencies que você quer ser empacotado em seu jar, ou perto de seu arquivo jar

  • Para construir seu artefato, vá para construir artefatos e escolha “reconstruir”. Ele criará uma pasta “out” com seu arquivo jar e suas dependencies.

insira a descrição da imagem aqui

2. Usando o plugin maven-assembly

Adicionar seção de compilation ao arquivo pom

     maven-assembly-plugin  ServiceCreate false   com.svt.optimoo.App    jar-with-dependencies     org.apache.maven.plugins maven-compiler-plugin  1.8 1.8     
  • Crie uma nova configuração de execução / debugging:

Crie uma nova configuração de execução / depuração:

  • Escolha a aplicação:

Escolha a aplicação

  • Preencher o formulário
  • Adicione o objective do maven “assembly: single” após a compilation para ser executado por último

insira a descrição da imagem aqui

Configuração final

  • Salve e execute

insira a descrição da imagem aqui

Este procedimento irá criar o arquivo jar sob a pasta “target”

Localização do arquivo JAR

Para aqueles que se beneficiam das imagens como eu:

Arquivo -> Estrutura do Projeto

insira a descrição da imagem aqui

insira a descrição da imagem aqui

insira a descrição da imagem aqui

insira a descrição da imagem aqui

É provavelmente um pouco tarde, mas eu consegui resolvê-lo dessa maneira -> abra com winrar e delete ECLIPSEF.RSA e ECLIPSEF.SF na pasta META-INF, além disso coloque “Main-class: main_class_name” (sem “.class” ) em MANIFEST.MF. Certifique-se de ter pressionado “Enter” duas vezes após a última linha, caso contrário, não funcionará.

Idéia 8.1.3

Jar está ok, desde que há uma saída compilada no diretório ‘output’ (project / out / production //)

Eu acho que você tem que correr ‘make’ antes de construir jar

para dependencies, basta marcar “show library” e escolher o que você deseja.

Você pode querer dar uma olhada no Maven ( http://maven.apache.org ). Você pode usá-lo como o processo de criação principal para seu aplicativo ou apenas executar determinadas tarefas através da checkbox de diálogo Editar configurações. O processo de criação de um JAR de um módulo dentro do Maven é bastante trivial, se você quiser include todas as dependencies em um JAR auto-executável que também seja trivial.

Se você nunca usou o Maven antes, você quer ler Better Builds With Maven .

Com o Maven você pode usar este plugin:

     maven-assembly-plugin    [path you class main]    jar-with-dependencies     make-assembly package  single       

Se você estiver usando bibliotecas de terceiros com seu projeto ou se tiver problemas com a criação do arquivo MANIFEST.MF corretamente, pode haver conflitos ao executar arquivos JAR gerados usando

 File > Project Structure > Artifacts > '+' > JAR > From modules with dependencies > ..... 

método mencionado acima.

Em vez disso, sugiro que você crie um JAR vazio e adicione todos os outros elementos à raiz de saída manualmente. Um artigo de blog maravilhoso para este método pode ser encontrado aqui: http://karthicraghupathi.com/2016/07/10/creating-an-executable-jar-in-intellij-idea/ Eu tentei os passos mencionados lá e tudo funcionou bem para mim!

Algumas das outras respostas são inúteis porque, assim que você reimportar o projeto IntelliJ IDEA do projeto maven, todas as alterações serão perdidas.

A construção do jar precisa ser acionada por uma configuração de execução / debugging, não pelas configurações do projeto.

Jetbrains tem uma boa descrição de como você pode fazer isso aqui:

https://www.jetbrains.com/help/idea/maven.html

Role para baixo até a seção chamada “Configurando gatilhos para metas do Maven”.

(A única desvantagem de sua descrição é que suas capturas de canvas estão no esquema de colors preto-sobre-branco padrão, em vez do tema super incrível de darcula. Ugh!)

Então, basicamente, o que você faz é abrir o painel “Maven Projects”, você encontra o projeto de interesse, (no seu caso, o projeto que constrói seu jar), abaixo dele você encontra o objective do maven que você quer executar , (geralmente o “pacote” objective cria jars,) você abre o menu de contexto nele (clique com o botão direito do mouse em uma máquina Windows) e haverá uma opção “Executar antes de executar / depurar …” que você pode selecione e ele irá levá-lo pela mão de lá. Muito fácil.

Caso você esteja tentando construir um jar com kotlin, você precisa criar uma pasta src/main/java e usar essa pasta como um local para a pasta META-INF.

Ant e Maven são amplamente utilizados. Eu prefiro Ant, eu sinto que é mais leve e você, o desenvolvedor, está mais no controle. Alguns sugerem que é a sua desvantagem 🙂