Maven ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਨਿਰਭਰਤਾ ਦੇ ਨਾਲ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਬਣਾਉਣਾ

ਇੱਕ ਸਿੰਗਲ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਵਿੱਚ ਮਾਵੇਨ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਪੈਕ ਕਰਨਾ

Java ਪ੍ਰੋਜੈਕਟਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਆਸਾਨੀ ਨਾਲ ਵੰਡਣ ਲਈ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਫਾਈਲ ਵਿੱਚ ਪੈਕੇਜ ਕਰਨਾ ਅਕਸਰ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ। Maven, ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਬਿਲਡ ਆਟੋਮੇਸ਼ਨ ਟੂਲ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇਸ ਸਿੰਗਲ ਆਉਟਪੁੱਟ JAR ਦੇ ਅੰਦਰ ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਇਹ ਲੇਖ ਤੁਹਾਡੀ ਅੰਤਿਮ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਵਿੱਚ ਸਾਰੇ ਨਿਰਭਰਤਾ JAR ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਤੁਹਾਡੇ Maven ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਕਦਮਾਂ ਬਾਰੇ ਮਾਰਗਦਰਸ਼ਨ ਕਰੇਗਾ। ਇਹਨਾਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਗੇ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਗੇ ਕਿ ਤੁਹਾਡੀ ਅਰਜ਼ੀ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਚੱਲਦੀ ਹੈ।

ਹੁਕਮ	ਵਰਣਨ
<plugin>	ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਵਰਤਣ ਲਈ ਇੱਕ ਮਾਵੇਨ ਪਲੱਗਇਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਪਲੱਗਇਨ ਖਾਸ ਕੰਮ ਚਲਾ ਸਕਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਕੋਡ ਕੰਪਾਇਲ ਕਰਨਾ ਜਾਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਪੈਕ ਕਰਨਾ।
<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 ਵਰਣਨਕਰਤਾ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਸਾਰੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਅੰਤਿਮ 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 ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਸੰਰਚਨਾ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਵਾਧੂ ਤਕਨੀਕਾਂ ਹਨ ਜੋ ਤੁਹਾਡੀ ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵਧਾ ਸਕਦੀਆਂ ਹਨ। ਇੱਕ ਅਜਿਹੀ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ ਦੀ ਬਜਾਏ ਪਲੱਗਇਨ ਪਲੱਗਇਨ. Maven ਸ਼ੇਡ ਪਲੱਗਇਨ uber-JARs (ਨਿਰਭਰਤਾਵਾਂ ਦੇ ਨਾਲ JARs ਸ਼ਾਮਲ) ਬਣਾਉਣ ਲਈ ਵਧੇਰੇ ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਕਲਾਸਪਾਥ ਵਿਵਾਦਾਂ ਤੋਂ ਬਚਣ ਲਈ ਪੈਕੇਜਾਂ ਦਾ ਨਾਮ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਅਤੇ ਡੁਪਲੀਕੇਟ ਕਲਾਸਾਂ ਅਤੇ ਸਰੋਤਾਂ ਲਈ ਬਿਹਤਰ ਪ੍ਰਬੰਧਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਵਧੀਆ ਨਿਯੰਤਰਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਅੰਤਮ JAR ਵਿੱਚ ਕਿਹੜੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਤੁਹਾਡੀ JAR ਫਾਈਲ ਦੇ ਆਕਾਰ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਰਿਹਾ ਹੈ. ਵੱਡੀਆਂ JAR ਫਾਈਲਾਂ ਬੋਝਲ ਹੋ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਟ੍ਰਾਂਸਫਰ ਜਾਂ ਲੋਡ ਕਰਨ ਲਈ ਹੌਲੀ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਦ ਤੁਹਾਨੂੰ ਬੇਲੋੜੀਆਂ ਫਾਈਲਾਂ ਅਤੇ ਕਲਾਸਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇ ਕੇ ਇਸ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਅੰਤਮ JAR ਦਾ ਆਕਾਰ ਘਟਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਗੈਰ-ਜ਼ਰੂਰੀ ਜਾਣਕਾਰੀ ਜਿਵੇਂ ਕਿ ਅਣਵਰਤੀਆਂ ਕਲਾਸਾਂ ਜਾਂ ਬੇਲੋੜੇ ਸਰੋਤਾਂ ਨੂੰ ਹਟਾ ਕੇ JAR ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਪਲੱਗਇਨ ਨੂੰ ਕੌਂਫਿਗਰ ਵੀ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਉੱਨਤ ਸੰਰਚਨਾਵਾਂ ਖਾਸ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਦੋਂ ਕਈ ਨਿਰਭਰਤਾਵਾਂ ਵਾਲੇ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ।

