Jak dodać lokalne pliki jar do projektu Maven?

Jak dodać lokalne pliki jar (nie będące jeszcze częścią repozytorium Maven) bezpośrednio w źródłach bibliotecznych mojego projektu?

Zainstaluj plik JAR w lokalnym repozytorium Maven w następujący sposób:

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

Gdzie każdy odnosi się do:

<path-to-file>: ścieżka do pliku do załadowania np. → c:\kaptcha-2.3.jar

<group-id>: grupa, w której plik powinien zostać zarejestrowany, np. → com.google.code

<artifact-id>: nazwa artefaktu dla pliku, np. → kaptcha

<version>: wersja pliku np. → 2.3

<packaging>: opakowanie pliku np. → jar

Odniesienie

• Maven FAQ: Mam słoik, który chcę umieścić w moim lokalnym repozytorium. Jak mogę to skopiować?
• Maven zainstalować Plugin Zastosowanie: The install:install-filecel

Możesz dodać lokalne zależności bezpośrednio (jak wspomniano w projekcie build maven z dołączonymi bibliotekami firmowymi ) w następujący sposób:

<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>

Aktualizacja

W nowych wersjach ta funkcja jest oznaczona jako przestarzała, ale nadal działa i jeszcze nie została usunięta (po prostu widzisz ostrzeżenie w dzienniku podczas uruchamiania maven). W grupie maven pojawia się problem dotyczący tej https://issues.apache.org/jira/browse/MNG-6523 (możesz wziąć udział i opisać, dlaczego ta funkcja jest pomocna w niektórych przypadkach). Mam nadzieję, że ta funkcja pozostanie!

Jeśli mnie pytasz, dopóki funkcja nie zostanie usunięta, używam tego do uzależnienia tylko od jednego niegrzecznego pliku jar w moim projekcie, który nie mieści się w repozytorium. Jeśli ta funkcja zostanie usunięta, istnieje wiele dobrych odpowiedzi, które mogę wybrać później.

Po pierwsze, chciałbym wyrazić uznanie dla tej odpowiedzi anonimowemu użytkownikowi przepełnienia stosu - jestem pewien, że widziałem już kiedyś podobną odpowiedź - ale teraz nie mogę jej znaleźć.

Najlepszą opcją posiadania lokalnych plików JAR jako zależności jest utworzenie lokalnego repozytorium Maven. Takie repozytorium jest niczym więcej niż właściwą strukturą katalogów z plikami pom.

Na przykład: mam projekt główny na ${master_project}lokalizacji i podprojekt 1 jest włączony ${master_project}/${subproject1}.

Następnie utworzyć repozytorium Maven w: ${master_project}/local-maven-repo.

W pliku pom w podprojekcie1 znajdującym się w ${master_project}/${subproject1}/pom.xml, należy określić repozytorium, które przyjmuje ścieżkę pliku jako parametr adresu URL:

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

Zależność można określić jak dla każdego innego repozytorium. To czyni twoje repozytorium pom niezależnym. Na przykład, gdy żądany plik JAR będzie dostępny w centrali Maven, wystarczy go usunąć z lokalnego repozytorium, a zostanie on pobrany z domyślnego repozytorium.

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

Ostatnią rzeczą, którą należy zrobić, jest dodanie pliku JAR do lokalnego repozytorium za pomocą przełącznika -DlocalRepositoryPath w następujący sposób:

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

Po zainstalowaniu pliku JAR repozytorium Maven może zostać przypisane do repozytorium kodu, a cała konfiguracja jest niezależna od systemu. ( Przykład roboczy w GitHub ).

Zgadzam się, że zaangażowanie plików JAR w repozytorium kodu źródłowego nie jest dobrą praktyką, ale w rzeczywistości szybkie i brudne rozwiązania są czasem lepsze niż pełne repozytorium Nexus do hostowania jednego pliku JAR, którego nie można opublikować.

Utwórz nowy folder, powiedzmy local-maven-repow katalogu głównym projektu Maven.

