קומפילציה ב-Java

תכנות ב-IDE הוא נהדר: קוהרנטיות של תלות בקוד, איתור באגים נוח, בדיקות ברורות, ערכת נושא כהה. אז, הודות ל-IDE, הפיתוח מתפתח בצעדי ענק. אבל היא נרגעת. בכל יום, כשהוא שוקע בפונקציונליות של ה-IDE, המפתח מתרגל להתחייב עם כפתור אחד או לבנות בשתי לחיצות. המצב הרבה יותר גרוע עם אלה החדשים בתכנות שעובדים ב-IDE מההתחלה, מתעלמים מהעבודה בשורת הפקודה. לדוגמה, ב-Intellij IDEA, הקומפילציה של אפליקציית Java מודגמת על ידי סרגל טעינה בפאנל התחתון, וכל פרמטרי הקומפילציה, עיבוד נתיב class ותענוגות אחרים של חיי Java נשארים מאחורי הקלעים. אנו מציעים לדבר על קומפילציה ב-Java ללא IDE. כדי להפעיל את הדוגמאות במאמר זה, ודא ש-JDK 1.7 ואילך מותקן במחשב שלך.

איך להרכיב תוכנית?

קומפילציה בתכנות היא הפחתת קוד המקור לקוד בתים להתחלה הבאה של התוכנית. רצף הפעולות מקוד המקור ועד להפעלת התוכנית נראה כך:

1. יש קוד מקור בקובץ בשם ClassName.java;
2. אם אין שגיאות בקוד, הוא מקומפל לתוך bytecode (בקובץ ClassName.class);
3. התוכנית מתחילה.

בדרך כלל, כל תוכנית כלולה בספרייה נפרדת. כדוגמה פשוטה, בואו ניקח את הפלט לקונסולה:

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

למה משמשת פקודת javac?

אוקיי, הנקודה הראשונה הסתיימה. בואו נלך רחוק יותר כדי להבין: איך קומפילציה? :) פקודת javac תעזור לנו בכך, שהארגומנט שלה חייב לציין את הקובץ הנדרש:

javac Test.java

אם אין שגיאות בקוד, יופיע קובץ Test.class ליד הקובץ Test.java. זהו קוד הביטים המהודר. עכשיו צריך להשיק אותו. כאן אנו משתמשים בפקודה java, שמריצה את ה-bytecode: צילום המסך מראה שאנו מקבלים כמה הירוגליפים בפלט: ברור שזה קידוד שבור. בדרך כלל זה קורה במערכת Windows. כדי להציג נכון את האלפבית הקירילי בקונסולה, יש את הפקודות הבאות:

REM change CHCP to UTF-8
CHCP 65001
CLS

הם משנים את דף הקוד הנוכחי של המעטפת למשך החלון הנוכחי. בוא ננסה שוב:

D:\Java>java Test

זה מה שהאפליקציה אומרת משורת הפקודה. לדעת כיצד פועלת פקודת javac היא שימושית מאוד, שכן פקודה זו היא הבסיס לכל מערכת בניית פרויקטים.

הידור והרצה של מחלקות מרובות

כדי לעבוד עם מחלקות מרובות אתה צריך נתיב כיתתי. זה דומה למערכת קבצים שבה מחלקות כלולים, וחבילות פועלות כתיקיות. בשלב זה, כדאי לחשוב על הפרדה בין קובצי קוד המקור לקבצי ההידור. ככלל, המקורות ממוקמים בספריית src, והמחלקות הקומפיליות נמצאות ב-bin. לדוגמה, יש לנו מחלקה Boxומחלקה BoxMachineהמכילה מתודה main. מעמד Box:

package src;

public class Box {
   private double size;

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

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

זה בחבילת src, יש לתקן את זה. מעמד 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));
       }
   }
}

מחלקה זו נמצאת גם בחבילת src. בשיטה main, הוא יוצר חמישה אובייקטי מחלקה Boxבגדלים שונים ומציג מידע עליהם לקונסולה. כדי להרכיב קבוצת מחלקות זו, עליך להשתמש בפקודה javac מהספרייה הראשית (המכילה את התיקיות src ו-bin) עם הארגומנטים:

javac -d bin ./src/*

-d- דגל שאחריו עליך לציין את המיקום שאליו יעברו השיעורים המורכבים. זה מאוד נוח, שכן העברת, למשל, 1000 כיתות היא תהליך עתיר עבודה. bin- שם התיקייה. ./src/*- מיקום קבצי המקור. *מציין כי יש להרכיב את כל הקבצים. כעת מופיעות המחלקות הקומפיליות בתיקיית bin. כדי להפעיל אותם, השתמש בפקודה java מאותה ספרייה, גם עם ארגומנטים:

java -classpath ./bin BoxMachine

-classpath- דגל שאחריו עליך לציין את מיקומן של הכיתות המורכבות. Java תחפש את המחלקה הראשית ואת כל המחלקות הקשורות בספרייה זו. ./bin- שם התיקיה שבה ממוקמות המחלקות המורכבות. BoxMachine- שם הכיתה הראשית. כמו במקרה הראשון, אין לציין .class, מכיוון שזהו שם של מחלקה, לא קובץ. סיכום:

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

יצירת קבצי JAR

כדי להפוך את התוכנית לקלה לנייד ולהפעיל, אתה יכול לאסוף את המחלקות הקומפיליות לקובץ jar - ארכיון מחלקות. ההבדל העיקרי מארכיוני zip או rar הוא הנוכחות של קובץ מניפסט. מניפסט זה מציין את המחלקה הראשית שתופעל כאשר קובץ ה-jar יופעל, את ה-classpath ומידע נוסף רב. בואו ניצור קובץ manifest.mf בספרייה הראשית. תוכנו יהיה כדלקמן:

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

main-classמציין את המחלקה המכילה את השיטה mainותבוצע בעת ההפעלה. class-path- נתיב למחלקות הידור או ספריות נוספות. עכשיו הגיע הזמן לבנות תוכנית אמיתית ללא IDE באמצעות הפקודה jar:

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

-cmf- דגל שאחריו עליך לציין את הנתיב לקובץ המניפסט. manifest.mf- נתיב למניפסט. box-machine.jar- שם קובץ jar הפלט. -С- דגל שאחריו מצוין הנתיב למחלקות הקומפילציה. .- הנתיב שבו ימוקם קובץ ה-jar. במקרה שלנו, זו המדריך הראשי. עכשיו אתה יכול להפעיל. הפעלת קובצי jar מתבצעת גם היא באמצעות פקודת java, אבל אז אתה צריך לציין את הדגל -jar: זה מציין שקובץ ה-Jar מופעל, והארגומנט השני הוא הנתיב לקובץ jar, כולל הסיומת :

java -jar box-machine.jar

סיכום:

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

קומפילציה ב-Java ללא IDE: סקירה כללית של מערכות בנייה

למרות הקלות היחסית בשימוש בשורת הפקודה, קשה מאוד לבנות באמצעותה פרויקטים בינוניים וגדולים. זה לוקח הרבה זמן ורצוף בשגיאות בדרגות שונות. למרבה המזל, ישנן מערכות הרכבה שמקלות בהרבה על תהליך העבודה. עם מספר צוותים, מערכת זו יכולה להרכיב פרויקט בכל מורכבות, ושפע התוספים שנוצרו במהלך קיומן של מערכות כאלה יכול להעלים כמעט כל כאב ראש.

איך לקמפל ג'אווה?

מערכות הבנייה המפורסמות ביותר של Java הן Ant, Maven ו- Gradle. אין טוב או רע: כל אחד מהם נוצר כדי לפתור בעיות מסוימות. בואו נסתכל על כל אחד מהם ביתר פירוט.

נְמָלָה

Ant הוא כלי בנייה שמשתמש בסקריפט המתואר באמצעות קובץ xml. מבנה קובץ xml:

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

בואו ניצור קובץ build.xml בספרייה הראשית עם התוכן הבא:

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

באותה ספרייה, קרא לפקודת הנמלה:

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

test:
     [echo] First build in Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

התג <target>יכול לציין משימות שונות המאפשרות לך לנהל את המכלול ומערכת הקבצים. ל-Ant יש למעלה מ-150 פקודות זמינות, המפורטות בתיעוד. בדוגמה למטה אנו משתמשים רק ב-5:

• mkdir - יצירת ספריות
• delete- מחיקת קבצים וספריות
• javac- קומפילציה של קוד Java
• java- הפעלת קוד קומפילציה

כך נראה סקריפט קומפילציה, בנייה או ניקוי פשוט:

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

הסקריפט מתאר שלוש פעולות - compile, ,code>ריצה ו- clean. compileיוצר ספריית תוצאות עם מחלקות בתוכה, ולאחר מכן משתמש ב-javac כדי לקמפל את המחלקות לתוך הספרייה שנוצרה. runמריץ מחלקות קומפילציה עם הפקודה java. cleanמוחק את ספריית התוצאות. אם תפעיל את פקודת הנמלה ללא ארגומנטים בספרייה הראשית, פעולת ההידור תפעל. אם צריך לבצע פעולה מסוימת, היא מצוינת בארגומנט.

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 מציעה גישה שונה במקצת לבניית פרויקטים. כאן היזם דווקא מתאר את הפרויקט שלו ואת הכלים הנוספים שבהם הוא משתמש, בניגוד ל-Ant, שם ה-build הוא רצף של פעולות. Maven פופולרי בקרב מפתחים בשל ניהול התלות הקל והשילוב הנוחה שלו עם כל סביבות הפיתוח. בעבודה עם Maven, אנו מקפידים על מבנה הפרויקט הבא: כללי בנייה, תלות וכו' מתוארים בקובץ pom.xml. בדרך כלל הוא ממוקם בתיקיית הפרויקט הראשית. בעת ההפעלה, Maven בודק את מבנה הקובץ והתחביר, ומזהיר אותך לגבי שגיאות. בספרייה הראשית, ליד התיקיות bin ו-src, צור קובץ pom.xml, הוסף פנימה:

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

לאחר מכן, הפעל את הפקודה mvn בשורת הפקודה:

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

כעת יש תיקיית src בתיקיית bin אשר מכילה את המחלקות הקומפיליות. ב-pom.xml, תג ה-build מגדיר את מטרת ה-build - קומפילציה, את הספריות של קוד המקור וקבצי תוצאות ההידור, כמו גם את שם הפרויקט. ל-Maven יש מגוון יעדי בנייה ותוספים להפעלת בדיקות, יצירת קבצי Jar, בניית הפצות ומשימות אחרות.

גרדל

זוהי מערכת הבנייה הצעירה ביותר, המבוססת על Ant ומייבן. ההבדל העיקרי הוא שהוא עובד על בסיס גרף אציקלי כדי לקבוע את סדר המשימות. זה מאוד שימושי למשימות מורכבות יותר, כגון בנייה מצטברת ומרובת פרויקטים. כאשר בונים עם Gradle, מומלץ גם להיצמד למבנה התיקיות של פרויקט Maven. אגב, הקובץ לבנייה ב-Gradle נקרא build.gradle ונראה הרבה יותר קטן מזה של Maven. דוגמה לשיעורים שלנו:

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

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

mainClassName = "src.BoxMachine"

defaultTasks 'compileJava', 'run'

הקובץ כולל תוספים, מגדיר את ספריית קובצי קוד המקור (אם לא נעשה שימוש במבנה הפרויקט של Maven), ספריית תוצאות הבנייה, שם המחלקה הראשית ומשימות ברירת המחדל. הפקודה gradle בספרייה שבה נמצא הקובץ build.gradle אחראית על התחלת ה-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

סיכום

במבט ראשון, היכולת להרכיב ולהרכיב קוד ללא IDE נראית חסרת תועלת. מה שכן, למה להתעסק בשורות פקודה ולגוגל את כל הפקודות כשיש IDE נעים עם תוספים, בדיקה אוטומטית של כל מה שאפשר (IDE מודרניים לא בודקים רמת IQ) ואינטגרציה עם מערכות פופולריות. עם זאת, התרגול מראה שהיכולת להרכיב קוד ללא סביבת פיתוח והבנת כל שלב בתהליך זה היא הכרח חמור. מיומנות זו תחסוך הרבה תאי עצב וזמן עבורך ועבור החברה שלך. אתה יכול ללמוד כיצד להשתמש ב-IDE, לתרגל כתיבת קוד, וכמובן, לקבל את היסודות של תכנות Java כאן - ב-JavaRush. הגיע הזמן לחזור ללמוד :)