మావెన్‌ని ఉపయోగించి డిపెండెన్సీలతో ఎక్జిక్యూటబుల్ JARని సృష్టించడం

మావెన్‌ని ఉపయోగించి డిపెండెన్సీలతో ఎక్జిక్యూటబుల్ JARని సృష్టించడం
మావెన్‌ని ఉపయోగించి డిపెండెన్సీలతో ఎక్జిక్యూటబుల్ JARని సృష్టించడం

మావెన్ ప్రాజెక్ట్‌లను ఒకే ఎక్జిక్యూటబుల్ JARలోకి ప్యాకేజింగ్ చేయడం

జావా ప్రాజెక్ట్‌లతో పని చేస్తున్నప్పుడు, సులభంగా పంపిణీ చేయడానికి మీ అప్లికేషన్‌ను ఒకే ఎక్జిక్యూటబుల్ JAR ఫైల్‌లో ప్యాక్ చేయడం తరచుగా అవసరం. మావెన్, శక్తివంతమైన బిల్డ్ ఆటోమేషన్ సాధనం, ఈ సింగిల్ అవుట్‌పుట్ JARలో అవసరమైన అన్ని డిపెండెన్సీలను చేర్చడానికి డెవలపర్‌లను అనుమతిస్తుంది.

మీ చివరి ఎక్జిక్యూటబుల్ JARలో అన్ని డిపెండెన్సీ JARలను చేర్చడానికి మీ మావెన్ ప్రాజెక్ట్‌ను కాన్ఫిగర్ చేయడానికి అవసరమైన దశల ద్వారా ఈ కథనం మీకు మార్గనిర్దేశం చేస్తుంది. ఈ సూచనలను అనుసరించడం ద్వారా, మీరు విస్తరణ ప్రక్రియను సులభతరం చేస్తారు మరియు మీ అప్లికేషన్ వివిధ వాతావరణాలలో సజావుగా నడుస్తుందని నిర్ధారించుకోండి.

ఆదేశం వివరణ
<plugin> బిల్డ్ ప్రాసెస్ సమయంలో ఉపయోగించడానికి మావెన్ ప్లగ్ఇన్‌ను నిర్వచిస్తుంది. కోడ్‌ను కంపైల్ చేయడం లేదా ప్రాజెక్ట్‌ను ప్యాకేజింగ్ చేయడం వంటి నిర్దిష్ట పనులను ప్లగిన్‌లు అమలు చేయగలవు.
<groupId> మావెన్ ప్రాజెక్ట్ కోసం సమూహ ఐడెంటిఫైయర్‌ను పేర్కొంటుంది, సాధారణంగా రివర్స్ డొమైన్ పేరు.
<artifactId> ప్రాజెక్ట్ పేరు అయిన ఆర్టిఫ్యాక్ట్ ఐడెంటిఫైయర్‌ను నిర్వచిస్తుంది.
<version> ప్రాజెక్ట్ యొక్క ప్రస్తుత సంస్కరణను సూచిస్తుంది.
<build> ప్లగిన్‌లు మరియు వనరులతో సహా ప్రాజెక్ట్ కోసం బిల్డ్ కాన్ఫిగరేషన్‌ను కలిగి ఉంటుంది.
<descriptorRef> "జార్-విత్-డిపెండెన్సీస్" వంటి ఉపయోగించడానికి మావెన్ అసెంబ్లీ ప్లగిన్ కోసం ముందే నిర్వచించిన డిస్క్రిప్టర్‌ను సూచిస్తుంది.
<mainClass> JAR ఫైల్ అమలు చేయబడినప్పుడు అమలు చేయవలసిన ప్రధాన తరగతిని పేర్కొంటుంది.
<execution> ఒక ప్లగ్ఇన్‌లోని ఎగ్జిక్యూషన్ బ్లాక్‌ను నిర్వచిస్తుంది, వివిధ నిర్మాణ దశల్లో నిర్వహించాల్సిన పనులను పేర్కొంటుంది.
mvn clean package ప్రాజెక్ట్‌ను క్లీన్ చేసి, అన్ని డిపెండెన్సీలతో సహా JAR ఫైల్‌కి ప్యాక్ చేయమని ఆదేశం.
java -jar target/...jar JARకి మార్గాన్ని పేర్కొంటూ, రూపొందించబడిన JAR ఫైల్‌ను అమలు చేయమని ఆదేశం.

మావెన్‌తో ఎక్జిక్యూటబుల్ JARని సృష్టించడం మరియు అమలు చేయడం

