இந்த பொருள் "நிறுவன மேம்பாட்டிற்கான அறிமுகம்" தொடரின் ஒரு பகுதியாகும். முந்தைய கட்டுரைகள்: பகுதி 4. மேவனின் அடிப்படைகள் - 1மேவன் என்பது திட்டங்களை நிர்வகிப்பதற்கும் உருவாக்குவதற்கும் ஒரு கருவியாகும் - ஜாவா புரோகிராமரின் உதவியாளர். இது வேலையின் ஒவ்வொரு கட்டத்திலும் டெவலப்பர்களுக்கு வாழ்க்கையை எளிதாக்குகிறது: திட்ட கட்டமைப்பை உருவாக்குவது மற்றும் தேவையான நூலகங்களை இணைப்பது முதல் தயாரிப்பை சேவையகத்தில் வரிசைப்படுத்துவது வரை. எந்தவொரு கட்டமைப்பிலும் பணிபுரியும் போது நீங்கள் Maven ஐப் பயன்படுத்த வேண்டும். எனவே, இன்று அதன் முக்கிய செயல்பாடுகளைப் பார்ப்போம், அவற்றை எவ்வாறு பயன்படுத்துவது என்பதைப் பார்ப்போம்.

Maven இன் படிப்படியான நிறுவல்

  1. முதலில், நாம் Maven ஐ நிறுவ வேண்டும். இந்த இணைப்பில் இருந்து பதிவிறக்கவும் .

  2. அடுத்து, பதிவிறக்கம் செய்யப்பட்ட காப்பகத்தை அன்ஜிப் செய்து, அன்ஜிப் செய்யப்பட்ட காப்பகத்தின் இடத்திற்கு M2_HOME சூழல் மாறியை அமைக்கவும். எடுத்துக்காட்டாக, C:\\Program Files\\maven\\

  3. அனைத்தும் நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்த, கட்டளை வரியில் பின்வருவனவற்றை இயக்கவும்:

    mvn - பதிப்பு

  4. மேவன், ஜாவா போன்றவற்றுக்கான பதிப்புத் தகவல் காட்டப்பட்டால், எல்லாம் தயாராக உள்ளது.

  5. இப்போது IntelliJ IDEA ஐத் திறந்து புதிய திட்டத்தை உருவாக்கவும். முதல் சாளரத்தில், Maven என்பதைத் தேர்ந்தெடுக்கவும்:

    பகுதி 4. மேவனின் அடிப்படைகள் - 2

  6. "அடுத்து" என்பதைக் கிளிக் செய்து, தோன்றும் சாளரத்தை நிரப்பவும்:

    பகுதி 4. மேவனின் அடிப்படைகள் - 3

  7. பின்னர், வழக்கம் போல், நீங்கள் விரும்பும் இடத்தில் ஒரு திட்டத்தை உருவாக்கவும்.

    திட்டம் உருவாக்கப்பட்ட பிறகு, அதன் கட்டமைப்பைக் கவனியுங்கள்:

    பகுதி 4. மேவனின் அடிப்படைகள் - 4
இது ஒரு மேவன் திட்டத்தின் நிலையான அமைப்பு :
  • src /main/java கோப்புறையில் ஜாவா வகுப்புகள் உள்ளன
  • src /main/resources கோப்புறையில் பயன்பாடு பயன்படுத்தும் ஆதாரங்கள் உள்ளன (HTML பக்கங்கள், படங்கள், நடை தாள்கள் போன்றவை)
  • src /test கோப்புறை சோதனைகளுக்கானது
pom.xml எனப்படும் கோப்பிலும் கவனம் செலுத்துங்கள் . Maven ஐ நிர்வகிப்பதற்கான முக்கிய கோப்பு இதுவாகும் . முழு திட்ட விளக்கமும் இங்கே உள்ளது. இந்த நேரத்தில் அதிக தகவல்கள் இல்லை, ஆனால் அதை இப்போது சேர்ப்போம்.

மேவெனில் சார்புகளை நிர்வகித்தல்

