മാവൻ ഉപയോഗിച്ച് ഡിപൻഡൻസികൾ ഉപയോഗിച്ച് എക്സിക്യൂട്ടബിൾ JAR സൃഷ്ടിക്കുന്നു

മാവെൻ പ്രോജക്‌റ്റുകൾ ഒരു സിംഗിൾ എക്‌സിക്യൂട്ടബിൾ ജാറിലേക്ക് പാക്കേജിംഗ്

ജാവ പ്രോജക്‌റ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, എളുപ്പത്തിൽ വിതരണത്തിനായി നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഒരു എക്‌സിക്യൂട്ടബിൾ JAR ഫയലിലേക്ക് പാക്കേജ് ചെയ്യേണ്ടത് ആവശ്യമാണ്. ശക്തമായ ബിൽഡ് ഓട്ടോമേഷൻ ടൂളായ Maven, ഈ ഒരൊറ്റ ഔട്ട്‌പുട്ട് JAR-ൽ ആവശ്യമായ എല്ലാ ഡിപൻഡൻസികളും ഉൾപ്പെടുത്താൻ ഡെവലപ്പർമാരെ അനുവദിക്കുന്നു.

നിങ്ങളുടെ അന്തിമ എക്സിക്യൂട്ടബിൾ JAR-ൽ എല്ലാ ഡിപൻഡൻസി JAR-കളും ഉൾപ്പെടുത്തുന്നതിന് നിങ്ങളുടെ Maven പ്രോജക്റ്റ് കോൺഫിഗർ ചെയ്യുന്നതിന് ആവശ്യമായ ഘട്ടങ്ങളിലൂടെ ഈ ലേഖനം നിങ്ങളെ നയിക്കും. ഈ നിർദ്ദേശങ്ങൾ പാലിക്കുന്നതിലൂടെ, നിങ്ങൾ വിന്യാസ പ്രക്രിയ ലളിതമാക്കുകയും നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വ്യത്യസ്ത പരിതസ്ഥിതികളിൽ സുഗമമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുകയും ചെയ്യും.

മാവെനൊപ്പം ഒരു എക്‌സിക്യൂട്ടബിൾ JAR സൃഷ്‌ടിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു

മുകളിൽ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ഒരു മാവൻ പ്രോജക്റ്റ് അതിൻ്റെ എല്ലാ ഡിപൻഡൻസികളും ഒരു എക്സിക്യൂട്ടബിൾ JAR ഫയലിലേക്ക് എങ്ങനെ ക്രമീകരിക്കാമെന്ന് കാണിക്കുന്നു. ആദ്യത്തെ തിരക്കഥ ഒരു മാവൻ ആണ് pom.xml പ്രോജക്റ്റിൻ്റെ കോൺഫിഗറേഷൻ അടങ്ങുന്ന ഫയൽ. ഈ ഫയലിനുള്ളിൽ, ദി <plugin> Maven അസംബ്ലി പ്ലഗിൻ നിർവചിക്കാൻ ടാഗ് ഉപയോഗിക്കുന്നു. എല്ലാ ഡിപൻഡൻസികളും ഉൾപ്പെടുന്ന ഒരു എക്സിക്യൂട്ടബിൾ 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

പാക്കേജിംഗ് ഡിപൻഡൻസികൾക്കായുള്ള വിപുലമായ മാവൻ ടെക്നിക്കുകൾ

Maven ഉപയോഗിച്ച് ഒരു എക്സിക്യൂട്ടബിൾ JAR സൃഷ്ടിക്കുന്നതിനുള്ള അടിസ്ഥാന കോൺഫിഗറേഷനുപുറമെ, നിങ്ങളുടെ ബിൽഡ് പ്രോസസ്സ് മെച്ചപ്പെടുത്താൻ കഴിയുന്ന അധിക ടെക്നിക്കുകൾ ഉണ്ട്. അത്തരം ഒരു സാങ്കേതികത ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു shade പകരം പ്ലഗിൻ assembly പ്ലഗിൻ. മാവെൻ ഷേഡ് പ്ലഗിൻ uber-JAR-കൾ (ഡിപൻഡൻസികൾ ഉൾപ്പെടുന്ന JAR-കൾ) സൃഷ്‌ടിക്കുന്നതിന് കൂടുതൽ വിപുലമായ സവിശേഷതകൾ വാഗ്ദാനം ചെയ്യുന്നു. ക്ലാസ്പാത്ത് വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാൻ പാക്കേജുകളുടെ പേരുമാറ്റാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു കൂടാതെ ഡ്യൂപ്ലിക്കേറ്റ് ക്ലാസുകൾക്കും ഉറവിടങ്ങൾക്കും മികച്ച കൈകാര്യം ചെയ്യൽ നൽകുന്നു. കൂടാതെ, അന്തിമ JAR-ൽ ഏതൊക്കെ ഡിപൻഡൻസികൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് എന്നതിനെക്കുറിച്ചുള്ള സൂക്ഷ്മമായ നിയന്ത്രണം ഇത് വാഗ്ദാനം ചെയ്യുന്നു.

നിങ്ങളുടെ JAR ഫയലിൻ്റെ വലുപ്പം നിയന്ത്രിക്കുക എന്നതാണ് മറ്റൊരു പ്രധാന വശം. വലിയ JAR ഫയലുകൾ ബുദ്ധിമുട്ടുള്ളതും കൈമാറ്റം ചെയ്യുന്നതിനോ ലോഡുചെയ്യുന്നതിനോ മന്ദഗതിയിലായേക്കാം. ദി maven-shade-plugin അനാവശ്യമായ ഫയലുകളും ക്ലാസുകളും ഒഴിവാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നതിലൂടെ, അന്തിമ JAR-ൻ്റെ വലുപ്പം കുറയ്ക്കാൻ ഇത് സഹായിക്കും. ഉപയോഗിക്കാത്ത ക്ലാസുകൾ അല്ലെങ്കിൽ അനാവശ്യ ഉറവിടങ്ങൾ പോലുള്ള അവശ്യമല്ലാത്ത വിവരങ്ങൾ നീക്കം ചെയ്തുകൊണ്ട് JAR ചെറുതാക്കാൻ നിങ്ങൾക്ക് പ്ലഗിൻ കോൺഫിഗർ ചെയ്യാനും കഴിയും. നിരവധി ഡിപൻഡൻസികളുള്ള വലിയ പ്രോജക്ടുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഈ വിപുലമായ കോൺഫിഗറേഷനുകൾ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

മാവെൻ എക്സിക്യൂട്ടബിൾ ജാറുകളെ കുറിച്ചുള്ള സമാപന ചിന്തകൾ

Maven ഉപയോഗിച്ച് ഡിപൻഡൻസികൾ ഉപയോഗിച്ച് എക്സിക്യൂട്ടബിൾ JAR സൃഷ്ടിക്കുന്നത് ജാവ ആപ്ലിക്കേഷനുകൾക്കുള്ള വിന്യാസ പ്രക്രിയ ലളിതമാക്കുന്നു. ശരിയായി ക്രമീകരിച്ചുകൊണ്ട് pom.xml ഫയൽ ചെയ്ത് Maven അസംബ്ലി പ്ലഗിൻ അല്ലെങ്കിൽ Maven Shade Plugin പോലുള്ള പ്ലഗിനുകൾ ഉപയോഗിക്കുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് ആവശ്യമായ എല്ലാ ഡിപൻഡൻസികളും ഒരൊറ്റ JAR ഫയലിലേക്ക് പാക്കേജ് ചെയ്യാൻ കഴിയും. ഈ സമീപനം, വിതരണവും നിർവ്വഹണവും നേരായതാക്കുന്ന, വിവിധ പരിതസ്ഥിതികളിൽ ആപ്ലിക്കേഷന് തടസ്സമില്ലാതെ പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു. ഈ ഘട്ടങ്ങൾ പാലിക്കുന്നത് നിങ്ങളുടെ പ്രോജക്റ്റിൻ്റെ ഡിപൻഡൻസികൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാനും വിശ്വസനീയവും എക്‌സിക്യൂട്ടബിൾ JAR ഫയലുകൾ സൃഷ്ടിക്കാനും നിങ്ങളെ സഹായിക്കും.