Po prostu dodaj lokalne repozytorium <project>do swojego pom.xml:

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

Następnie dla każdego zewnętrznego słoika, który chcesz zainstalować, przejdź do katalogu głównego projektu i wykonaj:

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

Chciałbym takie rozwiązanie - użyj maven-install-pluginw pliku pom:

<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>

W takim przypadku możesz wykonać, mvn initializea jar zostanie zainstalowany w lokalnym repozytorium maven. Teraz ten słoik jest dostępny podczas każdego kroku maven na tym komputerze (nie zapomnij uwzględnić tej zależności, jak każdej innej zależności maven w pom z <dependency></dependency>tagiem). Możliwe jest również powiązanie instalacji jar nie initializekrok po kroku, ale każdy inny krok, który ci się podoba.

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

Tak, możesz mieć, ale to nie jest dobry pomysł.

Zamiast tego zainstaluj wszystkie te słoiki w repozytoriach maven

Zobacz także

• Jak zbudować projekt maven z dołączonymi bibliotekami firmowymi

Naprawdę szybki i brudny sposób to wskazanie lokalnego pliku:

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

Jednak będzie to działało tylko na twoim komputerze (oczywiście), do dzielenia się zwykle sensowne jest użycie odpowiedniego archiwum m2 (nexus / artifactory) lub jeśli nie masz żadnego z nich lub nie chcesz konfigurować lokalnego maven ustrukturyzowane archiwum i skonfiguruj „repozytorium” w pom: local:

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

zdalny:

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

w tym celu możliwa jest również ścieżka względna przy użyciu zmiennej basedir:

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

Dodaj własny lokalny plik JAR w pliku POM i użyj go w kompilacji maven.

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

Na przykład:

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

Następnie dodaj go do POM w ten sposób:

Jednym ze sposobów jest przesłanie go do własnego menedżera repozytorium Maven (takiego jak Nexus). W każdym razie dobrą praktyką jest posiadanie własnego menedżera repozytorium.

Innym fajnym sposobem, jaki ostatnio widziałem, jest włączenie wtyczki instalacyjnej Maven do swojego cyklu życia kompilacji: deklarujesz w POM, aby zainstalować pliki w lokalnym repozytorium. Jest to mały, ale niewielki narzut i nie wymaga ręcznego kroku.

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

Oczywiście możesz dodać słoiki do tego folderu. Ale może nie to, co chcesz osiągnąć ...

Jeśli potrzebujesz tych słoików do kompilacji, sprawdź to powiązane pytanie: Czy mogę dodać słoiki do ścieżki klas maven 2 bez ich instalowania?

Ponadto, zanim ktokolwiek to zasugeruje, NIE używaj zakresu systemowego.

Innym interesującym przypadkiem jest, gdy chcesz mieć w swoim projekcie prywatne słoiki z maven. Możesz chcieć zachować możliwości Maven w celu rozwiązania zależności przechodnich. Rozwiązanie jest dość łatwe.

1. Utwórz bibliotekę folderów w swoim projekcie

2. Dodaj następujące wiersze do pliku 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. Otwórz folder .m2 / repository i skopiuj strukturę katalogów projektu, który chcesz zaimportować do folderu libs .

Załóżmy na przykład, że chcesz zaimportować zależność

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

Po prostu przejdź do .m2 / repository, a zobaczysz następujący folder

com / mojafirma / myproject / 1.2.3

Skopiuj wszystko z folderu libs (ponownie, łącznie z folderami w .m2 / repository ) i gotowe.

wiersz poleceń :

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