"சார்பு மேலாளர்" என்ற சொற்றொடரை நீங்கள் கண்டிருக்கலாம். சார்புகளை எவ்வாறு நிர்வகிப்பது என்பது மேவனுக்குத் தெரியும். மேவனுக்கு நன்றி, இணையத்தில் தேவையான நூலகத்தைத் தேடுவதற்கும், அதைப் பதிவிறக்குவதற்கும், பின்னர் அதை உங்கள் திட்டத்துடன் இணைப்பதற்கும் அதிக நேரம் செலவிட வேண்டியதில்லை. அதற்கு பதிலாக, நீங்கள் Maven இல் உள்ள சார்புகளின் பட்டியலில் தேவையான நூலகத்தைச் சேர்க்கவும்.

சார்புகள் pom.xml கோப்பின் சார்பு முனையில் குறிப்பிடப்பட்டுள்ளன

கோப்புகளுடன் வேலை செய்வதை எளிதாக்க உங்கள் திட்டத்தில் அப்பாச்சி காமன்ஸ் ஐஓ நூலகம் தேவை என்று வைத்துக்கொள்வோம். ஒரு நூலகத்தைச் சேர்க்க, pom.xml இல் ஐந்து வரிகளை எழுதுகிறோம்: 

<dependency>
   <groupId>commons-io</groupId>
   <artifactId>commons-io</artifactId>
   <version>2.6</version>
</dependency>
இப்போது உங்கள் pom.xml கோப்பு இப்படி இருக்க வேண்டும்: 

  <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>example.com</groupId>
   <artifactId>example</artifactId>
   <version>1.0-SNAPSHOT</version>

   <dependencies>
       <dependency>
           <groupId>commons-io</groupId>
           <artifactId>commons-io</artifactId>
           <version>2.6</version>
       </dependency>
   </dependencies>
</project>
அதன் பிறகு, சார்புநிலையை இறக்குமதி செய்ய IntelliJ IDEA ஐ அனுமதிக்கவும் (ஒரு உரையாடல் கீழ் வலது மூலையில் தோன்றும்). இப்போது நூலகம் பயன்படுத்த தயாராக உள்ளது: 

import org.apache.commons.io.FileUtils;

import java.io.File;

public class TestMaven {
   public static void main(String[] args) {
       File tempDirectory = FileUtils.getTempDirectory();
   }
}
அனைத்து அடுத்தடுத்த சார்புகளும் குறிச்சொல்லின் உள்ளே எழுதப்பட வேண்டும் <dependencies>. குறிச்சொல்லின் உள்ளே நீங்கள் குறிப்பிட வேண்டிய நூலகத்தைப் பற்றிய தகவலை எவ்வாறு கண்டுபிடிப்பது என்று நீங்கள் யோசித்துக்கொண்டிருக்கலாம் <dependency>. அது எளிமையானது. மூன்று அளவுருக்கள் எப்போதும் அமைக்கப்பட வேண்டும்: "groupId", "artifactId" மற்றும் "version". இந்த அளவுருக்களை தீர்மானிக்க இரண்டு வழிகள் உள்ளன:

  1. நூலகத்தின் இணையதளத்தில். எங்களுக்கு Apache Commons IO நூலகம் தேவைப்பட்டால், அதிகாரப்பூர்வ வலைத்தளத்திற்குச் சென்று "சார்பு தகவல்" தாவலைத் தேர்ந்தெடுக்கவும். தேவையான அனைத்து தகவல்களும் இங்கே உள்ளன - நீங்கள் அதை நகலெடுத்து முனையில் சேர்க்கலாம் <dependencies>.

  2. ஒரு மேவன் களஞ்சியத்தில் . தேடல் பட்டியில் "apache Commons io" ஐ உள்ளிடவும், நூலகத்தின் அனைத்து பதிப்புகளையும் நீங்கள் காண்பீர்கள். சரியானதைத் தேர்ந்தெடுத்த பிறகு, பின்வருவனவற்றை நகலெடுக்கவும்:

    
<dependency>
           <groupId>commons-io</groupId>
           <artifactId>commons-io</artifactId>
           <version>2.6</version>
       </dependency>

    அதை உங்கள் pom.xml இல் சேர்க்கவும்.

மேவன் களஞ்சியங்களின் வகைகள்

மேவன் களஞ்சியங்களை மீண்டும் குறிப்பிடுவது பயனுள்ளது, ஏனென்றால் எங்களிடம் உண்மையில் இரண்டு உள்ளன: தொலைநிலை (மத்திய) களஞ்சியம் மற்றும் உள்ளூர் (உங்கள் கணினியில்) களஞ்சியம். உங்கள் திட்டப்பணிகளில் நீங்கள் சேர்க்கும் அனைத்து நூலகங்களும் உள்ளூர் களஞ்சியத்தில் சேமிக்கப்படும். ஒரு திட்டத்திற்கு தேவையான சார்புநிலையை Maven சேர்க்கும் போது, ​​நூலகம் ஏற்கனவே உள்ளூர் களஞ்சியத்தில் உள்ளதா என்பதை முதலில் சரிபார்க்கிறது. உள்நாட்டில் நூலகத்தைக் காணவில்லை என்றால் மட்டுமே அது தொலை களஞ்சியத்தை அணுகும். நீங்கள் பார்க்க முடியும் என, சார்புகளைச் சேர்க்க நீங்கள் Maven ஐப் பயன்படுத்தலாம், ஆனால் இது எல்லாம் செய்ய முடியாது.

மேவனைப் பயன்படுத்தி ஜாவா திட்டத்தை உருவாக்குதல்

இந்த திறன் ஒரு தொடக்கக்காரருக்கு அர்த்தமற்றதாகத் தோன்றலாம். எங்களிடம் ஒரு IDE இருந்தால் இது ஏன் தேவை? என்னை விவரிக்க விடு. முதலில், உங்கள் பயன்பாட்டை உருவாக்க வேண்டிய சேவையகத்தில் வளர்ச்சி சூழல் அல்லது வரைகலை இடைமுகம் இல்லாமல் இருக்கலாம். இரண்டாவதாக, பெரிய திட்டங்களில், மேவன் திட்டத்தை உருவாக்குவதற்கான சிறந்த வேலையைச் செய்கிறார். எனவே மேலும் விடைபெறாமல், மேவனைப் பயன்படுத்தி ஒரு பயன்பாட்டை உருவாக்கும் செயல்முறையை நாங்கள் கருத்தில் கொள்வோம்.

கட்டங்கள்

ஒரு பயன்பாட்டை உருவாக்கும் செயல்முறை மேவன் திட்டத்தின் வாழ்க்கைச் சுழற்சியாக அறியப்படுகிறது, மேலும் இது கட்டங்களைக் கொண்டுள்ளது. மேல் வலது மூலையில் உள்ள Maven > example > Lifecycle என்பதைக் கிளிக் செய்வதன் மூலம் IDEA இல் அவற்றைப் பார்க்கலாம்: பகுதி 4. மேவனின் அடிப்படைகள் - 5நீங்கள் பார்க்க முடியும் என, 9 கட்டங்கள் உள்ளன:
  1. சுத்தமான - இலக்கு கோப்பகத்தில் இருந்து தொகுக்கப்பட்ட அனைத்து கோப்புகளையும் நீக்குகிறது (முடிக்கப்பட்ட கலைப்பொருட்கள் சேமிக்கப்படும் இடம்)
  2. சரிபார்க்க - திட்டத்தை உருவாக்க தேவையான அனைத்து தகவல்களும் உள்ளதா என்பதை சரிபார்க்கிறது
  3. compile — மூல குறியீடு கோப்புகளை தொகுக்கிறது
  4. சோதனை - சோதனைகளைத் தொடங்குகிறது
  5. தொகுப்பு — தொகுப்புகள் தொகுக்கப்பட்ட கோப்புகள் (JAR, WAR, முதலியன காப்பகத்தில்)
  6. verify — தொகுக்கப்பட்ட கோப்பு தயாராக உள்ளதா என்பதை சரிபார்க்கிறது
  7. நிறுவு — தொகுப்பை உள்ளூர் களஞ்சியத்தில் வைக்கிறது. இப்போது அதை மற்ற திட்டங்களால் வெளிப்புற நூலகமாகப் பயன்படுத்தலாம்
  8. தளம் - திட்ட ஆவணங்களை உருவாக்குகிறது
  9. deploy — கட்டப்பட்ட காப்பகத்தை தொலை களஞ்சியத்திற்கு நகலெடுக்கிறது
அனைத்து கட்டங்களும் தொடர்ச்சியாக செய்யப்படுகின்றன: எடுத்துக்காட்டாக, 1-3 கட்டங்கள் முடியும் வரை நான்காவது கட்டத்தை தொடங்க முடியாது. ஒரு கட்டத்தைத் தொடங்க இரண்டு வழிகள் உள்ளன:

  • கட்டளை வரி மூலம்:

    mvn தொகுப்பு

    பகுதி 4. மேவனின் அடிப்படைகள் - 6

  • IntelliJ ஐடியாவைப் பயன்படுத்துதல்:

    பகுதி 4. மேவனின் அடிப்படைகள் - 7

    தொகுப்பு கட்டம் தொடங்கும் முன், சரிபார்த்தல், தொகுத்தல் மற்றும் சோதனை கட்டங்கள் செய்யப்படுகின்றன. சுத்தமான கட்டம் ஒரு விதிவிலக்கு. திட்டத்தின் ஒவ்வொரு கட்டத்திற்கும் முன் இந்த கட்டத்தை இயக்குவது நல்லது. நீங்கள் பல கட்டங்களை பட்டியலிடலாம், அவற்றை இடைவெளிகளுடன் பிரிக்கலாம்:

    mvn சுத்தமான தொகுப்பு.

மேலும், ஒவ்வொரு கட்டத்திற்கும் முன் மற்றும் பிந்தைய கட்டங்கள் உள்ளன: எடுத்துக்காட்டாக, முன்-வரிசைப்படுத்துதல், பின்-வரிசைப்படுத்துதல், முன்-சுத்தம், பிந்தைய சுத்தம் போன்றவை. ஆனால் அவை மிகவும் அரிதாகவே பயன்படுத்தப்படுகின்றன. கூடுதலாக, ஒவ்வொரு கட்டத்திற்கும் இலக்குகள் உள்ளன. நிலையான இலக்குகள் இயல்பாகவே அமைக்கப்படும். மேவன் செருகுநிரல்களால் கூடுதல் இலக்குகள் சேர்க்கப்படுகின்றன. சில நேரங்களில் ஒரு கட்டத்தில், நீங்கள் கூடுதல் செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும். இதற்கு Maven செருகுநிரல்கள் உள்ளன. அதிகாரப்பூர்வ செருகுநிரல்களின் பட்டியலை Maven இணையதளத்தில் காணலாம் . ஆனால் மூன்றாம் தரப்பு வலைத்தளங்களில் பல தனிப்பயன் செருகுநிரல்கள் உள்ளன என்பதை நீங்கள் அறிந்திருக்க வேண்டும். நிச்சயமாக, சில கவர்ச்சியான தேவைகள் ஏற்பட்டால், நீங்கள் எப்போதும் தனிப்பயன் செருகுநிரலை நீங்களே எழுதலாம் .

செருகுநிரல்கள்

திட்டத்தில் ஒரு Maven செருகுநிரலைச் சேர்க்க, அதன் விளக்கத்தை நாம் pom.xml கோப்பில் சேர்க்க வேண்டும், பயன்படுத்துதல் <build>மற்றும் <plugins>குறிச்சொற்கள், சார்புகளை எவ்வாறு சேர்த்தோம் என்பது போன்றது. எடுத்துக்காட்டாக, எங்களின் அனைத்து வெளிப்புற நூலகங்களின் சமீபத்திய பதிப்பைப் பயன்படுத்துகிறோம் என்பதைச் சரிபார்க்க ஒரு செருகுநிரல் தேவை என்று வைத்துக்கொள்வோம். இணையத்தில் சிறிது நேரம் தேடிய பிறகு, இந்தச் செருகுநிரலையும் அதை எப்படிப் பயன்படுத்துவது என்பதற்கான வழிமுறைகளையும் காணலாம் . groupId, artifactId மற்றும் பதிப்பை அமைப்போம். செருகுநிரல் என்ன இலக்குகளை நிறைவேற்ற வேண்டும் மற்றும் எந்த கட்டத்தில் இருக்க வேண்டும் என்பதைக் குறிப்பிடுவோம். எங்கள் விஷயத்தில், தற்போதைய pom.xml இல் சார்பு சரிபார்ப்பு சரிபார்ப்பு கட்டத்தில் நடக்கும். இப்போது எங்கள் pom.xml கோப்பு இதுபோல் தெரிகிறது: 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>example.com</groupId>
   <artifactId>example</artifactId>
   <version>1.0-SNAPSHOT</version>

   <build>
       <plugins>
           <plugin>
               <groupId>com.soebes.maven.plugins</groupId>
               <artifactId>uptodate-maven-plugin</artifactId>
               <version>0.2.0</version>
               <executions>
                   <execution>
                       <goals>
                           <goal>dependency</goal>
                       </goals>
                       <phase>validate</phase>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>

   <dependencies>
       <dependency>
           <groupId>commons-io</groupId>
           <artifactId>commons-io</artifactId>
           <version>2.6</version>
       </dependency>
   </dependencies>
</project>
எங்கள் திட்டத்தில் தொடர்ந்து பணியாற்றலாம். ஆனால் அப்பாச்சி காமன்ஸ் ஐஓவின் பதிப்பை 2.0 ஆக மாற்றி திட்டத்தை உருவாக்க முயற்சிப்போம். நாம் பெறுவோம் 

[ERROR] Failed to execute goal com.soebes.maven.plugins:uptodate-maven-plugin:0.2.0:dependency (default) on project example: There is a more up-to-date version ( 2.6 ) of the dependency commons-io:commons-io:2.0 available. -> [Help 1]
சொருகி மூலம் உருவாக்கப்படும் பிழை இங்கே உள்ளது. பதிப்பு 2.6 கிடைக்கும்போது நாங்கள் பதிப்பு 2.0 ஐப் பயன்படுத்துகிறோம் என்று பிழைச் செய்தி கூறுகிறது. அடிப்படையில், மேவன் மிகவும் பயனுள்ள கருவி. ஒருவேளை முதலில் பயன்படுத்த கடினமாக இருக்கும், ஆனால் பயிற்சி! Maven ஐப் பயன்படுத்தி உங்கள் திட்டங்களை உருவாக்கவும், சிறிது நேரத்திற்குப் பிறகு இறுதி முடிவில் நீங்கள் மிகவும் மகிழ்ச்சியடைவீர்கள். இந்தக் கட்டுரை வேண்டுமென்றே மேவன் பற்றிய பல விவரங்களைத் தவிர்த்துவிட்டது - நாங்கள் மிகவும் அவசியமானவற்றில் கவனம் செலுத்தினோம். ஆனால் முன்னேற்றத்திற்கு வரம்பு இல்லை: நீங்கள் அதன் அதிகாரப்பூர்வ இணையதளத்தில் Maven பற்றி மேலும் படிக்கலாம் . பகுதி 5. Servlets மற்றும் Java Servlet API. எளிய இணைய பயன்பாட்டை எழுதுதல் பகுதி 6. சர்வ்லெட் கொள்கலன்கள் பகுதி 7. MVC (மாடல்-வியூ-கண்ட்ரோலர்) வடிவத்தை அறிமுகப்படுத்துதல்