Pag-compile at pagpapatakbo ng Java nang walang IDE

Sa isang pagkakataon sa reddit.com , sa paksang Pag-compile at pagpapatakbo ng Java nang walang IDE , ang tanong ay tinanong: Mayroon bang command na nag-compile ng isang grupo ng mga Java file na nasa loob ng isang package sa isang hiwalay na folder (tawagin natin itong bin ) , at paano ako maglulunsad ng mga bagong file ng klase? " Ang may-akda ng paksa, kylolink , ay nagpapaliwanag: "Nang nagsimula akong gumamit ng Java, umasa ako sa Eclipse na gawin ang lahat ng compilation para sa akin at nag-aalala lang ako sa pagsulat ng code." Nakita ko ang tanong na ito nang maraming beses, at, sa katunayan, ito ang Ano ang nag-udyok sa akin na mag-post sa blog ng mga GPS system at IDE: mabuti o masama? Gustung-gusto ko ang mga makapangyarihang modernong Java IDE at pinapadali nila ang aking buhay araw-araw, ngunit mayroon ding mga benepisyo sa pag-alam kung paano bumuo at magpatakbo ng mga simpleng halimbawa ng Java nang walang kanila. Ang post na ito ay tungkol sa kung paano gawin iyon. Sa aking blog sa pag-aaral ng Java gamit ang mga simpleng pagsubok, isinulat ko kung paano ko minsan gustong gumamit ng simpleng text editor at command line tool upang magsulat, bumuo at magpatakbo ng mga simpleng application. Mayroon akong isang magandang ideya ngayon kung gaano karaming "overhead" ang kailangan ng aking mga paboritong Java IDE at gumawa ng isang maagang desisyon kung ang mga benepisyong nakamit sa pamamagitan ng paggamit ng balangkas ay sapat upang bigyang-katwiran ang "overhead". Sa karamihan ng mga totoong application, walang duda na ang VL IDE ay nagkakahalaga ng malaki. Gayunpaman, para sa pinakasimpleng halimbawa ng mga application, hindi ito palaging nangyayari. Ang natitirang bahagi ng post na ito ay nagpapakita kung paano bumuo at magpatakbo ng Java code nang walang IDE para sa mga sitwasyong ito.

Pagsusulat at Pagpapatupad ng Java Code

Upang gawing mas malinaw ang halimbawa, gagamit ako ng ilang napakasimpleng klase ng Java na nauugnay sa isa't isa sa pamamagitan ng komposisyon o pamana at nasa parehong pakete na tinatawag na dustin.examples . Dalawang klase ang walang function main; ang pangatlong klase, ang Main.java, ay may function mainna nagbibigay-daan sa iyong ipakita kung paano patakbuhin ang klase nang walang IDE. Nasa ibaba ang code para sa tatlong klase na ito: Parent.java

package dustin.examples;

public class Parent
{
   @Override
   public String toString()
   {
      return "I'm the Parent.";
   }
}

Bata.java

package dustin.examples;

public class Child extends Parent
{
   @Override
   public String toString()
   {
      return "I'm the Child.";
   }
}

Main.java

package dustin.examples;

import static java.lang.System.out;

public class Main
{
   private final Parent parent = new Parent();
   private final Child child = new Child();

   public static void main(final String[] arguments)
   {
      final Main instance = new Main();
      out.println(instance.parent);
      out.println(instance.child);
   }
}

Ang sumusunod na screenshot ay nagpapakita ng istraktura ng direktoryo na may mga .java class na ito . Ipinapakita ng screenshot na ang mga source file ay nasa directory hierarchy na kumakatawan sa pangalan ng package ( dustin/examples , dahil ang impormasyon ng package ay dustin.examples ) at ang package na ito ay sumasalamin sa direktoryo Ang hierarchy ay nasa ilalim ng subdirectory na SRC. Gumawa din ako ng subdirectory ng mga klase (na kasalukuyang walang laman) para ilagay ang pinagsama-samang .class na mga file para hindi gagawa ang Javac ng direktoryo na ito kapag wala ito.

Pagbuo gamit ang JAVAC at pagtakbo gamit ang Java