Ważną częścią zależności jest: $ {pom.basedir} (zamiast tylko $ {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>

Myślę, że lepszym rozwiązaniem tego problemu jest użycie wtyczki maven-install-plug do automatycznej instalacji plików podczas instalacji. Tak to skonfigurowałem dla mojego projektu.

Najpierw dodaj ścieżkę (gdzie przechowujesz lokalne pliki .jars) jako właściwość.

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

Następnie w obszarze pluginsdodaj wtyczkę, aby zainstalować słoiki podczas kompilacji.

<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>

Wreszcie, w zależnościach, możesz dodać słoiki

<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>

Po skonfigurowaniu projektu w ten sposób projekt będzie kontynuowany, nawet jeśli przeniesiesz go na inny komputer (biorąc pod uwagę, że zawiera on wszystkie pliki jar w ścieżce określonej przez właściwość local.sdk ).

Dla groupId użytku unikalną nazwę, żeby upewnić się, że nie ma żadnych konfliktów.

Teraz, gdy ty mvn installlub mvn testlokalne słoiki zostaną dodane automatycznie.

Preferowanym sposobem byłoby utworzenie własnego zdalnego repozytorium.

Zobacz tutaj, aby dowiedzieć się, jak to zrobić. Zajrzyj do sekcji „ Przesyłanie do zdalnego repozytorium ”.

Chcę udostępnić kod, w którym możesz przesłać folder pełen słoików. Jest to przydatne, gdy dostawca nie ma publicznego repozytorium i trzeba ręcznie dodać wiele bibliotek. Postanowiłem zbudować .bat zamiast wywoływać bezpośrednio do maven, ponieważ mogą to być błędy braku pamięci. Został przygotowany dla środowiska Windows, ale łatwo go dostosować do systemu operacyjnego Linux:

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();
    }

}

Po uruchomieniu tego głównego z dowolnego IDE, uruchom update_repo_maven.bat.

Oto krótka składnia dla nowszych wersji:

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

Działa, gdy JAR został zbudowany przez Apache Maven - najczęstszy przypadek. Następnie będzie zawierać plik pom.xml w podfolderze katalogu META-INF, który zostanie domyślnie odczytany.

Źródło: http://maven.apache.org/guides/mini/guide-3rd-party-jars-local.html

Zobacz także ...

<scope>compile</scope>

Zależności Maven . Jest to ustawienie domyślne, ale w niektórych przypadkach znalazłem jawne ustawienie tego zasięgu również w Maven, aby znaleźć biblioteki lokalne w lokalnym repozytorium.

Z jakiegoś powodu w aplikacji internetowej, którą konserwuję, ani rozwiązania Alirezy Fattahi, ani rozwiązania JJ Romana działało poprawnie. W obu przypadkach kompilacja idzie dobrze (widzi słoik), ale opakowanie nie zawiera słoika w czasie wojny.

Jedynym sposobem, w jaki udało mi się sprawić, by działało, było włożenie słoika, /src/main/webapp/WEB-INF/lib/a następnie połączenie go z roztworem Fattahisa lub Romana.

Pamiętaj, że niekoniecznie dobrym pomysłem jest użycie lokalnego repozytorium. Jeśli ten projekt jest udostępniany innym, wtedy wszyscy będą mieli problemy i pytania, gdy nie będzie działać, a słoik nie będzie dostępny nawet w twoim systemie kontroli źródła!

Chociaż repozytorium wspólne jest najlepszą odpowiedzią, jeśli z jakiegoś powodu nie możesz tego zrobić, osadzenie słoika jest lepsze niż repozytorium lokalne. Lokalna zawartość repozytorium może powodować wiele problemów, zwłaszcza w miarę upływu czasu.

W lokalnym repozytorium możesz zainstalować słoik, wydając polecenia

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

Kliknij ten przydatny link, aby zrobić to samo ze strony internetowej mkyoung. Możesz także sprawdzić przewodnik maven dla tego samego

Aby zainstalować słoik innej firmy, wywołaj polecenie jak poniżej

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

1. instalacja mvn

Możesz napisać kod poniżej w wierszu poleceń lub jeśli używasz wbudowanego narzędzia eclipse maven, kliknij prawym przyciskiem myszy projekt -> Uruchom jako -> uruchom konfiguracje ... -> w lewym panelu kliknij prawym przyciskiem myszy Maven Build -> nowa konfiguracja -> wpisz kod w Celach i katalogu podstawowym: $ {project_loc: NameOfYourProject} -> Uruchom

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

