Compilando em Java

Programar em um IDE é ótimo: coerência de dependências de código, depuração conveniente, testes claros, tema escuro. Portanto, graças ao IDE, o desenvolvimento está se desenvolvendo aos trancos e barrancos. Mas ela relaxa. Todos os dias, mergulhando nas funcionalidades do IDE, o desenvolvedor se acostuma a comprometer com um botão ou construir com dois cliques. A situação é muito pior para quem é novo em programação e trabalha no IDE desde o início, ignorando o trabalho na linha de comando. Por exemplo, no Intellij IDEA, a compilação de um aplicativo Java é demonstrada por uma barra de carregamento no painel inferior, e todos os parâmetros de compilação, processamento de caminho de classe e outras delícias da vida Java permanecem nos bastidores. Sugerimos falar sobre compilar em Java sem IDE. Para executar os exemplos deste artigo, certifique-se de que o JDK 1.7 ou posterior esteja instalado em sua máquina.

Como compilar um programa?

Compilação em programação é a redução do código-fonte em bytecode para o posterior início do programa. A sequência de ações desde o código-fonte até o lançamento do programa é semelhante a esta:

1. Existe o código-fonte em um arquivo chamado ClassName.java;
2. Se não houver erros no código, ele é compilado em bytecode (no arquivo ClassName.class);
3. O programa é iniciado.

Normalmente, cada programa está contido em um diretório separado. Como exemplo simples, vamos levar a saída para o console:

class Test {
   public static void main(String[] args) {
      System.out.println("Это говорит приложение из командной строки");
   }
}

Para que é usado o comando javac?

Ok, o primeiro ponto está feito. Vamos mais longe para entender: como compilar? :) O comando javac nos ajudará nisso, cujo argumento deve especificar o arquivo necessário:

javac Test.java

Se não houver erros no código, um arquivo Test.class aparecerá próximo ao arquivo Test.java. Este é o bytecode compilado. Agora ele precisa ser lançado. Aqui usamos o comando java, que executa o bytecode: A captura de tela mostra que obtemos alguns hieróglifos na saída: obviamente, esta é uma codificação quebrada. Normalmente isso acontece em um sistema Windows. Para exibir corretamente o alfabeto cirílico no console, existem os seguintes comandos:

REM change CHCP to UTF-8
CHCP 65001
CLS

Eles alteram a página de código do shell atual durante a janela atual. Vamos tentar de novo:

D:\Java>java Test

Isso é o que o aplicativo diz na linha de comando. Saber como funciona o comando javac é muito útil, pois este comando é a base de qualquer sistema de construção de projeto.

Compilando e executando múltiplas classes

Para trabalhar com múltiplas classes você precisa de um classpath. É semelhante a um sistema de arquivos no qual as classes estão contidas e os pacotes atuam como pastas. Neste ponto, vale a pena pensar em separar os arquivos de código-fonte dos arquivos compilados. Via de regra, os fontes estão localizados no diretório src e as classes compiladas estão em bin. Por exemplo, temos uma classe Boxe uma classe BoxMachineque contém um método main. Aula Box:

package src;

public class Box {
   private double size;

   public Box(double size) {
       this.size = size;
   }

   public String toString() {
       return "Box have size " + size;
   }
}

Está no pacote src e precisa ser corrigido. Aula BoxMachine:

package src;

public class BoxMachine {
   public static void main(String[] args) {
       for(int  i = 0; i < 5; i++) {
           System.out.println(new Box(Math.random()*10));
       }
   }
}

Esta classe também é encontrada no pacote src. No método main, ele cria cinco objetos de classe Boxde tamanhos diferentes e exibe informações sobre eles no console. Para compilar este grupo de classes, é necessário utilizar o comando javac do diretório principal (que contém as pastas src e bin) com os argumentos:

javac -d bin ./src/*

-d— um sinalizador após o qual você deve indicar o local para onde as classes compiladas irão. Isso é muito conveniente, pois a transferência, por exemplo, de 1.000 turmas é um processo muito trabalhoso. bin- nome da pasta. ./src/*— localização dos arquivos de origem. *indica que todos os arquivos devem ser compilados. Agora as classes compiladas aparecem na pasta bin. Para executá-los, utilize o comando java do mesmo diretório, também com argumentos:

java -classpath ./bin BoxMachine

-classpath— um sinalizador após o qual você deve indicar a localização das classes compiladas. Java irá procurar a classe principal e todas as relacionadas neste diretório. ./bin— o nome da pasta na qual as classes compiladas estão localizadas. BoxMachine— nome da classe principal. Como no primeiro caso, não deve ser especificado .class, pois é o nome de uma classe e não de um arquivo. Conclusão:

D:\Java>java -classpath ./bin src.BoxMachine
Box have size 4.085985295359718
Box have size 8.63682158248986
Box have size 6.027448124299726
Box have size 7.288317703877914
Box have size 1.106181659384694

Criando arquivos JAR

Para tornar o programa fácil de portar e executar, você pode coletar as classes compiladas em um arquivo jar - um arquivo de classe. A principal diferença dos arquivos zip ou rar é a presença de um arquivo de manifesto. Este manifesto especifica a classe principal que será executada quando o arquivo jar for executado, o caminho de classe e muitas informações adicionais. Vamos criar um arquivo manifest.mf no diretório principal. Seu conteúdo será o seguinte:

main-class: src.BoxMachine
class-path: bin/

main-classespecifica a classe que contém o método maine será executada na inicialização. class-path— caminho para classes compiladas ou bibliotecas adicionais. Agora é hora de construir um programa real sem IDE usando o comando jar:

jar -cmf manifest.mf box-machine.jar  -C bin .

-cmf— um sinalizador após o qual você deve especificar o caminho para o arquivo de manifesto. manifest.mf– caminho para o manifesto. box-machine.jar— nome do arquivo jar de saída. -С— um sinalizador após o qual o caminho para as classes compiladas é indicado. .— o caminho onde o arquivo jar será colocado. No nosso caso, este é o diretório principal. Agora você pode lançar. O lançamento de arquivos jar também é feito usando o comando java, mas então você precisa especificar o sinalizador -jar: indica que o arquivo Jar está sendo iniciado, e o segundo argumento é o caminho para jaro arquivo, incluindo a extensão :

java -jar box-machine.jar

Conclusão:

Box have size 5.5495235762547965
Box have size 9.695870044165662
Box have size 2.3408385788129227
Box have size 7.2790741216674135
Box have size 2.3620854470160513

Compilando em Java sem IDE: uma visão geral dos sistemas de construção

Apesar da relativa facilidade de uso da linha de comando, é muito difícil construir projetos de médio e grande porte utilizando-a. Isso leva muito tempo e está repleto de erros de vários graus. Felizmente, existem sistemas de montagem que facilitam muito o processo de trabalho. Com diversas equipes, esse sistema pode montar um projeto de qualquer complexidade, e a abundância de plugins criados durante a existência de tais sistemas pode eliminar quase qualquer dor de cabeça.

Como compilar Java?

Os sistemas de construção Java mais famosos são Ant, Maven e Gradle. Não existe bom ou mau: cada um deles é criado para resolver determinados problemas. Vejamos cada um deles com mais detalhes.

Formiga

Ant é uma ferramenta de construção que usa um script descrito em um arquivo xml. estrutura do arquivo xml:

<?xml version="1.0"?>
<project name="NameПроекта" default="сценарийПоУмолчанию">
    <target name="NameСценария">
  //  Действия сценария
        <echo>Hello, World!</echo>
    </target>
  //  Второй сценарий
  //  И тд
</project>

Vamos criar um arquivo build.xml no diretório principal com o seguinte conteúdo:

<?xml version="1.0"?>
<project name="BoxMachine" default="test">
   <target name="test">
       <echo>First build in Ant!</echo>
   </target>
</project>

No mesmo diretório, chame o comando ant:

D:\Java>D:\Temp\ant\bin\ant
Buildfile: D:\Java\build.xml

test:
     [echo] First build in Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

A tag <target>pode especificar várias tarefas que permitem gerenciar a montagem e o sistema de arquivos. Ant tem mais de 150 comandos disponíveis, que estão listados na documentação. No exemplo abaixo usamos apenas 5:

• mkdir - criando diretórios
• delete- exclusão de arquivos e diretórios
• javac- Compilação de código Java
• java- executando código compilado

Esta é a aparência de um script simples de compilação, construção ou limpeza:

<?xml version="1.0"?>
<project name="BoxMachine" default="compile">
   <target name="compile">
       <mkdir dir="result/classes"/>
       <javac destdir="result/classes" includeantruntime="false">
           <src path="src"/>
       </javac>
   </target>
   <target name="run" depends="compile">
       <java classname="BoxMachine" classpath="result/classes"/>
   </target>
   <target name="clean">
       <delete dir="result"/>
   </target>
</project>

O script descreve três ações - compile, ,code>run e clean. compilecria um diretório de resultados com classes e usa javac para compilar as classes no diretório criado. runexecuta as classes compiladas com o comando java. cleanexclui o diretório de resultados. Se você executar o comando ant no diretório principal sem nenhum argumento, a ação de compilação será executada. Se uma ação específica precisar ser executada, ela será especificada no argumento.

D:\Java>D:/Temp/ant/bin/ant compile
Buildfile: D:\Java\build.xml

compile:
    [mkdir] Created dir: D:\Java\result\classes
    [javac] Compiling 2 source files to D:\Java\result\classes

BUILD SUCCESSFUL
Total time: 1 second

Maven

Maven oferece uma abordagem ligeiramente diferente para projetos de construção. Aqui, o desenvolvedor descreve seu projeto e as ferramentas adicionais que utiliza, ao contrário do Ant, onde a construção é uma sequência de ações. Maven é popular entre os desenvolvedores devido ao seu fácil gerenciamento de dependências e integração conveniente com todos os ambientes de desenvolvimento. Ao trabalhar com Maven, seguimos a seguinte estrutura de projeto: regras de construção, dependências, etc. são descritas no arquivo pom.xml. Normalmente ele está localizado na pasta principal do projeto. Na inicialização, o Maven verifica a estrutura e a sintaxe do arquivo, avisando sobre erros. No diretório principal, próximo às pastas bin e src, crie um arquivo pom.xml, adicione dentro:

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>ru.javarush.testmaven</groupId>
  <artifactId>testMavenWithoutIde</artifactId>
  <version>1.0.0</version>

  <build>
     <defaultGoal>compile</defaultGoal>
     <sourceDirectory>src</sourceDirectory>
     <outputDirectory>bin</outputDirectory>
     <finalName>${project.artifactId}-${project.version}</finalName>
  </build>
</project>

Em seguida, execute o comando mvn na linha de comando:

D:\Java>mvn
[INFO] Scanning for projects...
[INFO]
[INFO] -------------< ru.javarush.testmaven:testMavenWithoutIde >--------------
[INFO] Building testMavenWithoutIde 1.0.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ testMavenWithoutIde ---
[WARNING] Using platform encoding (Cp1251 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory D:\Java\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ testMavenWithoutIde ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1251, i.e. build is platform dependent!
[INFO] Compiling 2 source files to D:\Java\bin
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 15.521 s
[INFO] Finished at: 2019-06-25T20:18:05+03:00
[INFO] ------------------------------------------------------------------------

Agora existe uma pasta src na pasta bin onde as classes compiladas estão localizadas. Em pom.xml, a tag build define a finalidade da compilação - compilação, os diretórios do código-fonte e dos arquivos de resultado da compilação, bem como o nome do projeto. O Maven tem uma variedade de alvos de construção e plug-ins para executar testes, criar arquivos Jar, construir distribuições e outras tarefas.

Gradle

Este é o sistema de compilação mais recente, baseado em Ant e Maven. A principal diferença é que funciona com base em um gráfico acíclico para determinar a ordem das tarefas. Isso é muito útil para tarefas mais complexas, como compilações incrementais e de vários projetos. Ao construir com Gradle, também é recomendado seguir a estrutura de pastas do projeto Maven. A propósito, o arquivo para construção no Gradle é chamado build.gradle e parece muito menor que o do Maven. Exemplo para nossas aulas:

apply plugin: 'java'
apply plugin: 'application'

sourceSets {
   main {
       java {
           srcDirs 'src'
       }
   }
}
sourceSets.main.output.classesDir = file("bin")

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

O arquivo contém plug-ins, a definição do diretório do arquivo de código-fonte (se a estrutura do projeto Maven não for usada), o diretório de resultados da construção, o nome da classe principal e tarefas padrão. O comando gradle no diretório onde o arquivo build.gradle está localizado é responsável por iniciar a compilação:

d:\Java>D:\Temp\gradle\bin\gradle

Welcome to Gradle 5.4.1!

Here are the highlights of this release:
 - Run builds with JDK12
 - New API for Incremental Tasks
 - Updates to native projects, including Swift 5 support

For more details see https://docs.gradle.org/5.4.1/release-notes.html

Starting a Gradle Daemon (subsequent builds will be faster)

> Task :help

Welcome to Gradle 5.4.1.

To run a build, run gradle <task> ...

To see a list of available tasks, run gradle tasks

To see a list of command-line options, run gradle --help

To see more detail about a task, run gradle help --task <task>

For troubleshooting, visit https://help.gradle.org

BUILD SUCCESSFUL in 52s
1 actionable task: 1 executed

Conclusão

À primeira vista, a capacidade de compilar e montar código sem um IDE parece inútil. Na verdade, por que se preocupar com linhas de comando e todos os comandos do Google quando existe um IDE aconchegante com plug-ins, verificação automática de tudo o que é possível (IDEs modernos não verificam o nível de QI) e integração com sistemas populares. No entanto, a prática mostra que a capacidade de montar código sem um ambiente de desenvolvimento e compreender cada etapa desse processo é uma necessidade extrema. Essa habilidade economizará muitas células nervosas e tempo para você e sua empresa. Você pode aprender como usar o IDE, praticar a escrita de código e, claro, obter os fundamentos da programação Java aqui - no JavaRush. É hora de voltar a aprender :)