මාවන් ව්‍යාපෘතියකට දේශීය භාජන ගොනු එකතු කරන්නේ කෙසේද?

මගේ ව්‍යාපෘතියේ පුස්තකාල ප්‍රභවයන් වෙත දේශීය භාජන ලිපිගොනු (තවමත් මාවන් ගබඩාවේ කොටසක් නොවේ) එකතු කරන්නේ කෙසේද?

පහත දැක්වෙන පරිදි ඔබේ දේශීය මේවන් ගබඩාවට JAR ස්ථාපනය කරන්න:

mvn install:install-file \
   -Dfile=<path-to-file> \
   -DgroupId=<group-id> \
   -DartifactId=<artifact-id> \
   -Dversion=<version> \
   -Dpackaging=<packaging> \
   -DgeneratePom=true

එක් එක් සඳහන් වන්නේ:

<path-to-file>: උදා. පැටවීම සඳහා ගොනුවට යන මාර්ගය c:\kaptcha-2.3.jar

<group-id>: උදා: under යටතේ ගොනුව ලියාපදිංචි කළ යුතු කණ්ඩායම com.google.code

<artifact-id>: උදා: file ගොනුව සඳහා පුරාවස්තු නම kaptcha

<version>: ගොනුවේ අනුවාදය උදා. 2.3

<packaging>: ගොනුවේ ඇසුරුම් කිරීම උදා. jar

යොමුව

• මේවන් නිති අසන ප්‍රශ්න: මගේ දේශීය ගබඩාවට දැමීමට අවශ්‍ය භාජනයක් මා සතුව ඇත. මම එය පිටපත් කරන්නේ කෙසේද?
• : හොදම විදිය තමයි භාවිතය ස්ථාපනය ලැබෙන කව්ලුවේ ඇති install:install-fileඉලක්කය

ඔබට දේශීය යැපීම් කෙලින්ම එකතු කළ හැකිය ( හිමිකාර පුස්තකාල ඇතුළත් බිල්ඩ් මේවන් ව්‍යාපෘතියේ සඳහන් පරිදි ):

<dependency>
    <groupId>com.sample</groupId>
    <artifactId>sample</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/src/main/resources/Name_Your_JAR.jar</systemPath>
</dependency>

යාවත්කාලීන කරන්න

නව නිකුතුවලදී මෙම අංගය අවලංගු කර ඇති නමුත් තවමත් ක්‍රියා කර ඇති අතර තවමත් ඉවත් කර නොමැත (මේවන් ආරම්භයේදී ඔබට ලොගයේ අනතුරු ඇඟවීමක් පෙනේ). මේ පිළිබඳව මේවන් කණ්ඩායමේ ප්‍රශ්නයක් මතු වේ https://issues.apache.org/jira/browse/MNG-6523 (සමහර අවස්ථාවලදී මෙම අංගය ප්‍රයෝජනවත් වන්නේ මන්දැයි ඔබට සහභාගී වී විස්තර කළ හැකිය). මෙම අංගය එහි පවතිනු ඇතැයි මම බලාපොරොත්තු වෙමි!

ඔබ මගෙන් අසන්නේ නම්, විශේෂාංගය ඉවත් නොකරන තාක් කල්, මම මෙය භාවිතා කරමි කරන්නේ මගේ ව්‍යාපෘතියේ එක් නපුරු භාජන ගොනුවකට පමණක් යැපීමටය, එය ගබඩාවට නොගැලපේ. මෙම අංගය ඉවත් කළ හොත්, මට පසුව තෝරා ගත හැකි හොඳ පිළිතුරු ගොඩක් තිබේ!

පළමුවෙන්ම, මම මෙම පිළිතුර සඳහා නිර්නාමික ස්ටැක් පිටාර ගැලීම් පරිශීලකයෙකුට ගෞරවය දීමට කැමතියි - මීට පෙරද මෙවැනිම පිළිතුරක් මා දැක ඇති බව මට විශ්වාසයි - නමුත් දැන් මට එය සොයාගත නොහැක.

දේශීය JAR ලිපිගොනු යැපීමක් ලෙස තබා ගැනීම සඳහා හොඳම විකල්පය වන්නේ දේශීය Maven ගබඩාවක් නිර්මාණය කිරීමයි. එවැනි ගබඩාවක් යනු එහි ඇති pom ගොනු සහිත නිසි නාමාවලි ව්‍යුහයකට වඩා වැඩි දෙයක් නොවේ.