Gdzie każdy odnosi się do:

<ścieżka do pliku>: ścieżka do pliku do załadowania, np. -> c: \ kaptcha-2.3.jar

<identyfikator grupy>: grupa, w której plik powinien zostać zarejestrowany np. -> com.google.code

<artefakt-id>: nazwa artefaktu dla pliku np. -> kaptcha

<wersja>: wersja pliku np. -> 2.3

<opakowanie>: opakowanie pliku np. -> jar

2. Po zainstalowaniu, po prostu deklaruje jar w pom.xml.

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

Krok 1: Skonfiguruj maven-install-plugincel install-filew swoimpom.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>

Zmodyfikuj fileścieżkę na podstawie rzeczywistej ścieżki pliku (zalecane jest umieszczenie tych zewnętrznych słoików niepochodzących z maven w jakimś folderze, powiedzmy lib, i umieszczenie tego libfolderu w projekcie, aby użyć ścieżki względnej specyficznej dla projektu i uniknąć dodawania systemu konkretna ścieżka bezwzględna.

Jeśli masz wiele słoików zewnętrznych, po prostu powtórz <execution>dla innych słoików w tym samym maven-install-plugin.

Krok 2: Po skonfigurowaniu pliku maven-install-pluginpokazanego powyżej w pom.xmlpliku, musisz pom.xmljak zwykle użyć tych słoików :

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

Pamiętaj, że maven-install-plugintylko zewnętrzne słoiki są kopiowane do lokalnych.m2 repozytorium maven. Otóż ​​to. Nie uwzględnia automatycznie tych słoików jako zależności maven od twojego projektu.

To drobiazg, ale czasem łatwo go przeoczyć.

Miałem ten sam błąd dla zestawu zależności w moim pom.xml okazuje się, że wersje zależności nie zostały określone w pom.xml i zostały wymienione w repozytorium nadrzędnym. Z jakiegoś powodu szczegóły wersji nie były synchronizowane z tym repozytorium. Dlatego ręcznie wprowadziłem wersje za pomocą znacznika i działało to jak urok. Trochę czasu zajęło sprawdzenie wersji w obiekcie nadrzędnym i określenie tutaj. Ale można to zrobić tylko dla słoików, które pokazują błąd artefaktu i działa. Mam nadzieję, że to komuś pomoże.

W Apache Maven 3.5.4 musiałem dodać podwójny cytat. Bez podwójnego cytowania nie działało to dla mnie.

przykład: mvn install: plik-instalacyjny „-Dfile = lokalizacja do pliku jar” „-DgroupId = identyfikator grupy” „-DartifactId = identyfikator artefaktu” „-Dversion = wersja” „-Dpackaging = typ pakietu”

1. Utwórz lokalny katalog repozytorium Maven, katalog główny projektu powinien wyglądać mniej więcej tak:

yourproject
+- pom.xml
+- src

2. Dodaj standardowy katalog repozytorium Maven o nazwie repo dla grupy com.example i wersji 1.0:

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

3. Wdróż artefakt w repozytorium, Maven może wdrożyć artefakt za Ciebie przy użyciu polecenia mvn deploy: deploy-file:

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

4. zainstaluj plik pom odpowiadający twojemu jarowi, aby twój projekt mógł znaleźć jar podczas kompilacji maven z lokalnego repozytorium:

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

5. dodaj repo w pliku pom:

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

6. dodaj zależność w swoim pom:

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

ODPOWIEDŹ JEST TYLKO DLA UŻYTKOWNIKÓW ECLIPSE:

Jeśli używasz Eclipse, umieść słoik w lib /, kliknij prawym przyciskiem myszy nazwę słoika i kliknij „dodaj do ścieżki kompilacji”. Eclipse utworzy „biblioteki odniesienia” i umieści słoik za Ciebie

Rozwiązało to dla mnie import słoika od razu w programie