ಮಾವೆನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಅನ್ನು ರಚಿಸುವುದು

ಮಾವೆನ್ ಯೋಜನೆಗಳನ್ನು ಏಕ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಆಗಿ ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡುವುದು

ಜಾವಾ ಯೋಜನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಸುಲಭವಾದ ವಿತರಣೆಗಾಗಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಒಂದೇ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಫೈಲ್‌ಗೆ ಪ್ಯಾಕೇಜ್ ಮಾಡುವುದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಮಾವೆನ್, ಶಕ್ತಿಯುತವಾದ ನಿರ್ಮಾಣ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಸಾಧನವಾಗಿದ್ದು, ಈ ಒಂದೇ ಔಟ್‌ಪುಟ್ JAR ಒಳಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ನಿಮ್ಮ ಅಂತಿಮ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಗೆ ಎಲ್ಲಾ ಅವಲಂಬನೆ JAR ಗಳನ್ನು ಸೇರಿಸಲು ನಿಮ್ಮ Maven ಯೋಜನೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಹಂತಗಳ ಮೂಲಕ ಈ ಲೇಖನವು ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ಈ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತೀರಿ ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಿವಿಧ ಪರಿಸರದಲ್ಲಿ ಸರಾಗವಾಗಿ ಚಲಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಮಾವೆನ್‌ನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ 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.

<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

ಪ್ಯಾಕೇಜಿಂಗ್ ಅವಲಂಬನೆಗಳಿಗಾಗಿ ಸುಧಾರಿತ ಮಾವೆನ್ ತಂತ್ರಗಳು

ಮಾವೆನ್‌ನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಅನ್ನು ರಚಿಸಲು ಮೂಲ ಸಂರಚನೆಯ ಆಚೆಗೆ, ನಿಮ್ಮ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚಿಸುವ ಹೆಚ್ಚುವರಿ ತಂತ್ರಗಳಿವೆ. ಅಂತಹ ಒಂದು ತಂತ್ರವನ್ನು ಬಳಸುವುದು ಒಳಗೊಂಡಿರುತ್ತದೆ shade ಬದಲಿಗೆ ಪ್ಲಗಿನ್ assembly ಪ್ಲಗಿನ್. ಮಾವೆನ್ ಶೇಡ್ ಪ್ಲಗಿನ್ uber-JAR ಗಳನ್ನು ರಚಿಸಲು ಹೆಚ್ಚು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ (ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ JAR ಗಳು). ಕ್ಲಾಸ್‌ಪಾತ್ ಘರ್ಷಣೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಪ್ಯಾಕೇಜುಗಳನ್ನು ಮರುಹೆಸರಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ನಕಲಿ ತರಗತಿಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಉತ್ತಮ ನಿರ್ವಹಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅಂತಿಮ JAR ನಲ್ಲಿ ಯಾವ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಎಂಬುದರ ಮೇಲೆ ಇದು ಸೂಕ್ಷ್ಮವಾದ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ.

ನಿಮ್ಮ JAR ಫೈಲ್‌ನ ಗಾತ್ರವನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ದೊಡ್ಡ JAR ಫೈಲ್‌ಗಳು ತೊಡಕಾಗಿರಬಹುದು ಮತ್ತು ವರ್ಗಾಯಿಸಲು ಅಥವಾ ಲೋಡ್ ಮಾಡಲು ನಿಧಾನವಾಗಬಹುದು. ದಿ maven-shade-plugin ಅನಗತ್ಯ ಫೈಲ್‌ಗಳು ಮತ್ತು ತರಗತಿಗಳನ್ನು ಹೊರಗಿಡಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಹಾಯ ಮಾಡಬಹುದು, ಹೀಗಾಗಿ ಅಂತಿಮ JAR ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಬಳಕೆಯಾಗದ ತರಗತಿಗಳು ಅಥವಾ ಅನಗತ್ಯ ಸಂಪನ್ಮೂಲಗಳಂತಹ ಅನಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ JAR ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನೀವು ಪ್ಲಗಿನ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಹಲವಾರು ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ದೊಡ್ಡ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ಸುಧಾರಿತ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಬಹುದು.

ಮಾವೆನ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ JAR ಗಳ ಕುರಿತು ಅಂತಿಮ ಆಲೋಚನೆಗಳು

Maven ಬಳಸಿಕೊಂಡು ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಅನ್ನು ರಚಿಸುವುದು ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಮೂಲಕ pom.xml ಫೈಲ್ ಮತ್ತು ಮಾವೆನ್ ಅಸೆಂಬ್ಲಿ ಪ್ಲಗಿನ್ ಅಥವಾ ಮಾವೆನ್ ಶೇಡ್ ಪ್ಲಗಿನ್‌ನಂತಹ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ, ಡೆವಲಪರ್‌ಗಳು ಎಲ್ಲಾ ಅಗತ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಒಂದೇ JAR ಫೈಲ್‌ಗೆ ಪ್ಯಾಕೇಜ್ ಮಾಡಬಹುದು. ಈ ವಿಧಾನವು ಅಪ್ಲಿಕೇಶನ್ ವಿವಿಧ ಪರಿಸರಗಳಲ್ಲಿ ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ವಿತರಣೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನೇರಗೊಳಿಸುತ್ತದೆ. ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುವುದರಿಂದ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನ ಅವಲಂಬನೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ JAR ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.