Anuman ang diskarte na ginagamit ng isang tao upang lumikha ng Java code (Ant, Maven, Gradle o IDE), sa wakas ay bumaba ito sa JAVAC. Ang mga karaniwang opsyon sa Oracle/Sun na ibinigay na JAVAC command line tool ay makikita sa pamamagitan ng pagpapatakbo ng JAVAC -help at ang mga karagdagang opsyon sa extension ay maaaring matingnan sa pamamagitan ng pagpapatakbo ng JAVAC -help -X. Higit pang mga detalye kung paano gamitin ang mga opsyong ito ay makikita sa dokumentasyon ng tool ng JAVAC para sa Windows o Unix/Linux. Tulad ng sinasabi ng dokumentasyon ng Javac, ang pagpipiliang -sourcepath ay maaaring gamitin upang ipahayag ang direktoryo kung saan umiiral ang mga source file. Sa istraktura ng aking direktoryo na ipinapakita sa screenshot sa itaas, nangangahulugan ito na, sa pag-aakalang pinapatakbo ko ang utos ng JAVAC mula sa C:\Java\examples\javacAndJava\ direktoryo , kailangan kong magkaroon ng ganito sa aking utos: Javac -sourcepath src SRC\Dustin\mga halimbawa\*. Java . Ang sumusunod na screenshot ay nagpapakita ng mga resulta nito. Dahil hindi kami tumukoy ng direktoryo para sa mga .class na file , inilagay ang mga ito bilang default sa parehong direktoryo gaya ng mga source na .java file kung saan binubuo ang mga ito. Maaari naming gamitin ang opsyon -dupang ayusin ang sitwasyong ito. Ang aming command ay maaaring patakbuhin ngayon, halimbawa, bilang Javac -sourcepath src -d classes src\Dustin\examples\*. Ako ikaw . Tulad ng nabanggit kanina, ang napiling folder (mga klase) ay dapat na umiiral na. Kapag nangyari ito, ilalagay ng command ang mga .class na file sa tinukoy na folder tulad ng ipinapakita sa sumusunod na screenshot Gamit ang mga Java source file na pinagsama-sama sa kaukulang .class na mga file sa tinukoy na direktoryo, maaari naming ilunsad ang application gamit ang mabilisang paglulunsad ng menu ng Java command line tool. Ginagawa lamang ito sa pamamagitan ng pagsunod sa mga tagubiling ibinigay sa mga pahina ng Java -help o Java tools at pagtukoy sa lokasyon ng mga .class na file na may opsyong -classpath( o -cp) . Ang paggamit ng parehong mga diskarte upang tukuyin ang direktoryo ng mga klase kung saan hahanapin ang mga .class na file ay ipinapakita sa sumusunod na screenshot. Ang huling argumento ay ang buong (buong Java package) na pangalan ng klase na may pangunahing function na isasagawa. Ang mga command na ipinakita sa sumusunod na screenshot ay java classes -cp dustin.examples.Main at java classes -classpath dustin.examples.Main.

Pagbuo at Pagtakbo kasama ng Langgam

Para sa pinakasimpleng mga application ng Java, medyo madaling gamitin ang JAVAC at Java upang lumikha at patakbuhin ang application, ayon sa pagkakabanggit, tulad ng ipinakita lamang. Habang ang mga application ay nagiging mas kumplikado (halimbawa, ang code na umiiral sa higit sa isang pakete/direktoryo o mas kumplikadong mga klase ng dependency sa mga third party na library at frameworks), ang diskarteng ito ay maaaring maging mahirap gamitin. Ang Apache Ant ay ang pinakaluma sa "big three" Java build tool at ginamit sa libu-libong mga application at deployment. Tulad ng sinabi ko sa isang nakaraang post sa blog, ang isang napaka-simpleng Ant build file ay madaling gawin, lalo na kung ito ay nagsisimula sa isang template tulad ng binalangkas ko sa post na ito. Ang sumusunod na listahan ng code ay para sa build.xml file ng Ant , na maaaring gamitin upang bumuo ng mga .java file sa .class na mga file at pagkatapos ay patakbuhin ang klase dustin.examples.Main tulad ng ginawa sa itaas sa JAVAC at Java. build.xml

