மேவனைப் பயன்படுத்தி சார்புகளுடன் இயங்கக்கூடிய JAR ஐ உருவாக்குதல்

மேவன் ப்ராஜெக்ட்களை ஒரு ஒற்றை எக்ஸிகியூடபிள் ஜாரில் பேக்கேஜிங் செய்தல்

ஜாவா ப்ராஜெக்ட்களுடன் பணிபுரியும் போது, ​​எளிதாக விநியோகிக்க உங்கள் விண்ணப்பத்தை ஒரே இயங்கக்கூடிய JAR கோப்பில் தொகுக்க வேண்டியது அவசியம். மேவன், ஒரு சக்திவாய்ந்த உருவாக்க ஆட்டோமேஷன் கருவி, இந்த ஒற்றை வெளியீடு JAR க்குள் தேவையான அனைத்து சார்புகளையும் சேர்க்க டெவலப்பர்களை அனுமதிக்கிறது.

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

கட்டளை	விளக்கம்
<plugin>	உருவாக்க செயல்பாட்டின் போது பயன்படுத்த Maven செருகுநிரலை வரையறுக்கிறது. செருகுநிரல்கள் குறியீட்டை தொகுத்தல் அல்லது திட்டத்தை பேக்கேஜிங் செய்தல் போன்ற குறிப்பிட்ட பணிகளைச் செய்ய முடியும்.
<groupId>	Maven திட்டத்திற்கான குழு அடையாளங்காட்டியைக் குறிப்பிடுகிறது, பொதுவாக ஒரு தலைகீழ் டொமைன் பெயர்.
<artifactId>	புராஜெக்ட்டின் பெயரான கலைப்பொருளின் அடையாளங்காட்டியை வரையறுக்கிறது.
<version>	திட்டத்தின் தற்போதைய பதிப்பைக் குறிக்கிறது.
<build>	செருகுநிரல்கள் மற்றும் ஆதாரங்கள் உட்பட திட்டத்திற்கான உருவாக்க உள்ளமைவைக் கொண்டுள்ளது.
<descriptorRef>	"ஜார்-வித்-சார்புகள்" போன்ற, பயன்படுத்துவதற்கு மேவன் அசெம்பிளி செருகுநிரலுக்கான முன் வரையறுக்கப்பட்ட விளக்கத்தைக் குறிப்பிடுகிறது.
<mainClass>	JAR கோப்பு இயக்கப்படும் போது செயல்படுத்தப்பட வேண்டிய முக்கிய வகுப்பைக் குறிப்பிடுகிறது.
<execution>	ஒரு செருகுநிரலுக்குள் செயல்படுத்தும் தொகுதியை வரையறுக்கிறது, வெவ்வேறு கட்ட கட்டங்களில் செய்ய வேண்டிய பணிகளைக் குறிப்பிடுகிறது.
mvn clean package	திட்டத்தைச் சுத்தம் செய்து, அனைத்து சார்புகளையும் சேர்த்து, JAR கோப்பில் தொகுக்குமாறு கட்டளையிடவும்.
java -jar target/...jar	உருவாக்கப்பட்ட JAR கோப்பை இயக்குவதற்கான கட்டளை, JARக்கான பாதையைக் குறிப்பிடுகிறது.

Maven உடன் இயங்கக்கூடிய JAR ஐ உருவாக்குதல் மற்றும் இயக்குதல்

மேலே கொடுக்கப்பட்டுள்ள ஸ்கிரிப்ட்கள், ஒரு மேவன் திட்டத்தை அதன் அனைத்து சார்புகளையும் ஒரே இயங்கக்கூடிய JAR கோப்பில் தொகுக்க எப்படி கட்டமைப்பது என்பதை விளக்குகிறது. முதல் ஸ்கிரிப்ட் ஒரு மேவன் கோப்பு, இது திட்டத்தின் உள்ளமைவைக் கொண்டுள்ளது. இந்த கோப்பில், தி மேவன் சட்டசபை செருகுநிரலை வரையறுக்க டேக் பயன்படுத்தப்படுகிறது. அனைத்து சார்புகளையும் உள்ளடக்கிய இயங்கக்கூடிய JAR ஐ உருவாக்குவதற்கு இந்த செருகுநிரல் முக்கியமானது. தி செருகுநிரல் உள்ளமைவில் உள்ள குறிச்சொல்லின் பயன்பாட்டைக் குறிப்பிடுகிறது jar-with-dependencies descriptor, இது திட்டத்தின் அனைத்து சார்புகளும் இறுதி JAR கோப்பில் தொகுக்கப்படுவதை உறுதி செய்கிறது. தி உள்ளே குறிச்சொல் JAR செயல்படுத்தப்படும்போது எந்த வகுப்பில் இயங்குவதற்கான முக்கிய முறை உள்ளது என்பதை மேவன் கூறுவதால் பிரிவு அவசியம்.

