Pag-compile sa Java

Ang pagprograma sa isang IDE ay mahusay: pagkakaugnay ng mga dependency ng code, maginhawang pag-debug, malinaw na pagsubok, madilim na tema. Kaya, salamat sa IDE, ang pag-unlad ay umuunlad nang mabilis. Pero nakakarelax siya. Araw-araw, isawsaw ang kanyang sarili sa functionality ng IDE, nasanay ang developer na mag-commit gamit ang isang button o gusali na may dalawang pag-click. Ang sitwasyon ay mas masahol pa sa mga bago sa programming na nagtatrabaho sa IDE mula pa sa simula, hindi pinapansin ang trabaho sa command line. Halimbawa, sa Intellij IDEA, ang compilation ng isang Java application ay ipinapakita sa pamamagitan ng loading bar sa ilalim na panel, at lahat ng compilation parameters, classpath processing at iba pang kasiyahan ng Java life ay nananatili sa likod ng mga eksena. Iminumungkahi naming pag-usapan ang tungkol sa pag-compile sa Java nang walang IDE. Upang patakbuhin ang mga halimbawa sa artikulong ito, tiyaking naka-install ang JDK 1.7 o mas bago sa iyong makina.

Paano mag-compile ng isang programa?

Ang compilation sa programming ay ang pagbabawas ng source code sa bytecode para sa kasunod na pagsisimula ng programa. Ang pagkakasunud-sunod ng mga aksyon mula sa source code hanggang sa paglulunsad ng programa ay ganito ang hitsura:

1. Mayroong source code sa isang file na tinatawag na ClassName.java;
2. Kung walang mga error sa code, ito ay pinagsama-sama sa bytecode (sa file na ClassName.class);
3. Magsisimula na ang programa.

Karaniwan, ang bawat programa ay nakapaloob sa isang hiwalay na direktoryo. Bilang isang simpleng halimbawa, dalhin natin ang output sa console:

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

Ano ang gamit ng javac command?

Okay, tapos na ang unang punto. Pumunta pa tayo upang maunawaan: paano mag-compile? :) Tutulungan tayo ng javac command dito, ang argumento kung saan dapat tukuyin ang kinakailangang file:

javac Test.java

Kung walang mga error sa code, lalabas ang isang Test.class file sa tabi ng Test.java file. Ito ang pinagsama-samang bytecode. Ngayon ay kailangan itong ilunsad. Dito ginagamit namin ang java command, na nagpapatakbo ng bytecode: Ipinapakita ng screenshot na nakakakuha kami ng ilang hieroglyph sa output: malinaw naman, ito ay isang sirang encoding. Kadalasan nangyayari ito sa isang Windows system. Upang maipakita nang tama ang Cyrillic alphabet sa console, mayroong mga sumusunod na command:

REM change CHCP to UTF-8
CHCP 65001
CLS

Binabago nila ang kasalukuyang pahina ng shell code para sa tagal ng kasalukuyang window. Subukan nating muli:

D:\Java>java Test

Ito ang sinasabi ng application mula sa command line. Ang pag-alam kung paano gumagana ang javac command ay lubhang kapaki-pakinabang, dahil ang utos na ito ay ang batayan ng anumang sistema ng pagbuo ng proyekto.

Pag-compile at Pagpapatakbo ng Maramihang Klase

Upang gumana sa maraming klase kailangan mo ng isang classpath. Ito ay katulad ng isang file system kung saan ang mga klase ay nakapaloob, at ang mga pakete ay kumikilos bilang mga folder. Sa puntong ito, sulit na pag-isipan ang tungkol sa paghihiwalay ng mga source code file mula sa mga pinagsama-samang file. Bilang isang patakaran, ang mga mapagkukunan ay matatagpuan sa direktoryo ng src, at ang mga pinagsama-samang klase ay nasa bin. Halimbawa, mayroon kaming isang klase Boxat isang klase BoxMachinena naglalaman ng isang pamamaraan main. klase Box:

package src;

public class Box {
   private double size;

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

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

Ito ay nasa src package, kailangan itong ayusin. klase 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));
       }
   }
}

Ang klase na ito ay matatagpuan din sa src package. Sa pamamaraan main, lumilikha ito ng limang klase ng mga bagay Boxna may iba't ibang laki at nagpapakita ng impormasyon tungkol sa mga ito sa console. Upang i-compile ang grupong ito ng mga klase, kailangan mong gamitin ang javac command mula sa pangunahing direktoryo (na naglalaman ng src at bin folder) na may mga argumento:

javac -d bin ./src/*

-d— isang bandila pagkatapos kung saan dapat mong ipahiwatig ang lokasyon kung saan pupunta ang mga pinagsama-samang klase. Ito ay napaka-maginhawa, dahil ang paglilipat, halimbawa, ang 1000 mga klase ay isang napakahirap na proseso. bin— pangalan ng folder. ./src/*— lokasyon ng mga source file. *ay nagpapahiwatig na ang lahat ng mga file ay dapat na pinagsama-sama. Ngayon ang mga pinagsama-samang klase ay lilitaw sa folder ng bin. Upang patakbuhin ang mga ito, gamitin ang java command mula sa parehong direktoryo, kasama rin ang mga argumento:

java -classpath ./bin BoxMachine

-classpath— isang bandila pagkatapos kung saan dapat mong ipahiwatig ang lokasyon ng mga pinagsama-samang klase. Hahanapin ng Java ang pangunahing klase at lahat ng nauugnay sa direktoryong ito. ./bin— ang pangalan ng folder kung saan matatagpuan ang mga pinagsama-samang klase. BoxMachine— pangalan ng pangunahing klase. Tulad ng sa unang kaso, hindi dapat tukuyin .class, dahil ito ang pangalan ng isang klase, hindi isang file. Konklusyon:

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

Paglikha ng JAR Files

Upang gawing madaling i-port at patakbuhin ang programa, maaari mong kolektahin ang mga pinagsama-samang klase sa isang jar file - isang archive ng klase. Ang pangunahing pagkakaiba mula sa zip o rar archive ay ang pagkakaroon ng isang manifest file. Tinutukoy ng manifest na ito ang pangunahing klase na tatakbo kapag naisakatuparan ang jar file, ang classpath, at maraming karagdagang impormasyon. Gumawa tayo ng manifest.mf file sa pangunahing direktoryo. Ang mga nilalaman nito ay ang mga sumusunod:

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

main-classtumutukoy sa klase na naglalaman ng pamamaraan mainat isasagawa sa pagsisimula. class-path— landas sa mga pinagsama-samang klase o karagdagang mga aklatan. Ngayon ay oras na upang bumuo ng isang tunay na programa nang walang IDE gamit ang jar command:

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

-cmf— isang bandila pagkatapos kung saan dapat mong tukuyin ang landas sa manifest file. manifest.mf— landas patungo sa manifest. box-machine.jar— pangalan ng output jar file. -С- isang bandila pagkatapos kung saan ang landas sa pinagsama-samang mga klase ay ipinahiwatig. .— ang landas kung saan ilalagay ang jar file. Sa aming kaso, ito ang pangunahing direktoryo. Ngayon ay maaari mong ilunsad. Ang paglulunsad ng mga jar file ay ginagawa din gamit ang java command, ngunit pagkatapos ay kailangan mong tukuyin ang flag -jar: ito ay nagpapahiwatig na ang Jar file ay inilunsad, at ang pangalawang argumento ay ang landas sa jarfile, kasama ang extension :

java -jar box-machine.jar

Konklusyon:

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

Pag-compile sa Java nang walang IDE: Isang Pangkalahatang-ideya ng Mga Build System

Sa kabila ng kamag-anak na kadalian ng paggamit ng command line, napakahirap na bumuo ng daluyan at malalaking proyekto gamit ito. Ito ay tumatagal ng maraming oras at puno ng mga error na may iba't ibang antas. Sa kabutihang palad, may mga sistema ng pagpupulong na ginagawang mas madali ang proseso ng trabaho. Sa ilang mga koponan, ang system na ito ay maaaring mag-assemble ng isang proyekto ng anumang kumplikado, at ang kasaganaan ng mga plugin na nilikha sa panahon ng pagkakaroon ng mga naturang sistema ay maaaring alisin ang halos anumang sakit ng ulo.

Paano mag-compile ng Java?

Ang pinakasikat na Java build system ay Ant, Maven at Gradle. Walang mabuti o masama: bawat isa sa kanila ay nilikha upang malutas ang ilang mga problema. Tingnan natin ang bawat isa sa kanila nang mas detalyado.

Langgam

Ang Ant ay isang build tool na gumagamit ng script na inilarawan gamit ang isang xml file. xml file structure:

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

Gumawa tayo ng build.xml file sa pangunahing direktoryo na may mga sumusunod na nilalaman:

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

Sa parehong direktoryo, tawagan ang ant command:

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

test:
     [echo] First build in Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

Maaaring tukuyin ng tag <target>ang iba't ibang gawain na nagbibigay-daan sa iyong pamahalaan ang assembly at file system. Ang Ant ay may higit sa 150 command na magagamit, na nakalista sa dokumentasyon. Sa halimbawa sa ibaba ginagamit lang namin ang 5:

• mkdir - paglikha ng mga direktoryo
• delete- pagtanggal ng mga file at direktoryo
• javac- Compilation ng Java code
• java- pagpapatakbo ng pinagsama-samang code

Ganito ang hitsura ng isang simpleng compile, build, o cleanup script:

<?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>

Inilalarawan ng script ang tatlong aksyon - compile, ,code>run at clean. compilelumilikha ng isang direktoryo ng resulta na may mga klase sa loob nito, pagkatapos ay gumagamit ng javac upang i-compile ang mga klase sa nilikha na direktoryo. runnagpapatakbo ng mga pinagsama-samang klase gamit ang java command. cleantinatanggal ang direktoryo ng resulta. Kung pinapatakbo mo ang utos ng ant nang walang mga argumento sa pangunahing direktoryo, tatakbo ang pagkilos ng pag-compile. Kung ang isang partikular na aksyon ay kailangang isagawa, ito ay tinukoy sa 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

Nag-aalok ang Maven ng bahagyang naiibang diskarte sa pagbuo ng mga proyekto. Dito, mas inilalarawan ng developer ang kanyang proyekto at ang mga karagdagang tool na ginagamit niya, hindi katulad ng Ant, kung saan ang build ay isang sequence ng mga aksyon. Ang Maven ay sikat sa mga developer dahil sa madaling pamamahala ng dependency at maginhawang pagsasama sa lahat ng development environment. Kapag nagtatrabaho sa Maven, sinusunod namin ang sumusunod na istraktura ng proyekto: Ang mga panuntunan sa pagbuo, dependency, atbp. ay inilalarawan sa pom.xml file. Kadalasan ito ay matatagpuan sa pangunahing folder ng proyekto. Sa pagsisimula, sinusuri ni Maven ang istraktura ng file at syntax, na nagbabala sa iyo tungkol sa mga error. Sa pangunahing direktoryo, sa tabi ng bin at src folder, lumikha ng isang pom.xml file, idagdag sa loob:

<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>

Susunod, patakbuhin ang mvn command sa command line:

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] ------------------------------------------------------------------------

Ngayon ay mayroong isang src folder sa bin folder na naglalaman ng mga pinagsama-samang klase. Sa pom.xml, tinutukoy ng build tag ang layunin ng build - compilation, ang mga direktoryo ng source code at mga file ng resulta ng compilation, pati na rin ang pangalan ng proyekto. Ang Maven ay may iba't ibang mga build target at plugin para sa pagpapatakbo ng mga pagsubok, paggawa ng mga Jar file, pagbuo ng mga pamamahagi, at iba pang mga gawain.

Gradle

Ito ang pinakabatang build system, na batay sa Ant at Maven. Ang pangunahing pagkakaiba ay gumagana ito batay sa isang acyclic graph upang matukoy ang pagkakasunud-sunod ng mga gawain. Ito ay lubhang kapaki-pakinabang para sa mas kumplikadong mga gawain, tulad ng mga incremental at multi-project build. Kapag nagtatayo gamit ang Gradle, inirerekomenda din na manatili sa istraktura ng folder ng proyekto ng Maven. Sa pamamagitan ng paraan, ang file para sa pagbuo sa Gradle ay tinatawag na build.gradle at mukhang mas maliit kaysa sa Maven. Halimbawa para sa aming mga klase:

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

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

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

Ang file ay naglalaman ng mga plugin, ang kahulugan ng source code file directory (kung ang Maven project structure ay hindi ginagamit), ang build results directory, ang pangalan ng pangunahing klase, at mga default na gawain. Ang gradle command sa direktoryo kung saan matatagpuan ang build.gradle file ay responsable para sa pagsisimula ng build:

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

Konklusyon

Sa unang sulyap, ang kakayahang mag-compile at mag-ipon ng code na walang IDE ay tila walang silbi. Sa katunayan, bakit mag-abala sa mga command line at Google sa lahat ng mga utos kung mayroong isang maginhawang IDE na may mga plugin, awtomatikong pagsuri sa lahat ng posible (hindi sinusuri ng mga modernong IDE ang antas ng IQ) at pagsasama sa mga sikat na system. Gayunpaman, ipinapakita ng pagsasanay na ang kakayahang mag-assemble ng code nang walang development environment at pag-unawa sa bawat hakbang ng prosesong ito ay isang matinding pangangailangan. Ang kasanayang ito ay magse-save ng maraming nerve cell at oras para sa iyo at sa iyong kumpanya. Maaari mong makabisado ang IDE, magsanay sa pagsusulat ng code, at, siyempre, makuha ang mga pangunahing kaalaman ng Java programming dito - sa JavaRush. Oras na para bumalik sa pag-aaral :)