මගේ උදාහරණය සඳහා: ${master_project}ස්ථානය පිළිබඳ මගේ ප්‍රධාන ව්‍යාපෘතිය මා සතුව ඇති අතර උප ප්‍රොජෙක්ට් 1 ක්‍රියාත්මක වේ ${master_project}/${subproject1}.

ඉන්පසු මම මේවන් ගබඩාවක් සාදන්නේ : ${master_project}/local-maven-repo.

උප ප්‍රොජෙක්ට් 1 හි ඇති පොම් ගොනුවේ ${master_project}/${subproject1}/pom.xml, URL පරාමිතියක් ලෙස ගොනු මාර්ගය ගත හැකි නිධිය නියම කළ යුතුය:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.parent.basedir}/local-maven-repo</url>
    </repository>
</repositories>

වෙනත් ඕනෑම ගබඩාවකට මෙන් පරායත්තතාවය නියම කළ හැකිය. මෙය ඔබගේ pom ගබඩාව ස්වාධීන කරයි. නිදසුනක් ලෙස, අපේක්ෂිත JAR මේවන් සෙන්ට්‍රල් වෙතින් ලබා ගත් පසු, ඔබ එය ඔබගේ දේශීය ගබඩාවෙන් මකා දැමිය යුතු අතර එය පෙරනිමි repo වෙතින් ඇද ගනු ඇත.

    <dependency>
        <groupId>org.apache.felix</groupId>
        <artifactId>org.apache.felix.servicebinder</artifactId>
        <version>0.9.0-SNAPSHOT</version>
    </dependency>

කළ යුතු අවසාන හා අවම දෙය නම් -DlocalRepositoryPath ස්විචය භාවිතා කරමින් JAR ගොනුව දේශීය ගබඩාවට එක් කිරීමයි.

mvn org.apache.maven.plugins:maven-install-plugin:2.5.2:install-file  \
    -Dfile=/some/path/on/my/local/filesystem/felix/servicebinder/target/org.apache.felix.servicebinder-0.9.0-SNAPSHOT.jar \
    -DgroupId=org.apache.felix -DartifactId=org.apache.felix.servicebinder \
    -Dversion=0.9.0-SNAPSHOT -Dpackaging=jar \
    -DlocalRepositoryPath=${master_project}/local-maven-repo

JAR ගොනුව ස්ථාපනය කළ පසු, ඔබේ Maven repo කේත ගබඩාවකට කැපවිය හැකි අතර, මුළු සැකසුමම පද්ධතියෙන් ස්වාධීන වේ. ( GitHub හි වැඩ කරන උදාහරණය ).

ප්‍රභව කේත රෙපෝ සඳහා JARs කැපවීම හොඳ පුරුද්දක් නොවන බව මම එකඟ වෙමි, නමුත් සැබෑ ජීවිතයේ දී, ඔබට ප්‍රකාශයට පත් කළ නොහැකි එක් JAR එකක් සත්කාරකත්වය සැපයීම සඳහා සම්පූර්ණ පිපිරුණු නෙක්සස් රෙපෝවට වඩා ඉක්මන් හා අපිරිසිදු විසඳුම් සමහර විට වඩා හොඳය.

නව ෆෝල්ඩරයක් සාදන්න, අපි කියමු local-maven-repo ඔබගේ මාවන් ව්‍යාපෘතියේ මුලදී .

ඔබගේ ඇතුළත දේශීය රෙපෝවක් එක් <project>කරන්න pom.xml:

<repositories>
    <repository>
        <id>local-maven-repo</id>
        <url>file:///${project.basedir}/local-maven-repo</url>
    </repository>
</repositories>

ඔබට ස්ථාපනය කිරීමට අවශ්‍ය සෑම බාහිර භාජනයක් සඳහාම, ඔබේ ව්‍යාපෘතියේ මුල වෙත ගොස් ක්‍රියාත්මක කරන්න:

mvn deploy:deploy-file -DgroupId=[GROUP] -DartifactId=[ARTIFACT] -Dversion=[VERS] -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=[FILE_PATH]

මම එවැනි විසඳුමකට කැමතියි - maven-install-pluginpom ගොනුවේ භාවිතා කරන්න:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <file>lib/yourJar.jar</file>
                <groupId>com.somegroup.id</groupId>
                <artifactId>artefact-id</artifactId>
                <version>x.y.z</version>
                <packaging>jar</packaging>
            </configuration>
        </execution>
    </executions>
</plugin>