தி செருகுநிரல் உள்ளமைவின் உள்ளே தடுப்பு என்பது செயல் நடக்கும் இடமாகும். இது செருகுநிரலின் இலக்கு என்று குறிப்பிடுகிறது போது செயல்படுத்தப்பட வேண்டும் உருவாக்க வாழ்க்கை சுழற்சியின் கட்டம். இது சார்புகளுடன் JAR கோப்பை உருவாக்க தூண்டுகிறது. இரண்டாவது ஸ்கிரிப்ட் ஒரு எளிய கட்டளை வரி அறிவுறுத்தலாகும்: mvn clean package. இந்த கட்டளை திட்டத்தை சுத்தம் செய்கிறது (முந்தைய உருவாக்க கலைப்பொருட்களை நீக்குகிறது), மூலக் குறியீட்டை தொகுக்கிறது, சோதனைகளை இயக்குகிறது மற்றும் திட்டத்தை ஒரு JAR கோப்பில் தொகுக்கிறது. இறுதி JAR கோப்பு உள்ள இடத்தில் இருக்கும் திட்டத்தின் அடைவு மற்றும் படி பெயரிடப்பட்டது மற்றும் இல் குறிப்பிடப்பட்டுள்ளது pom.xml.

<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>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.example.MainClass</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

mvn clean package
# This command will compile the code, run the tests, and create the JAR file
# The JAR file will include all dependencies specified in the pom.xml
# It will be located in the target directory of the project
# The final JAR file will be named my-app-1.0-SNAPSHOT-jar-with-dependencies.jar

# To run the JAR file, use the following command:
java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar
# Ensure that the mainClass specified in the pom.xml is correct
# This will start your application with all dependencies included

பேக்கேஜிங் சார்புகளுக்கான மேம்பட்ட மேவன் நுட்பங்கள்

Maven உடன் இயங்கக்கூடிய JAR ஐ உருவாக்குவதற்கான அடிப்படை கட்டமைப்புக்கு அப்பால், உங்கள் உருவாக்க செயல்முறையை மேம்படுத்தக்கூடிய கூடுதல் நுட்பங்கள் உள்ளன. அத்தகைய ஒரு நுட்பத்தை பயன்படுத்துவதை உள்ளடக்கியது க்கு பதிலாக சொருகி சொருகு. மேவன் ஷேட் செருகுநிரல் uber-JARகளை உருவாக்குவதற்கான மேம்பட்ட அம்சங்களை வழங்குகிறது (சார்புகளுடன் கூடிய JARகள்). இது கிளாஸ்பாத் மோதல்களைத் தவிர்க்க தொகுப்புகளை மறுபெயரிட உங்களை அனுமதிக்கிறது மற்றும் நகல் வகுப்புகள் மற்றும் ஆதாரங்களுக்கான சிறந்த கையாளுதலை வழங்குகிறது. கூடுதலாக, இது இறுதி JAR இல் எந்த சார்புநிலைகள் சேர்க்கப்பட்டுள்ளன என்பதில் நுணுக்கமான கட்டுப்பாட்டை வழங்குகிறது.

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

1. எனது JAR இல் உள்ள முக்கிய வகுப்பை எவ்வாறு குறிப்பிடுவது?
2. நீங்கள் முக்கிய வகுப்பைப் பயன்படுத்தி குறிப்பிடலாம் உள்ள குறிச்சொல் மேவன் சொருகி உள்ளமைவின் பிரிவு.
3. இறுதி JAR இலிருந்து குறிப்பிட்ட சார்புகளை நான் எவ்வாறு விலக்குவது?
4. பயன்படுத்த இறுதி JAR இல் சேர்க்கப்படாத சார்புகளைக் குறிப்பிட, செருகுநிரல் உள்ளமைவில் குறியிடவும்.
5. uber-JAR என்றால் என்ன?
6. uber-JAR என்பது உங்கள் தொகுக்கப்பட்ட குறியீடு மட்டுமல்ல, அதன் அனைத்து சார்புகளையும் கொண்ட ஒரு JAR கோப்பாகும்.
7. எனது JAR இல் கிளாஸ்பாத் மோதல்களை நான் எவ்வாறு தவிர்ப்பது?
8. தி முரண்பாடுகளைத் தவிர்க்க சார்புகளுக்குள் தொகுப்புகளை மறுபெயரிட உங்களை அனுமதிக்கிறது.
9. சார்புநிலைகளில் நகல் வகுப்புகளை எவ்வாறு கையாள்வது?
10. கட்டமைக்கவும் இறுதி JAR இல் நகல்கள் எவ்வாறு கையாளப்பட வேண்டும் என்பதைக் குறிப்பிடுவதன் மூலம் நகல் வகுப்புகள் மற்றும் ஆதாரங்களை நிர்வகிக்க.
11. சார்புநிலையிலிருந்து குறிப்பிட்ட கோப்புகளை மட்டும் சேர்க்க முடியுமா?
12. ஆம், நீங்கள் கட்டமைக்க முடியும் அல்லது சார்புநிலையிலிருந்து குறிப்பிட்ட கோப்புகளை மட்டும் சேர்க்க.
13. தொகுக்கப்பட்ட JAR ஐ எவ்வாறு இயக்குவது?
14. பயன்படுத்த கட்டளையைத் தொடர்ந்து உங்கள் JAR கோப்பிற்கான பாதை.
15. எனது JAR கோப்பின் உள்ளடக்கங்களை நான் எவ்வாறு சரிபார்க்க முடியும்?
16. நீங்கள் பயன்படுத்தலாம் JAR கோப்பின் உள்ளடக்கங்களை பட்டியலிட கட்டளை.
17. எனது JAR கோப்பு மிகப் பெரியதாக இருந்தால் என்ன செய்வது?
18. பயன்படுத்த தேவையற்ற கோப்புகளை விலக்கி, JAR அளவைக் குறைக்கவும்.

மேவன் எக்ஸிகியூடபிள் ஜேஆர்கள் பற்றிய முடிவான எண்ணங்கள்

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