పైన అందించిన స్క్రిప్ట్‌లు మావెన్ ప్రాజెక్ట్‌ను దాని అన్ని డిపెండెన్సీలను ఒకే ఎక్జిక్యూటబుల్ JAR ఫైల్‌గా ప్యాక్ చేయడానికి ఎలా కాన్ఫిగర్ చేయాలో చూపుతాయి. మొదటి స్క్రిప్ట్ మావెన్ pom.xml ఫైల్, ఇది ప్రాజెక్ట్ కాన్ఫిగరేషన్‌ను కలిగి ఉంటుంది. ఈ ఫైల్‌లో, ది <plugin> మావెన్ అసెంబ్లీ ప్లగిన్‌ను నిర్వచించడానికి ట్యాగ్ ఉపయోగించబడుతుంది. అన్ని డిపెండెన్సీలను కలిగి ఉన్న ఎక్జిక్యూటబుల్ JARని సృష్టించడానికి ఈ ప్లగ్ఇన్ కీలకం. ది <descriptorRefs> ప్లగ్ఇన్ కాన్ఫిగరేషన్‌లోని ట్యాగ్ వినియోగాన్ని నిర్దేశిస్తుంది jar-with-dependencies డిస్క్రిప్టర్, ఇది ప్రాజెక్ట్ యొక్క అన్ని డిపెండెన్సీలు చివరి JAR ఫైల్‌లో ప్యాక్ చేయబడిందని నిర్ధారిస్తుంది. ది <mainClass> లోపల ట్యాగ్ <manifest> JAR అమలు చేయబడినప్పుడు అమలు చేయడానికి ఏ తరగతి ప్రధాన పద్ధతిని కలిగి ఉందో మావెన్‌కు తెలియజేస్తుంది కాబట్టి విభాగం చాలా అవసరం.

ది <execution> చర్య జరిగే చోట ప్లగ్ఇన్ కాన్ఫిగరేషన్ లోపల బ్లాక్ చేయండి. ఇది ప్లగ్ఇన్ యొక్క లక్ష్యాన్ని నిర్దేశిస్తుంది single సమయంలో అమలు చేయాలి package నిర్మాణ జీవితచక్రం యొక్క దశ. ఇది డిపెండెన్సీలతో JAR ఫైల్ యొక్క సృష్టిని ట్రిగ్గర్ చేస్తుంది. రెండవ స్క్రిప్ట్ ఒక సాధారణ కమాండ్ లైన్ సూచన: mvn clean package. ఈ ఆదేశం ప్రాజెక్ట్‌ను శుభ్రపరుస్తుంది (మునుపటి నిర్మాణ కళాఖండాలను తొలగించడం), సోర్స్ కోడ్‌ను కంపైల్ చేస్తుంది, పరీక్షలను అమలు చేస్తుంది మరియు ప్రాజెక్ట్‌ను JAR ఫైల్‌గా ప్యాకేజీ చేస్తుంది. చివరి JAR ఫైల్ లో ఉంటుంది target ప్రాజెక్ట్ యొక్క డైరెక్టరీ మరియు దాని ప్రకారం పేరు పెట్టబడింది artifactId మరియు version లో పేర్కొనబడింది pom.xml.

మావెన్ ఉపయోగించి డిపెండెన్సీలతో ఎక్జిక్యూటబుల్ JAR ఫైల్‌ను సృష్టిస్తోంది

మావెన్ కాన్ఫిగరేషన్ స్క్రిప్ట్

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

JARని ప్యాకేజ్ చేయడానికి మావెన్ కమాండ్‌ని అమలు చేస్తోంది

కమాండ్ లైన్ సూచనలు

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

ప్యాకేజింగ్ డిపెండెన్సీల కోసం అధునాతన మావెన్ టెక్నిక్స్

మావెన్‌తో ఎక్జిక్యూటబుల్ JARని సృష్టించడానికి ప్రాథమిక కాన్ఫిగరేషన్‌కు మించి, మీ బిల్డ్ ప్రాసెస్‌ను మెరుగుపరచగల అదనపు పద్ధతులు ఉన్నాయి. అటువంటి సాంకేతికతలో ఒకటి shade బదులుగా ప్లగిన్ assembly అనుసంధానించు. మావెన్ షేడ్ ప్లగ్ఇన్ ఉబెర్-జార్‌లను రూపొందించడానికి మరింత అధునాతన ఫీచర్‌లను అందిస్తుంది (డిపెండెన్సీలతో కూడిన JARలు). ఇది క్లాస్‌పాత్ వైరుధ్యాలను నివారించడానికి ప్యాకేజీల పేరు మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది మరియు నకిలీ తరగతులు మరియు వనరులకు మెరుగైన నిర్వహణను అందిస్తుంది. అదనంగా, ఇది తుది JARలో చేర్చబడిన డిపెండెన్సీలపై చక్కటి నియంత్రణను అందిస్తుంది.

మరొక ముఖ్యమైన అంశం మీ JAR ఫైల్ పరిమాణాన్ని నిర్వహించడం. పెద్ద JAR ఫైల్‌లు గజిబిజిగా ఉంటాయి మరియు బదిలీ చేయడానికి లేదా లోడ్ చేయడానికి నెమ్మదిగా ఉంటాయి. ది maven-shade-plugin అనవసరమైన ఫైల్‌లు మరియు తరగతులను మినహాయించడానికి మిమ్మల్ని అనుమతించడం ద్వారా దీనితో సహాయపడుతుంది, తద్వారా చివరి JAR పరిమాణాన్ని తగ్గిస్తుంది. మీరు ఉపయోగించని తరగతులు లేదా అనవసరమైన వనరులు వంటి అనవసరమైన సమాచారాన్ని తీసివేయడం ద్వారా JARని కనిష్టీకరించడానికి ప్లగిన్‌ను కాన్ఫిగర్ చేయవచ్చు. అనేక డిపెండెన్సీలతో పెద్ద ప్రాజెక్ట్‌లపై పని చేస్తున్నప్పుడు ఈ అధునాతన కాన్ఫిగరేషన్‌లు ప్రత్యేకంగా ఉపయోగపడతాయి.

మావెన్ ఎక్జిక్యూటబుల్ JARల కోసం సాధారణ ప్రశ్నలు మరియు పరిష్కారాలు

  1. నేను నా JARలో ప్రధాన తరగతిని ఎలా పేర్కొనాలి?
  2. మీరు ఉపయోగించి ప్రధాన తరగతిని పేర్కొనవచ్చు <mainClass> లోపల ట్యాగ్ <manifest> Maven ప్లగ్ఇన్ కాన్ఫిగరేషన్ యొక్క విభాగం.
  3. తుది JAR నుండి నిర్దిష్ట డిపెండెన్సీలను నేను ఎలా మినహాయించగలను?
  4. ఉపయోగించడానికి excludes చివరి JARలో చేర్చకూడని డిపెండెన్సీలను పేర్కొనడానికి ప్లగిన్ కాన్ఫిగరేషన్‌లో ట్యాగ్ చేయండి.
  5. Uber-JAR అంటే ఏమిటి?
  6. uber-JAR అనేది మీ కంపైల్ చేసిన కోడ్‌ను మాత్రమే కాకుండా దాని అన్ని డిపెండెన్సీలను కూడా కలిగి ఉన్న JAR ఫైల్.
  7. నా JARలో క్లాస్‌పాత్ వైరుధ్యాలను నేను ఎలా నివారించగలను?
  8. ది maven-shade-plugin వైరుధ్యాలను నివారించడానికి డిపెండెన్సీలలోని ప్యాకేజీల పేరు మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది.
  9. డిపెండెన్సీలలో నేను నకిలీ తరగతులను ఎలా నిర్వహించగలను?
  10. కాన్ఫిగర్ చేయండి maven-shade-plugin చివరి JARలో డూప్లికేట్‌లను ఎలా నిర్వహించాలో పేర్కొనడం ద్వారా నకిలీ తరగతులు మరియు వనరులను నిర్వహించడానికి.
  11. నేను డిపెండెన్సీ నుండి నిర్దిష్ట ఫైల్‌లను మాత్రమే చేర్చవచ్చా?
  12. అవును, మీరు కాన్ఫిగర్ చేయవచ్చు maven-assembly-plugin లేదా maven-shade-plugin డిపెండెన్సీ నుండి నిర్దిష్ట ఫైల్‌లను మాత్రమే చేర్చడానికి.
  13. నేను ప్యాక్ చేయబడిన JARని ఎలా అమలు చేయాలి?
  14. ఉపయోగించడానికి java -jar కమాండ్ మీ JAR ఫైల్‌కి దారిని అనుసరిస్తుంది.
  15. నా JAR ఫైల్ కంటెంట్‌లను నేను ఎలా ధృవీకరించగలను?
  16. మీరు ఉపయోగించవచ్చు jar -tf JAR ఫైల్ యొక్క కంటెంట్‌లను జాబితా చేయడానికి ఆదేశం.
  17. నా JAR ఫైల్ చాలా పెద్దదిగా ఉంటే ఏమి చేయాలి?
  18. ఉపయోగించడానికి maven-shade-plugin అనవసరమైన ఫైల్‌లను మినహాయించడానికి మరియు JAR పరిమాణాన్ని తగ్గించడానికి.

మావెన్ ఎక్జిక్యూటబుల్ JARలపై ముగింపు ఆలోచనలు

మావెన్‌ని ఉపయోగించి డిపెండెన్సీలతో ఎక్జిక్యూటబుల్ JARని సృష్టించడం జావా అప్లికేషన్‌ల కోసం విస్తరణ ప్రక్రియను సులభతరం చేస్తుంది. సరిగ్గా కాన్ఫిగర్ చేయడం ద్వారా pom.xml ఫైల్ మరియు మావెన్ అసెంబ్లీ ప్లగిన్ లేదా మావెన్ షేడ్ ప్లగిన్ వంటి ప్లగిన్‌లను ఉపయోగించడం ద్వారా, డెవలపర్లు అవసరమైన అన్ని డిపెండెన్సీలను ఒకే JAR ఫైల్‌గా ప్యాక్ చేయవచ్చు. ఈ విధానం అప్లికేషన్ వివిధ వాతావరణాలలో సజావుగా అమలు చేయగలదని నిర్ధారిస్తుంది, పంపిణీ మరియు అమలును సూటిగా చేస్తుంది. ఈ దశలను అనుసరించడం వలన మీ ప్రాజెక్ట్ యొక్క డిపెండెన్సీలను సమర్థవంతంగా నిర్వహించడంలో మరియు నమ్మదగిన, ఎక్జిక్యూటబుల్ JAR ఫైల్‌లను రూపొందించడంలో మీకు సహాయపడుతుంది.