මෙම අවස්ථාවේ දී ඔබට ඉටු කළ හැකි mvn initializeඅතර භාජනය දේශීය මේවන් රෙපෝ තුළ ස්ථාපනය කෙරේ. දැන් මෙම භාජනය මෙම යන්ත්‍රයේ ඕනෑම පියවරකදී ලබා ගත හැකිය (මෙම යැපීම වෙනත් ඕනෑම මේවන් යැපීමක් ලෙස pom <dependency></dependency>ටැගය සමඟ ඇතුළත් කිරීමට අමතක නොකරන්න ). බඳුන් ස්ථාපනය කිරීම initializeපියවරක් නොව, ඔබ කැමති වෙනත් ඕනෑම පියවරක් බැඳ තැබිය හැකිය .

<dependency>
    <groupId>group id name</groupId>
    <artifactId>artifact name</artifactId>
    <version>version number</version>
    <scope>system</scope>
    <systemPath>jar location</systemPath>
</dependency>

ඔව්, ඔබට තිබිය හැකි නමුත් එය හොඳ අදහසක් නොවේ.

ඒ වෙනුවට මේ භාජන සියල්ලම මේවන් ගබඩාවලට සවි කරන්න

එසේම බලන්න

• හිමිකාර පුස්තකාල සමඟ මේවන් ව්‍යාපෘතිය ගොඩනගන්නේ කෙසේද?

සැබවින්ම ඉක්මන් හා අපිරිසිදු ක්‍රමය වන්නේ දේශීය ගොනුවකට යොමු කිරීමයි:

<dependency>
      <groupId>sample</groupId>  
       <artifactId>com.sample</artifactId>  
       <version>1.0</version> 
      <scope>system</scope>
      <systemPath>C:\DEV\myfunnylib\yourJar.jar</systemPath>
</dependency>

කෙසේ වෙතත් මෙය ඔබගේ යන්ත්‍රය මත පමණක් ජීවත් වනු ඇත (පැහැදිලිවම), එය බෙදා ගැනීම සඳහා සාමාන්‍යයෙන් නිසි m2 ලේඛනාගාරයක් (නෙක්සස් / කෞතුක වස්තුවක්) භාවිතා කිරීම අර්ථවත් කරයි හෝ ඔබට මේ කිසිවක් නොමැති නම් හෝ දේශීය මේවන් එකක් සැකසීමට අවශ්‍ය නොවන්නේ නම් ව්‍යුහගත ලේඛනාගාරයක් සහ ඔබේ පොම් එකේ “ගබඩාවක්” වින්‍යාස කරන්න: local:

<repositories>
    <repository>
        <id>my-local-repo</id>
        <url>file://C:/DEV//mymvnrepo</url>
    </repository>
</repositories>

දුරස්ථ:

<repositories>
    <repository>
        <id>my-remote-repo</id>
        <url>http://192.168.0.1/whatever/mavenserver/youwant/repo</url>
    </repository>
</repositories>

මේ සඳහා පදනම් වූ විචල්‍යය භාවිතා කරමින් සාපේක්ෂ මාර්ගයක් ද කළ හැකිය:

<url>file:${basedir}</url>

POM ගොනුවේ ඔබේම දේශීය JAR එකතු කර එය maven build හි භාවිතා කරන්න.

mvn install:install-file -Dfile=path-to-jar -DgroupId=owngroupid -DartifactId=ownartifactid -Dversion=ownversion -Dpackaging=jar

උදාහරණයක් වශයෙන්:

mvn install:install-file -Dfile=path-to-jar -DgroupId=com.decompiler -DartifactId=jd-core-java -Dversion=1.2 -Dpackaging=jar

ඉන්පසු එය මේ ආකාරයට POM වෙත එක් කරන්න:

පරායත්තතාවයේ වැදගත් කොටස: $ om pom.basedir} ( $ {basedir} වෙනුවට)

<dependency>
    <groupId>org.example</groupId>
    <artifactId>example</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${pom.basedir}/src/lib/example.jar</systemPath>
</dependency>

එක් ක්‍රමයක් නම් එය ඔබේම මාවන් නිධිය කළමණාකරුට (නෙක්සස් වැනි) උඩුගත කිරීමයි. කෙසේ හෝ තමන්ගේම නිධිය කළමණාකරුවෙකු සිටීම හොඳ පුරුද්දකි.

මම මෑතකදී දුටු තවත් හොඳ ක්‍රමයක් නම්, ඔබේ ගොඩනැඟීමේ ජීවන චක්‍රයට මාවන් ස්ථාපනය ප්ලගිනය ඇතුළත් කිරීමයි: දේශීය ගබඩාවට ගොනු ස්ථාපනය කිරීමට ඔබ POM හි ප්‍රකාශ කරයි. එය කුඩා නමුත් කුඩා පොදු කාර්යයක් වන අතර අතින් පියවරක් නොමැත.