<?xml version="1.0" encoding="UTF-8"?>
<project name="BuildingSansIDE" default="run" basedir=".">
   <description>Building Simple Java Applications Without An IDE</description>

   <target name="compile"
           description="Compile the Java code.">
      <javac srcdir="src"
             destdir="classes"
             debug="true"
      includeantruntime="false" />
   </target>

   <target name="run" depends="compile"
           description="Run the Java application.">
      <java classname="dustin.examples.Main" fork="true">
         <classpath>
           <pathelement path="classes"/>
         </classpath>
      </java>
   </target>
</project>

Hindi ko ginamit ang mga katangian ng Ant at hindi ko isinama ang mga karaniwang layunin na karaniwan kong kasama (tulad ng "pure" at "Javadoc") upang panatilihing simple ang halimbawang ito hangga't maaari at panatilihin itong malapit sa nakaraang halimbawa gamit ang JAVAC at Java . Tandaan din na pinagana ko ang "debug" na nakatakda sa "true" para sa gawain ng JAVAC Ant dahil hindi ito totoo sa kaso ng pagkabigo ng Ant, ngunit totoo ito sa default ng JAVAC. Hindi kataka-taka, ang gawain ng Javac at gawain ng Java Ant ay kahawig ng mga tool sa command ng JAVAC at Java. Dahil ginamit ko ang default na pangalan Inaasahan ng Ant ang isang build file kapag hindi ito malinaw na tinukoy (build.xml) at dahil ibinigay ko ang target na "Run" bilang "default" para sa build na ito at dahil isinama ko ang "compile" bilang isang dependency run ang target na "Run" at dahil si Ant ay nasa landas ng aking kapaligiran, ang kailangan ko lang gawin sa command line ay upang kunin si Ant na mag-compile at patakbuhin ang ant na halimbawa sa direktoryo gamit ang build.xml file . Ito ay ipinapakita sa sumusunod na screenshot. Bagama't nagpakita ako ng pag-compile at pagpapatakbo ng isang simpleng Java application kasama ang Ant, malamang na mag-compile lang ako sa Ant at tumakbo gamit ang Java (o isang script na tumatawag sa Java kung mabigat ang classpath).

Pagbuo at Pagtakbo kasama si Maven

Bagama't ang Ant ay ang unang pangunahing tool sa pagbuo ng Java, sa kalaunan ay nakuha ng Apache Maven ang katanyagan nito higit sa lahat dahil sa pagpapatibay nito ng convention-based na configuration at suporta para sa mga shared library repository. Madaling gamitin ang Maven kapag sinusunod ng code at mga nabuong bagay ang karaniwang layout ng direktoryo nito. Sa kasamaang palad, ang aking halimbawa ay hindi sumusunod sa istraktura ng direktoryo na ito, ngunit pinapayagan kami ng Maven na i-override ang inaasahang default na istraktura ng direktoryo. Ang sumusunod na listahan ay code para sa isang Maven POM file na ginagamit bilang kapalit ng source at target na mga direktoryo at nagbibigay ng iba pang minimum na kinakailangang elemento para sa isang Maven build gamit ang Maven 3.2.1. pom.xml

<project>
   <modelVersion>4.0.0</modelVersion>
   <groupId>dustin.examples</groupId>
   <artifactId>CompilingAndRunningWithoutIDE</artifactId>
   <version>1</version>

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

Dahil ang pom.xml file sa itaas ay tumutukoy sa "defaultGoal" ng "compile" at dahil ang mga pom.xml file ay ang default na POM custom na hinahanap ng Maven executable (MVN) at dahil ang Maven installation bin directory ay nasa aking landas, tanging Kailangan kong patakbuhin ang "MVN " para mag-compile ng .class na mga file tulad ng nabanggit sa sumusunod na screenshot. Maaari ko ring patakbuhin ang pinagsama-samang aplikasyon mula sa Maven gamit ang Mvn Exec command: Java -Dexec.mainClass = dustin.examples.Main , na sinusunod sa sumusunod na screenshot. Tulad ng Ant, madalas kong hindi gamitin ang Maven upang patakbuhin ang aking simpleng Java application, ngunit sa halip ay gumamit ng Java sa pinagsama-samang code (o gumamit ng script na direktang tumatawag sa Java sa mga mahabang tumatakbong klase).

Pagbuo at pagtakbo gamit ang Gradle

Ang Gradle ay ang pinakabago, pinaka-uso, at naka-istilong sa tatlong pangunahing tool sa pagbuo ng Java. Minsan ay nag-aalinlangan ako tungkol sa esensya ng kung ano ang uso, ngunit nakahanap ako ng maraming bagay na gusto tungkol sa Gradle (nakasulat sa Groovy sa halip na XML, built-in na Ant support, built-in na Ivy support, configuration ayon sa convention na madali upang i-reconfigure, suporta sa imbakan ng Maven, at iba pa). Ang sumusunod na halimbawa ay nagpapakita ng isang Gradle build na maaaring magamit upang mag-compile at magpatakbo ng isang simpleng application, na siyang pangunahing sample code para sa post na ito. Iniharap ko ang inangkop na halimbawang ito sa Simple Gradle Java Plugin Customization blog. build.gradle

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

// Redefine where Gradle should expect Java source files (*.java)
sourceSets {
    main {
        java {
            srcDirs 'src'
        }
    }
}

// Redefine where .class files are written
sourceSets.main.output.classesDir = file("classes")

// Specify main class to be executed
mainClassName = "dustin.examples.Main"

defaultTasks 'compileJava', 'run'

Ang unang dalawang linya mula sa build.gradle file ay nagpapahiwatig ng paggamit ng Java plugin at Application plugin, na nagreresulta sa isang grupo ng functionality na awtomatikong binuo sa build na ito. Ang pagtukoy sa "sourceSets" at "sourceSets.main.output.classesDir" ay nagbibigay-daan sa iyo na i-override ang mga default na direktoryo ng Java ng Gradle plugin para sa Java source code at mga pinagsama-samang binary class, ayon sa pagkakabanggit. "MainClassName" ay nagbibigay-daan sa iyo na tahasang tukuyin kung aling klase ang dapat patakbuhin sa loob ng Application plugin. Ang linyang "defaultTasks" ay tumutukoy sa mga gawain na tatakbo sa pamamagitan lamang ng pag-type ng "Gradle" sa command line: 'compileJava' ang default na gawain na ibinigay ng Java plugin at ang 'Run' ay ang default na gawain na ibinigay ng Application plugin. Dahil pinangalanan ko ang mga assemblies na build.gradle at iyon ang dahilan kung bakit tinukoy ko ang mga default na gawain bilang 'compileJava' at 'Run' at dahil mayroon akong direktoryo ng pag-install ng Gradle bin sa aking landas, ang kailangan ko lang gawin upang buuin at patakbuhin ang mga halimbawa ay uri 'Gradle' at ito ay ipinapakita sa sumusunod na screenshot . Kahit na ang pinakamalaking nag-aalinlangan ay dapat aminin na ang mga build ng Gradle ay napakadulas para sa simpleng halimbawang ito. Pinagsasama nito ang pagiging maikli ng pag-asa sa ilang mga kombensiyon at pagpapalagay na may napakadaling mekanismo para sa pag-override ng mga default kung kinakailangan. Ang katotohanan na ito ay nasa Groovy sa halip na XML ay talagang kaakit-akit! Tulad ng sa Ant at Maven, may posibilidad akong bumuo lamang gamit ang mga tool na ito at malamang na magpatakbo ng mga pinagsama-samang .class na file nang direkta mula sa Java o isang script na tumatawag sa Java. Oo nga pala, may posibilidad kong i-archive din ang mga .class na ito sa isang garapon para ilunsad, ngunit lampas iyon sa saklaw ng artikulong ito.

Konklusyon

Ang isang IDE ay madalas na hindi kinakailangan upang bumuo ng mga simpleng application at mga halimbawa at maaaring maging mas mahal kaysa sa gastos upang bumuo ng mga simpleng halimbawa. Sa ganoong kaso, medyo madaling gamitin ang JAVAC at Java upang direktang buuin at patakbuhin ang mga halimbawa. Bilang mga halimbawa ng pagiging mas kasangkot, nagiging mas kaakit-akit ang isang build tool gaya ng Ant, Maven, o Gradle. Ang katotohanan na maraming mga development environment ang sumusuporta sa mga build utilities na ito ay nangangahulugan na ang isang developer ay maaaring lumipat sa IDE gamit ang isang built-in na tool na ginawa nang mas maaga sa proseso kung ito ay natukoy na ang IDE support ay kailangan bilang isang simpleng application ay lumago sa isang ganap na proyekto .