implementação do pacote JAR
O pacote JAR pode ser embalado usando a diretiva JAR. Entrar o jar na linha de comando pode visualizar o conteúdo da diretiva JAR
Dos dois exemplos mostrados no último show, há duas maneiras de embalar. A diferença entre os dois é usar o arquivo manifesto de manifesto que você definiu. O primeiro exemplo não é embalado usando o arquivo de manifesto; portanto, o arquivo de manifesto no pacote de jar gerado final é o arquivo padrão. Este método é adequado para uma estrutura de pacote de jar relativamente simples, não há outra dependência do pacote JAR e o pacote JAR gerado não precisa ser executável. O pacote JAR gerado dessa maneira não pode ser executado usando o comando java -jar XXX.jar porque a entrada do programa não é especificada no arquivo de manifesto. A segunda instância é um método de embalagem relativamente comum, ou seja, use um arquivo de manifesto personalizado para participar da embalagem, para que você possa adicionar dependências ao pacote e especificar a entrada do programa para implementar java -jar XXX.jar para executar diretamente o pacote JAR.
O primeiro método de embalagem simples
O mais fácil é empacotar e produzir o arquivo de bytecode da classe compilada na pasta atual. Exemplos são os seguintes:
Escreva três arquivos java, test1.java test2.java e main.java
classe pública test1 {public static void main (string [] args) {} public void Display () {System.out.println ("Esta é a classe test1"); }}e Test2.java Arquivo
classe pública test2 {public static void main (string [] args) {} public void Display () {System.out.println ("Esta é a classe test2"); }}Main.java
public class Main {public static void main (string [] args) {for (string a: args) {System.out.println ("parâmetro gived"+a); } test1 t1 = new test1 (); t1.display (); test2 t2 = new test2 (); t2.display (); }} Compile esses três arquivos na linha de comando e use o comando javac para compilar.
Use a diretiva JAR para empacotar o arquivo da classe compilada
A lista adicionada é exibida durante a embalagem. Use a ferramenta de descompressão para abrir o test.jar gerado. Jar e você pode ver a seguinte estrutura:
Além dos arquivos de três classes compilados, há uma pasta meta-INF adicional, que contém um manifesto.mf (arquivo de lista). O papel desse arquivo é muito importante, conforme explicado mais tarde. Vejamos o conteúdo primeiro
Manifesto muito simples, contém apenas a versão manifesta e a versão Java.
Execução do java -jar test.jar neste momento tem o seguinte efeito:
Nenhum erro de atributo da lista principal relatado. Isso ocorre porque usamos o primeiro método para gerar o frasco usando o manifesto padrão. O manifesto padrão não especifica a entrada do programa; portanto, ocorre um erro.
Você pode alterar diretamente o arquivo de manifesto no pacote JAR (abra a ferramenta de descompressão e salvá -lo depois de alterá -lo) e alterá -lo para o seguinte efeito:
Depois de executar java -jar test.jar novamente, o programa entra no conteúdo correto:
O atributo de classe principal é adicionado ao arquivo de manifesto e especifica a entrada do programa, que realiza a execução direta do arquivo JAR.
Portanto, o uso do manifesto padrão não pode executar diretamente o arquivo JAR. Use o arquivo de manifesto que você definir para empacotá -lo ou altere o arquivo de manifesto no pacote.
A segunda maneira de embalar
O segundo método de embalagem é mais geral. De um modo geral, a primeira linha do arquivo java é package XXX; Ou seja, o nome do pacote, ele também determina o caminho do arquivo de classe compilado. Quando existem vários arquivos Java a serem compilados e embalados e eles têm nomes de pacotes diferentes, é muito irrealista escrever um arquivo por vez ao empacotá -lo de acordo com o primeiro método, então há um segundo método. Coloque todos os diretórios que existem nos arquivos de classe a serem embalados e os pacotes JAR de dependência em uma pasta raiz (como Foo) e, em seguida, escreva um arquivo de manifesto para especificar a entrada do programa e outros pacotes de jar de dependência adicionados. Ao executar o comando:
Observe que há um espaço e um ponto atrás foo/ Pasta no comando acima
Vamos ver um exemplo abaixo
O mesmo é test1.java, test2.java e main.java, mas cada um tem seus próprios nomes de pacotes.
pacote cn.mytest1; public class Test1 {public static void main (string [] args) {} public void Display () {System.out.println ("Esta é a classe test1"); }} pacote cn.mytest2; public class Test2 {public static void main (string [] args) {} public void Display () {System.out.println ("Esta é a classe test2"); }} pacote cn.mymain; importar cn.mytest1.test1; importar cn.mytest2.test2; public class Main {public static void main (string [] args) {for (string item: args) {System.out.println ("Passando o parâmetro"+item); } test1 t1 = new test1 (); test2 t2 = new test2 (); t1.display (); t2.display (); }} Também compilados usando a diretiva JAVAC, os três arquivos de classe existem em caminhos diferentes porque seus nomes de pacotes são diferentes. Coloque todas as pastas compiladas contendo arquivos de classe na pasta Foo:
Em seguida, escreva um arquivo de manifesto fora do Foo:
O conteúdo do manifesto é o seguinte:
Nota : A última linha do arquivo de manifesto é uma linha vazia.
Execute o comando da linha de comando: jar cvfm test.jar MANIFEST.MF -C foo/ .
Teste se o pacote JAR pode ser executado diretamente na linha de comando, use o comando java -jar test.jar
Pacote corretamente e execute o frasco com sucesso.
Introdução ao arquivo de manifesto
Nos dois exemplos acima, podemos ver que o arquivo de manifesto é necessário para a embalagem JAR. O arquivo de manifesto descreve as informações detalhadas do arquivo JAR embalado e existe na pasta Meta-Inf embalada. O principal conteúdo de um arquivo manifesto simples é o seguinte:
O principal é que os três atributos da classe principal da classe manifestos são muito importantes ao fazer pacotes de jar. Manifest-Version é o número da versão, basta escrevê-lo de acordo. A classe principal é o programa de entrada do pacote JAR, que especifica o nome completo da classe Running (deve incluir o nome do pacote). Dessa forma, você pode usar java -jar name.jar para executar o pacote JAR diretamente. O caminho de terceira classe refere-se a outros pacotes JAR que precisam ser confiados ao embalagem. Ao embalagem, seu programa também pode conter outros pacotes JAR, portanto, você precisa adicionar dependências.
Observe que existe um espaço entre o cólon e o conteúdo de cada atributo manifesto, e deve haver uma linha em branco no final após a escrita, caso contrário, ainda haverá um erro no tempo de execução de que o atributo da lista principal não pode ser encontrado.
resumo
The easy thing to make mistakes in packaging jar files is the writing of Manifest manifest files, which are prone to format errors such as few spaces between the colon of the attribute and the content, no spaces between the addition of dependencies in Class-Path, too many dependencies, no spaces at the beginning of each line when writing multiple lines, no blank lines at the end of the file, etc. Pay attention to these key points when writing MANIFEST files, and you won’t spend too much time on packaging.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.