http://maven.apache.org/plugins/maven-install-plugin/install-file-mojo.html

ඇත්ත වශයෙන්ම ඔබට එම ෆෝල්ඩරයට භාජන එකතු කළ හැකිය. නමුත් සමහර විට එය ඔබට ළඟා කර ගැනීමට අවශ්‍ය දේ නොවේ ...

සම්පාදනය සඳහා ඔබට මෙම භාජන අවශ්‍ය නම්, මෙම අදාළ ප්‍රශ්නය පරීක්ෂා කරන්න: ඒවා ස්ථාපනය නොකර මේවන් 2 බිල්ඩ් පංති පථයට භාජන එක් කළ හැකිද?

එසේම, කිසිවෙකු එය යෝජනා කිරීමට පෙර, පද්ධති විෂය පථය භාවිතා නොකරන්න.

තවත් සිත්ගන්නා කරුණක් වන්නේ ඔබේ ව්‍යාපෘතියේ පෞද්ගලික මේවන් භාජන තබා ගැනීමට ඔබට අවශ්‍ය වූ විටය. සංක්‍රාන්ති පරායත්තතා නිරාකරණය කිරීම සඳහා මාවන්ගේ හැකියාවන් තබා ගැනීමට ඔබට අවශ්‍ය විය හැකිය. විසඳුම තරමක් පහසුය.

1. ෆෝල්ඩර ලිබ්ස් සාදන්නඔබේ ව්යාපෘතියේ

2. ඔබගේ pom.xml ගොනුවේ පහත පේළි එක් කරන්න

   <properties><local.repository.folder>${pom.basedir}/libs/</local.repository.folder>
   </properties>
   
   <repositories>
      <repository>
           <id>local-maven-repository</id>
           <url>file://${local.repository.folder}</url>
           <releases>
               <enabled>true</enabled>
           </releases>
           <snapshots>
               <enabled>true</enabled>
           </snapshots>
      </repository>
   </repositories>

3. .M2 / repository ෆෝල්ඩරය විවෘත කර ඔබට ලිබ්ස් ෆෝල්ඩරයට ආනයනය කිරීමට අවශ්‍ය ව්‍යාපෘතියේ නාමාවලි ව්‍යුහය පිටපත් කරන්න .

උදා: ඔබට යැපීම ආනයනය කිරීමට අවශ්‍ය යැයි සිතමු

<dependency>
    <groupId>com.mycompany.myproject</groupId>
    <artifactId>myproject</artifactId>
    <version>1.2.3</version>
</dependency>

යන්තම් යන්න .m2 / ගබඩාව සහ ඔබ පහත සඳහන් ෆෝල්ඩරය දකිනු ඇත

com / mycompany / myproject / 1.2.3

ඔබගේ ලිබ්ස් ෆෝල්ඩරයේ ඇති සියල්ල පිටපත් කරන්න (නැවතත්, .m2 / repository යටතේ ඇති ෆෝල්ඩර ඇතුළුව ) ඔබ අවසන් කර ඇත.

විධාන රේඛාව:

mvn install:install-file -Dfile=c:\kaptcha-{version}.jar -DgroupId=com.google.code
-DartifactId=kaptcha -Dversion={version} -Dpackaging=jar

මෙය නව සංස්කරණ සඳහා කෙටි වාක්‍ය ඛණ්ඩයකි:

mvn install:install-file -Dfile=<path-to-file>

එය ක්‍රියාත්මක වන්නේ JAR අපාචි මාවන් විසින් ගොඩනඟන විටය - වඩාත් පොදු අවස්ථාව. එවිට එය META-INF නාමාවලියේ උප ෆෝල්ඩරයක pom.xml අඩංගු වන අතර එය පෙරනිමියෙන් කියවනු ලැබේ.

මුලාශ්‍රය: http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html

මෙම ගැටළුවට වඩා හොඳ විසඳුමක් වනුයේ ස්ථාපනය කරන වේලාවේදී ගොනු ස්වයංක්‍රීයව ස්ථාපනය කිරීම සඳහා maven-install-plugin භාවිතා කිරීමයි . මගේ ව්‍යාපෘතිය සඳහා මම එය සකසා ඇත්තේ එලෙසිනි.

පළමුව, මාර්ගය (ඔබ දේශීය .jars ගබඩා කරන ස්ථානය) දේපලක් ලෙස එක් කරන්න.

<properties>
    <local.sdk>/path/to/jar</local.sdk>
</properties>

ඉන්පසු, pluginsසම්පාදනය කිරීමේදී භාජන ස්ථාපනය කිරීම සඳහා ප්ලගිනයක් එක් කරන්න.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <version>2.5.2</version>
    <executions>
        <execution>
            <id>1</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId> 
                <artifactId>appengine-api</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api.jar</file>
            </configuration>
        </execution>
        <execution>
            <id>appengine-api-stubs</id>
            <phase>initialize</phase>
            <goals>
                <goal>install-file</goal>
            </goals>
            <configuration>
                <groupId>com.local.jar</groupId>
                <artifactId>appengine-api-stubs</artifactId>
                <version>1.0</version>
                <packaging>jar</packaging>
                <file>${local.sdk}/lib/impl/appengine-api-stubs.jar</file>
            </configuration>
        </execution>
    </executions>
</plugin>

අවසාන වශයෙන්, පරායත්තතාවයන්හිදී, ඔබට භාජන එකතු කළ හැකිය

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api</artifactId>
    <version>1.0</version>
</dependency>

<dependency>
    <groupId>com.local.jar</groupId>
    <artifactId>appengine-api-stubs</artifactId>
    <version>1.0</version>
    <scope>test</scope>
</dependency>

ඔබේ ව්‍යාපෘතිය මේ ආකාරයෙන් සැකසීමෙන්, ඔබ එය වෙනත් පරිගණකයකට ගෙන ගිය විට පවා ව්‍යාපෘතිය දිගටම ගොඩනගනු ඇත (දේපල මගින් නියම කර ඇති මාර්ගයේ සියලුම භාජන ගොනු ඇති බැවින්) local.sdk ).

සඳහා groupIdභාවිතා අද්විතීය නමක් පමණක් කිසිදු ගැටුම් පවතින බව තහවුරු කර ගන්න.

දැන් ඔබ mvn installහෝ mvn testදේශීය භාජන ස්වයංක්‍රීයව එකතු වන විට.

වඩාත් කැමති ක්‍රමය වනුයේ ඔබේම දුරස්ථ ගබඩාවක් නිර්මාණය කිරීමයි.

එය කරන්නේ කෙසේද යන්න පිළිබඳ විස්තර සඳහා මෙහි බලන්න . ' දුරස්ථ ගබඩාවකට උඩුගත කිරීම ' කොටස බලන්න.

භාජන වලින් පිරුණු ෆෝල්ඩරයක් උඩුගත කළ හැකි කේතයක් බෙදා ගැනීමට මට අවශ්‍යය. සැපයුම්කරුවකුට පොදු ගබඩාවක් නොමැති විට එය ප්‍රයෝජනවත් වන අතර ඔබට පුස්තකාල රාශියක් අතින් එකතු කළ යුතුය. මම කෙලින්ම මේවන් වෙත ඇමතීම වෙනුවට .bat එකක් සෑදීමට තීරණය කර ඇත්තේ එය මතක දෝෂ වලින් තොර විය හැකි බැවිනි. එය වින්ඩෝස් පරිසරයක් සඳහා සකස් කර ඇති නමුත් එය ලිනක්ස් මෙහෙයුම් පද්ධතියට අනුවර්තනය කිරීම පහසුය:

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class CreateMavenRepoApp {

    private static final String OCB_PLUGIN_FOLDER = "C://your_folder_with_jars";

    public static void main(String[] args) throws IOException {

    File directory = new File();
    //get all the files from a directory
    PrintWriter writer = new PrintWriter("update_repo_maven.bat", "UTF-8");
    writer.println("rem "+ new Date());  
    File[] fList = directory.listFiles();
    for (File file : fList){
        if (file.isFile()){               
        String absolutePath = file.getAbsolutePath() ;
        Manifest  m = new JarFile(absolutePath).getManifest();
        Attributes attributes = m.getMainAttributes();
        String symbolicName = attributes.getValue("Bundle-SymbolicName");

        if(symbolicName!=null &&symbolicName.contains("com.yourCompany.yourProject")) {
            String[] parts =symbolicName.split("\\.");
            String artifactId = parts[parts.length-1];
            String groupId = symbolicName.substring(0,symbolicName.length()-artifactId.length()-1);
            String version = attributes.getValue("Bundle-Version");
            String mavenLine= "call mvn org.apache.maven.plugins:maven-install-plugin:2.5.1:install-file -Dfile="+ absolutePath+" -DgroupId="+ groupId+" -DartifactId="+ artifactId+" -Dversion="+ version+" -Dpackaging=jar ";
            writer.println(mavenLine);          
        }

        }
    }
    writer.close();
    }

}

ඕනෑම IDE එකකින් මෙම ප්‍රධාන ධාවනය කිරීමෙන් පසු, update_repo_maven.bat ධාවනය කරන්න.

එසේම බලන්න ...

<scope>compile</scope>

මාවන් යැපීම් . මෙය පෙරනිමිය වන නමුත් සමහර අවස්ථාවල දී දේශීය ගබඩාවේ දේශීය පුස්තකාල සොයා ගැනීම සඳහා මේවන් විෂය පථය පැහැදිලිවම සකසා ඇති බව මට පෙනී ගියේය.

කිසියම් හේතුවක් නිසා, මම නඩත්තු කරන වෙබ් යෙදුමේ දී, අලිරීසා ෆටාහිගේ විසඳුම හෝ ජේ. ජේ. රෝමන්ගේ විසඳුම නිවැරදිව ක්‍රියාත්මක වූයේ නැත. අවස්ථා දෙකේදීම, සම්පාදනය හරි යයි (එය බඳුන දකිනවා), නමුත් ඇසුරුම්කරණය යුද්ධය තුළ භාජනය ඇතුළත් කිරීමට අසමත් වේ.

මම එය ක්‍රියාත්මක කිරීමට සමත් වූ එකම ක්‍රමය වූයේ භාජනය දමා /src/main/webapp/WEB-INF/lib/එය ෆටාහිස්ගේ හෝ රෝමගේ විසඳුම සමඟ ඒකාබද්ධ කිරීමයි.

පියවර 1: ඔබේ maven-install-pluginඉලක්කය සමඟ වින්‍යාස install-fileකරන්නpom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-install-plugin</artifactId>
    <executions>
        <execution>
            <id>install-external-non-maven-jar-MWS-Client-into-local-maven-repo</id>
            <phase>clean</phase>
            <configuration>
                <repositoryLayout>default</repositoryLayout>
                <groupId>com.amazonservices.mws</groupId>
                <artifactId>mws-client</artifactId>
                <version>1.0</version>
                <file>${project.basedir}/lib/MWSClientJavaRuntime-1.0.jar</file>
                <packaging>jar</packaging>
                <generatePom>true</generatePom>
            </configuration>
            <goals>
                <goal>install-file</goal>
            </goals>
        </execution>
    </executions>
</plugin>

fileඔබගේ සත්‍ය ගොනු මාර්ගය මත පදනම්ව මාර්ගය සංස්කරණය කිරීමට වග බලා ගන්න (නිර්දේශිත වන්නේ මෙම බාහිර නොවන භාජන කිසියම් ෆෝල්ඩරයක් තුළ තැබීමයි, අපි කියමු lib, මෙය තබන්නlib ෆෝල්ඩරය ඔබේ ව්‍යාපෘතිය තුළ තබන්න. නිශ්චිත නිරපේක්ෂ මාර්ගය.

ඔබට බාහිර භාජන කිහිපයක් තිබේ නම්, <execution>අනෙක් භාජන සඳහා එකම දේ නැවත කරන්න maven-install-plugin.

පියවර 2:maven-install-plugin ඔබේ pom.xmlගොනුවේ ඉහත පෙන්වා ඇති පරිදි වින්‍යාස කිරීමෙන් පසු , pom.xmlසුපුරුදු පරිදි මෙම භාජන භාවිතා කළ යුතුය :

    <dependency>
        <groupId>com.amazonservices.mws</groupId>
        <artifactId>mws-client</artifactId>
        <version>1.0</version>
    </dependency>

maven-install-pluginඔබගේ බාහිර භාජන ඔබේ දේශීය .m2මේවන් ගබඩාවට පිටපත් කරන බව සලකන්න . ඒක තමයි. එය ස්වයංක්‍රීයව මෙම භාජන ඔබේ ව්‍යාපෘතියට යැපෙන පරායත්තයන් ලෙස ඇතුළත් නොකරයි.

එය සුළු කාරණයක්, නමුත් සමහර විට මග හැරීමට පහසුය.

දේශීය repo එකක් භාවිතා කිරීම හොඳ අදහසක් නොවන බව සලකන්න. මෙම ව්‍යාපෘතිය අන් අය සමඟ බෙදාගනු ලැබුවහොත් එය ක්‍රියාත්මක නොවන විට අනෙක් සියල්ලන්ටම ගැටළු සහ ප්‍රශ්න ඇති වන අතර ඔබේ ප්‍රභව පාලන පද්ධතියේ පවා භාජනය ලබාගත නොහැක!

බෙදාගත් repo හොඳම පිළිතුර වුවද, ඔබට කිසියම් හේතුවක් නිසා මෙය කළ නොහැකි නම්, භාජනය කාවැද්දීම දේශීය repo එකකට වඩා හොඳය. දේශීය-පමණක් රෙපෝ අන්තර්ගතයන් බොහෝ ගැටලු ඇති කළ හැකිය, විශේෂයෙන් කාලයත් සමඟ.

ඔබේ දේශීය ගබඩාවේ විධාන නිකුත් කිරීමෙන් ඔබේ භාජනය ස්ථාපනය කළ හැකිය

 mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> \
-DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>

Mkyoung ගේ වෙබ් අඩවියෙන් එය කිරීමට මෙම ප්‍රයෝජනවත් සබැඳිය අනුගමනය කරන්න . ඔබට ඒ සඳහා මේවන් මාර්ගෝපදේශය ද පරීක්ෂා කළ හැකිය

තෙවන පාර්ශවීය භාජනයක් ස්ථාපනය කිරීමට, කරුණාකර පහත විධානය අමතන්න

mvn install:install-file -DgroupId= -DartifactId= -Dversion= -Dpackaging=jar -Dfile=path

1. mvn ස්ථාපනය කරන්න

ඔබට පහත කේතය විධාන රේඛාවෙන් ලිවිය හැකිය, නැතහොත් ඔබ සූර්යග්‍රහණ බිල්ඩින් මේවන් භාවිතා කරන්නේ නම් ව්‍යාපෘතිය මත දකුණු ක්ලික් කරන්න -> ධාවනය කරන්න -> වින්‍යාසයන් ධාවනය කරන්න ... -> වම් පුවරුවේ දකුණු පස මාවන් බිල්ඩ් -> නව වින්‍යාසය -> ලියන්න ඉලක්කයන් සහ මූලික නාමාවලියෙහි කේතය: $ {project_loc: NameOfYourProject} -> ධාවනය කරන්න

mvn install:install-file
   -Dfile=<path-to-file>
   -DgroupId=<group-id>
   -DartifactId=<artifact-id>
   -Dversion=<version>
   -Dpackaging=<packaging>
   -DgeneratePom=true

එක් එක් සඳහන් වන්නේ:

<path-to-file>: පූරණය කිරීමට ගොනුවට යන මාර්ගය උදා -> c: a kaptcha-2.3.jar

<group-id>: ගොනුව උදා -> com.google.code යටතේ ලියාපදිංචි කළ යුතු කණ්ඩායම

<artifact-id>: ගොනුවේ පුරාවස්තු නම උදා -> kaptcha

<version>: ගොනුවේ අනුවාදය උදා -> 2.3

<ඇසුරුම්කරණය: ගොනුවේ ඇසුරුම් කිරීම උදා -> භාජනය

2. ස්ථාපනය කිරීමෙන් පසු, pom.xml හි භාජනය ප්‍රකාශ කරන්න.

 <dependency>
      <groupId>com.google.code</groupId>
      <artifactId>kaptcha</artifactId>
      <version>2.3</version>
 </dependency>

මගේ pom.xml හි පරායත්තතා සමූහයක් සඳහා මට එකම දෝෂයක් ඇති අතර, පරායත්තතාවයේ අනුවාදයන් pom.xml හි නිශ්චිතව දක්වා නොමැති අතර එය මව් ගබඩාවේ සඳහන් කර ඇත. කිසියම් හේතුවක් නිසා අනුවාදයේ විස්තර මෙම repo සමඟ සමමුහුර්ත නොවීය. එබැවින් මම ටැගය භාවිතා කරමින් අනුවාදයන් අතින් ඇතුල් කළ අතර එය චාම් එකක් මෙන් ක්‍රියා කළේය. දෙමව්පියන්ගේ අනුවාදයන් සොයා බලා මෙහි සඳහන් කිරීමට සුළු කාලයක් අවශ්‍ය වේ. නමුත් මෙය කළ හැක්කේ පුරාවිද්‍යාත්මක දෝෂය පෙන්වන භාජන සඳහා වන අතර එය ක්‍රියාත්මක වේ. මෙය යමෙකුට උපකාරී වේ යැයි සිතමි.

Apache Maven 3.5.4 හි මට ද්විත්ව උපුටා දැක්වීම් එකතු කිරීමට සිදුවිය. ද්විත්ව උපුටා දැක්වීමකින් තොරව එය මට වැඩ කළේ නැත.

උදාහරණය: mvn install: install-file "-Dfile = භාජන ගොනුවට පිහිටීම" "-DgroupId = කණ්ඩායම් හැඳුනුම්පත" "-DartifactId = artifact id" "-Dversion = version" "-Dpackaging = ඇසුරුම් වර්ගය"

1. දේශීය Maven නිධිය නාමාවලියක් සාදන්න, ඔබේ ව්‍යාපෘති මූල ආරම්භ කිරීම සඳහා මේ හා සමාන විය යුතුය:

yourproject
+- pom.xml
+- src

2. Com.example සහ 1.0 අනුවාදය සඳහා repo නමින් සම්මත Maven නිධිය නාමාවලියක් එක් කරන්න:

yourproject
+- pom.xml
+- src
+- repo

3. කෞතුක භාණ්ඩය රෙපෝවට යොදවන්න, එම්වීඑන් යෙදවීම: යෙදවීම-ගොනු ඉලක්කය:

mvn deploy:deploy-file -Durl=file:///pathtoyour/repo -Dfile=your.jar -DgroupId=your.group.id -DartifactId=yourid -Dpackaging=jar -Dversion=1.0

4. ඔබේ බඳුනට අනුරූපව pom ගොනුවක් ස්ථාපනය කරන්න, එවිට ඔබේ ව්‍යාපෘතියට දේශීය repo වලින් සාදන විට බඳුන සොයාගත හැකිය:

mvn install:install-file -Dfile=/path-to-your-jar-1.0.jar -DpomFile=/path-to-your-pom-1.0.pom

5. ඔබගේ pom ගොනුවේ repo එක් කරන්න:

<repositories>
    <!--other repositories if any-->
    <repository>
        <id>project.local</id>
        <name>project</name>
        <url>file:${project.basedir}/repo</url>
    </repository>
</repositories>

6. ඔබගේ පොම් මත යැපීම එක් කරන්න:

<dependency>
    <groupId>com.groupid</groupId>
    <artifactId>myid</artifactId>
    <version>1.0</version>
</dependency>

මුල් ප්‍රශ්නයට පිළිතුරක් නොවේ, කෙසේ වෙතත් එය යමෙකුට ප්‍රයෝජනවත් විය හැකිය

Maven භාවිතා කරමින් ෆෝල්ඩරයෙන් බඳුන් බහු පුස්තකාල එකතු කිරීමට නිසි ක්‍රමයක් නොමැත. පරායත්තතා කිහිපයක් පමණක් තිබේ නම්, maven-install-pluginඉහත පිළිතුරු වල සඳහන් පරිදි වින්‍යාස කිරීම පහසුය .

කෙසේ වෙතත්, මගේ විශේෂිත අවස්ථාව සඳහා, මට libහිමිකාර භාජන ලිපිගොනු 100 කට වඩා ඇති ෆෝල්ඩරයක් තිබී ඇති අතර එය කෙසේ හෝ එකතු කළ යුතුව තිබුණි. මගේ Mavenව්‍යාපෘතිය බවට පරිවර්තනය කිරීම මට වඩා පහසු විය Gradle.

plugins {
    id 'org.springframework.boot' version '2.2.2.RELEASE'
    id 'io.spring.dependency-management' version '1.0.8.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
    mavenCentral()
    flatDir {
       dirs 'libs' // local libs folder
   }
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    
    implementation 'io.grpc:grpc-netty-shaded:1.29.0'
    implementation 'io.grpc:grpc-protobuf:1.29.0'
    implementation 'io.grpc:grpc-stub:1.29.0' // dependecies from maven central

    implementation name: 'akka-actor_2.12-2.6.1' // dependecies from lib folder
    implementation name: 'akka-protobuf-v3_2.12-2.6.1'
    implementation name: 'akka-stream_2.12-2.6.1'

 }

මෙම පිළිතුර පරිශීලකයින් සඳහා පමණි:

ඔබ සූර්යග්‍රහණය භාවිතා කරන්නේ නම්, භාජනය lib / හි තබන්න, භාජනයේ නම මත දකුණු ක්ලික් කර "මාර්ගය ගොඩ නැගීමට එකතු කරන්න" ක්ලික් කරන්න. සූර්යග්‍රහණය මඟින් “යොමු කරන ලද පුස්තකාල” නිර්මාණය කර ඔබ වෙනුවෙන් භාජනය තබනු ඇත

එය මා සඳහා වූ වැඩසටහනේ දී බඳුන ආනයනය කිරීම වහාම විසඳීය