1. ਮੈਂ ਆਪਣੇ JAR ਵਿੱਚ ਮੁੱਖ ਕਲਾਸ ਨੂੰ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰਾਂ?
2. ਤੁਸੀਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁੱਖ ਕਲਾਸ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਦੇ ਅੰਦਰ ਟੈਗ ਕਰੋ Maven ਪਲੱਗਇਨ ਸੰਰਚਨਾ ਦਾ ਭਾਗ.
3. ਮੈਂ ਅੰਤਿਮ JAR ਤੋਂ ਖਾਸ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਬਾਹਰ ਕਰ ਸਕਦਾ ਹਾਂ?
4. ਦੀ ਵਰਤੋਂ ਕਰੋ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਪਲੱਗਇਨ ਸੰਰਚਨਾ ਦੇ ਅੰਦਰ ਟੈਗ ਕਰੋ ਜੋ ਅੰਤਿਮ JAR ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ।
5. ਇੱਕ ਉਬੇਰ-ਜਾਰ ਕੀ ਹੈ?
6. ਇੱਕ uber-JAR ਇੱਕ JAR ਫਾਈਲ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਨਾ ਸਿਰਫ਼ ਤੁਹਾਡਾ ਕੰਪਾਇਲ ਕੀਤਾ ਕੋਡ ਹੁੰਦਾ ਹੈ, ਸਗੋਂ ਇਸ ਦੀਆਂ ਸਾਰੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਵੀ ਹੁੰਦੀਆਂ ਹਨ।
7. ਮੈਂ ਆਪਣੇ JAR ਵਿੱਚ ਕਲਾਸਪਾਥ ਵਿਵਾਦਾਂ ਤੋਂ ਕਿਵੇਂ ਬਚ ਸਕਦਾ ਹਾਂ?
8. ਦ ਵਿਵਾਦਾਂ ਤੋਂ ਬਚਣ ਲਈ ਤੁਹਾਨੂੰ ਨਿਰਭਰਤਾ ਦੇ ਅੰਦਰ ਪੈਕੇਜਾਂ ਦਾ ਨਾਮ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
9. ਮੈਂ ਨਿਰਭਰਤਾ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਕਲਾਸਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਾਂ?
10. ਦੀ ਸੰਰਚਨਾ ਕਰੋ ਡੁਪਲੀਕੇਟ ਕਲਾਸਾਂ ਅਤੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਇਹ ਦੱਸ ਕੇ ਕਿ ਡੁਪਲੀਕੇਟ ਨੂੰ ਅੰਤਿਮ JAR ਵਿੱਚ ਕਿਵੇਂ ਸੰਭਾਲਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
11. ਕੀ ਮੈਂ ਨਿਰਭਰਤਾ ਤੋਂ ਸਿਰਫ਼ ਖਾਸ ਫਾਈਲਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕਦਾ ਹਾਂ?
12. ਹਾਂ, ਤੁਸੀਂ ਸੰਰਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਇੱਕ ਨਿਰਭਰਤਾ ਤੋਂ ਸਿਰਫ਼ ਖਾਸ ਫਾਈਲਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ.
13. ਮੈਂ ਪੈਕ ਕੀਤੇ JAR ਨੂੰ ਕਿਵੇਂ ਚਲਾਵਾਂ?
14. ਦੀ ਵਰਤੋਂ ਕਰੋ ਤੁਹਾਡੀ JAR ਫਾਈਲ ਦੇ ਮਾਰਗ ਤੋਂ ਬਾਅਦ ਕਮਾਂਡ.
15. ਮੈਂ ਆਪਣੀ JAR ਫਾਈਲ ਦੀ ਸਮੱਗਰੀ ਦੀ ਪੁਸ਼ਟੀ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
16. ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ JAR ਫਾਈਲ ਦੇ ਭਾਗਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨ ਲਈ ਕਮਾਂਡ.
17. ਜੇ ਮੇਰੀ JAR ਫਾਈਲ ਬਹੁਤ ਵੱਡੀ ਹੈ ਤਾਂ ਕੀ ਹੋਵੇਗਾ?
18. ਦੀ ਵਰਤੋਂ ਕਰੋ ਬੇਲੋੜੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਅਤੇ JAR ਆਕਾਰ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ।

ਮਾਵੇਨ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JARs 'ਤੇ ਵਿਚਾਰ ਸਮਾਪਤ ਕਰਨਾ

Maven ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਨਿਰਭਰਤਾ ਦੇ ਨਾਲ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਬਣਾਉਣਾ Java ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਰਚਿਤ ਕਰਕੇ ਫਾਈਲ ਅਤੇ ਮੇਵੇਨ ਅਸੈਂਬਲੀ ਪਲੱਗਇਨ ਜਾਂ ਮਾਵੇਨ ਸ਼ੇਡ ਪਲੱਗਇਨ ਵਰਗੇ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਡਿਵੈਲਪਰ ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ JAR ਫਾਈਲ ਵਿੱਚ ਪੈਕੇਜ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਪਹੁੰਚ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਨਿਰਵਿਘਨ ਚੱਲ ਸਕਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਵੰਡ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਸਿੱਧਾ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਨਾਲ ਤੁਹਾਨੂੰ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੀ ਨਿਰਭਰਤਾ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਅਤੇ ਭਰੋਸੇਯੋਗ, ਐਗਜ਼ੀਕਿਊਟੇਬਲ JAR ਫਾਈਲਾਂ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਮਿਲੇਗੀ।