Maven નો ઉપયોગ કરીને નિર્ભરતા સાથે એક્ઝિક્યુટેબલ JAR બનાવવું

સિંગલ એક્ઝિક્યુટેબલ JAR માં મેવેન પ્રોજેક્ટ્સનું પેકેજિંગ

Java પ્રોજેક્ટ્સ સાથે કામ કરતી વખતે, સરળ વિતરણ માટે તમારી એપ્લિકેશનને એક જ એક્ઝિક્યુટેબલ 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

પેકેજિંગ અવલંબન માટે અદ્યતન માવેન તકનીકો

Maven સાથે એક્ઝિક્યુટેબલ JAR બનાવવા માટે મૂળભૂત રૂપરેખાંકન ઉપરાંત, ત્યાં વધારાની તકનીકો છે જે તમારી બિલ્ડ પ્રક્રિયાને વધારી શકે છે. આવી એક તકનીકનો ઉપયોગ કરવાનો સમાવેશ થાય છે shade ના બદલે પ્લગઇન assembly માં નાખો. મેવેન શેડ પ્લગઇન uber-JARs બનાવવા માટે વધુ અદ્યતન સુવિધાઓ પ્રદાન કરે છે (નિર્ભરતા સાથે JARs શામેલ છે). તે તમને ક્લાસપાથ તકરારને ટાળવા માટે પેકેજોનું નામ બદલવાની પરવાનગી આપે છે અને ડુપ્લિકેટ વર્ગો અને સંસાધનો માટે વધુ સારી રીતે હેન્ડલિંગ પ્રદાન કરે છે. વધુમાં, તે અંતિમ JAR માં કઈ અવલંબનનો સમાવેશ થાય છે તેના પર ઝીણવટપૂર્વકનું નિયંત્રણ આપે છે.

અન્ય મહત્વપૂર્ણ પાસું તમારી JAR ફાઇલના કદનું સંચાલન કરવાનું છે. મોટી JAR ફાઇલો બોજારૂપ અને ટ્રાન્સફર અથવા લોડ કરવામાં ધીમી હોઇ શકે છે. આ maven-shade-plugin તમને બિનજરૂરી ફાઇલો અને વર્ગોને બાકાત રાખવાની મંજૂરી આપીને આમાં મદદ કરી શકે છે, આમ અંતિમ JAR નું કદ ઘટાડવું. તમે બિન-આવશ્યક માહિતી જેમ કે બિનઉપયોગી વર્ગો અથવા બિનજરૂરી સંસાધનો દૂર કરીને JAR ને ઘટાડવા માટે પ્લગઇનને પણ ગોઠવી શકો છો. અસંખ્ય અવલંબન સાથે મોટા પ્રોજેક્ટ્સ પર કામ કરતી વખતે આ અદ્યતન રૂપરેખાંકનો ખાસ કરીને ઉપયોગી થઈ શકે છે.

માવેન એક્ઝિક્યુટેબલ JARs પરના વિચારોના નિષ્કર્ષ

મેવનનો ઉપયોગ કરીને નિર્ભરતા સાથે એક્ઝિક્યુટેબલ JAR બનાવવાથી Java એપ્લિકેશનો માટે જમાવટ પ્રક્રિયા સરળ બને છે. યોગ્ય રીતે રૂપરેખાંકિત કરીને pom.xml ફાઇલ અને મેવેન એસેમ્બલી પ્લગઇન અથવા મેવેન શેડ પ્લગઇન જેવા પ્લગિન્સનો ઉપયોગ કરીને, વિકાસકર્તાઓ તમામ જરૂરી નિર્ભરતાને એક જ JAR ફાઇલમાં પેકેજ કરી શકે છે. આ અભિગમ સુનિશ્ચિત કરે છે કે એપ્લિકેશન વિવિધ વાતાવરણમાં એકીકૃત રીતે ચાલી શકે છે, વિતરણ અને અમલીકરણને સરળ બનાવે છે. આ પગલાંને અનુસરવાથી તમને તમારા પ્રોજેક્ટની નિર્ભરતાને અસરકારક રીતે સંચાલિત કરવામાં અને વિશ્વસનીય, એક્ઝિક્યુટેબલ JAR ફાઇલો બનાવવામાં મદદ મળશે.