Apache Maven to potężne narzędzie do zarządzania projektem, które służy do automatyzacji procesu budowy oprogramowania. Maven jest zasadniczo narzędziem do zarządzania zależnościami, ale oferuje wiele więcej funkcji, które pomagają tworzyć spójne, zrozumiałe i łatwe do zarządzania projekty.

Automatyzacja budowy: Maven umożliwia automatyzację wszystkich aspektów procesu budowy oprogramowania, takich jak kompilacja kodu źródłowego, pakowanie wynikowego oprogramowania, generowanie dokumentacji, uruchamianie testów i wiele innych.
Zarządzanie zależnościami: Jednym z głównych problemów, z którymi zmagają się deweloperzy, jest zarządzanie zależnościami między różnymi bibliotekami i modułami. Maven zautomatyzował ten proces, automatycznie pobierając i zarządzając zależnościami.
Standardowa struktura projektu: Maven wprowadza konwencję dotyczącą struktury projektu, która pomaga utrzymać spójność między różnymi projektami. Ta struktura jest łatwo zrozumiała przez nowych członków zespołu i umożliwia automatyzację wielu zadań.
Obsługa wielomodułowych projektów: Maven jest świetny do zarządzania wielomodułowymi projektami, co umożliwia utrzymanie spójności i zależności między różnymi modułami.
Wsparcie dla różnych technologii: Maven obsługuje wiele technologii i języków programowania poza Javą, takich jak C#, Ruby, Scala, itp., dzięki czemu można go używać w różnorodnych projektach.
Integracja z innymi narzędziami: Maven dobrze integruje się z wieloma innymi narzędziami i usługami, takimi jak systemy kontroli wersji (np. Git), serwery CI/CD (np. Jenkins), narzędzia do analizy jakości kodu (np. SonarQube), itp.

Instalacja Mavena

systemie Debian (lub dowolnym innym systemie opartym na Debianie, jak Ubuntu) jest stosunkowo prosta. Poniżej znajduje się instrukcja krok po kroku.

Aktualizacja systemu

Otwórz terminal i wpisz następujące polecenie, aby zaktualizować system:

aktualizacja repozytorium debian

sudo apt-get update

instalacja javy

sudo apt-get install default-jdk

jeśli java jest zaintalowana na twoje maszynie mozesz pominąć ten krok

Po zakończeniu instalacji możesz sprawdzić zainstalowaną wersję Javy, wpisując:

Instalacja Maven

Teraz, kiedy masz już zainstalowaną Javę, możesz zainstalować Mavena. Wykonaj to za pomocą polecenia:

sudo apt-get install maven

Po zakończeniu instalacji sprawdź, czy Maven został poprawnie zainstalowany, wpisując:

bash Copy code mvn -v Powinno to wyświetlić informacje o zainstalowanej wersji Mavena.

To wszystko! Teraz powinieneś mieć Mavena gotowego do użycia na swoim komputerze.

Instalacja Mavena na Windowsie

pobranie Mavena

$url = "https://www.apache.org/dyn/closer.cgi?filename=maven/maven-3/3.8.2/binaries/apache-maven-3.8.2-bin.zip&action=download" $output = "$env:TEMP\apache-maven-3.8.2-bin.zip" Invoke-WebRequest -Uri $url -OutFile $output

Rozpakowanie Mavena

$destination = "C:\Program Files\Apache-Maven" Expand-Archive -Path $output -DestinationPath $destination -Force

Ustawianie zmiennej środowiskowej M2_HOME

[Environment]::SetEnvironmentVariable("M2_HOME", "$destination\apache-maven-3.8.2", "Machine")

Dodanie katalogu bin do ścieżki

$newPath = "$env:Path;$destination\apache-maven-3.8.2\bin" [Environment]::SetEnvironmentVariable("Path", $newPath, "Machine")

Usunięcie pobranego pliku

Remove-Item -Path $output

Sprawdzenie instalacji

mvn -v

IntelliJ IDEA oferuje świetne wsparcie dla Mavena, co ułatwia korzystanie z tego narzędzia w środowisku IDE. Oto podstawowe kroki, jak korzystać z Mavena w IntelliJ IDEA:

Tworzenie nowego projektu Maven intellij

Wybierz File -> New -> Project.... W oknie "New Project", wybierz "Maven" z listy po lewej stronie. Wprowadź GroupId, ArtifactId i inne wymagane informacje, a następnie kliknij Next. Wybierz lokalizację dla nowego projektu i kliknij Finish.

Zarządzanie zależnościami

Aby dodać nową zależność do projektu, otwórz plik pom.xml i dodaj nowy blok w sekcji . Po dodaniu zależności, IntelliJ IDEA automatycznie pobierze i doda ją do ścieżki klas projektu.

Uruchamianie zadań Maven

Możesz uruchomić zadania Maven bezpośrednio z IntelliJ IDEA. Aby to zrobić, otwórz panel Maven Projects (zazwyczaj po prawej stronie), rozwiń projekt i jego cykl życia, a następnie dwukrotnie kliknij zadanie, które chcesz uruchomić. Możesz również uruchomić zadania Maven z linii poleceń w terminalu wbudowanym w IntelliJ IDEA.

Importowanie projektu Maven

Aby zaimportować projekt Maven, wybierz File -> New -> Project from Existing Sources... i wybierz katalog projektu Maven. IntelliJ IDEA automatycznie rozpozna projekt Maven i zaimportuje go.

Plik POM (Project Object Model) w Mavenie to podstawowy element każdego projektu Maven. Jest to plik XML, który zawiera informacje o projekcie i szczegółowe informacje na temat, jak oprogramowanie jest skonstruowane. Poniżej przedstawiam podstawowe elementy struktury pliku pom.xml:

project: Jest to główny element w pliku POM. Wszystkie inne elementy muszą znajdować się w tym elemencie.
modelVersion: Ta sekcja definiuje wersję POM, której używamy. Aktualna wersja to 4.0.0.
groupId: To jest identyfikator organizacji lub grupy, która jest odpowiedzialna za projekt.
artifactId: To jest nazwa projektu.
version: To jest wersja projektu.
packaging: Ten element określa typ pakietu, który Maven powinien utworzyć. Może to być na przykład "jar", "war" lub "pom". Domyślnie jest to "jar".
dependencies: W tej sekcji definiujemy zależności projektu. Każda zależność jest opisana za pomocą jej groupId, artifactId i version. Można również określić "scope", który mówi Mavenowi, jak zależność powinna być używana.
properties: W tym elemencie możemy zdefiniować różne właściwości, które mogą być używane w całym pliku POM.
build: Ten element zawiera informacje na temat procesu budowy projektu. Może zawierać elementy takie jak plugins, resources czy testResources.
profiles: Profile to zestawy konfiguracji, które mogą być aktywowane dla różnych środowisk budowy. Można je na przykład używać do dostosowywania procesu budowy do różnych środowisk rozwoju, testowego i produkcyjnego.
repositories: Tutaj definiowane są repozytoria, z których Maven może pobierać zależności.

Wszystkie te elementy są opcjonalne i można je dostosować do potrzeb konkretnego projektu. Wiele projektów Maven korzysta tylko z podstawowych elementów, takich jak groupId, artifactId, version i dependencies.

Przykład

oto dobrze znany przykład pliku pom.xml: z laboratorium otestowa

)<?xml version="1.0" encoding="UTF-8"?>
<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>org.example</groupId>
    <artifactId>Scenariusz</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>20</maven.compiler.source>
        <maven.compiler.target>20</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.9.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>19</source>
                    <target>19</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

#ZADANIE 0

testy klasy wieklomian z labu o testowabiu

Mokowaniw

Mockowanie to technika stosowana w testowaniu oprogramowania, która polega na tworzeniu fałszywych obiektów (zwanych "mockami"), które naśladują zachowanie rzeczywistych obiektów.

Mocki są używane z różnych powodów:

Izolacja testów jednostkowych: Testy jednostkowe powinny być izolowane od innych części systemu. Na przykład, jeśli testujesz metodę, która jest zależna od usługi zewnętrznej lub bazy danych, nie chcesz, aby Twój test zależał od tej usługi lub bazy danych. Zamiast tego, możesz utworzyć mocka tej usługi lub bazy danych, który naśladuje ich zachowanie. W ten sposób testujesz tylko kod, który chcesz przetestować, a nie jego zależności.

Symulowanie różnych scenariuszy: Mocki umożliwiają łatwe symulowanie różnych warunków, które mogą być trudne do osiągnięcia z prawdziwymi obiektami. Na przykład, jeśli chcesz przetestować, jak Twój kod radzi sobie z błędem sieciowym, możesz skonfigurować mocka tak, aby symulował taki błąd.

Kontrola nad zachowaniem obiektów zależności: Mocki pozwalają Ci mieć pełną kontrolę nad tym, jak obiekty zależności reagują na wywołania metod, umożliwiając precyzyjne testowanie interakcji.

W Javie, biblioteki takie jak Mockito są często używane do tworzenia i konfiguracji mocków. Na przykład, możesz użyć Mockito do utworzenia mocka interfejsu, skonfigurować, jak mock powinien reagować na wywołania określonej metody, a następnie przekazać ten mock do kodu, który testujesz, aby zobaczyć, jak zachowuje się w odpowiedzi na te wywołania.

Weźmy na przykład taki kod:

z naszego laboratorium o testowaniu

naszym ceem bedzie testowaniu będzie dododanie testu funkcji obliczającej miejsca zerowe w wielomianu pomimo nie zaimplementowania tej funkcji


```java
@Test
    void findRootsTest() {
        // Tworzymy mocka dla Polynomial
        Polynomial polynomial = mock(Polynomial.class);

        // Określamy zachowanie mocka - metoda findRoots() ma zwrócić tablicę {1.0, -1.0}
        when(polynomial.findRoots()).thenReturn(new double[]{1.0, -1.0});

        // Wywołujemy metodę na mocku
        double[] roots = polynomial.findRoots();

        // Sprawdzamy, czy zwrócone wartości są zgodne z oczekiwaniami
        assertArrayEquals(new double[]{1.0, -1.0}, roots);

        // Weryfikujemy, czy metoda findRoots() na mocku została wywołana dokładnie raz
        verify(polynomial, times(1)).findRoots();
    }
}

Uwaga aby ten tst dzialal konieczne jest dodanie do pliku pom.xml biblioteki mockito-core

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>

oraz zamokowanie metody findRoots() w klasie Polynomial funjcja ta moze wygladac np tak

 public double[] findRoots() {
            return new double[2];
    }

##W# zadanie 1 wykonaj opisane powyzej kroki i uruchom test uwagsa w intelij po kazdej zmianie w pliku pom.xml nalezy kliknac na niego prawym przyciskiem i zrobic reload mavena

dzedzidziczenie plików pom.xml

Maven oferuje funkcję dziedziczenia pomiędzy plikami pom.xml, która umożliwia zarządzanie wspólnymi elementami projektu w jednym miejscu. To oznacza, że możesz mieć jeden pom.xml jako rodzic dla wielu innych plików pom.xml w podprojektach.

Plik pom.xml rodzica może wyglądać mniej więcej tak

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>  <!-- ustawienie packaging na "pom" oznacza, że jest to projekt nadrzędny -->

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- Wspólne zależności dla wszystkich podprojektów -->
    <!-- np. JUnit,o itd. -->
  </dependencies>
</project>

a pom modułu dziecka tak:

<project>
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>com.example</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0</version>
  </parent>

  <artifactId>child-project</artifactId>

  <!-- Własne zależności, ustawienia itd. podprojektu -->
</project>

W pliku pom.xml podprojektu, używamy elementu do określenia projektu nadrzędnego. Podprojekt dziedziczy wszystkie zależności i właściwości zdefiniowane w pliku pom.xml rodzica, ale może również dodawać lub nadpisywać te ustawienia.

Dziedziczenie plików pom.xml jest bardzo użyteczne w dużych projektach z wieloma modułami, które mają wiele wspólnych zależności i ustawień. Pozwala to na centralne zarządzanie tymi elementami, co ułatwia utrzymanie i aktualizację projektu.

Zadanie 2

wykonaj zadanie 1 z wykorzystaniem dziedziczenia plikow pom.xml

Pluginy mavena

Maven Plugin to program, który rozszerza możliwości narzędzia Maven. Każde zadanie, które Maven wykonuje (takie jak kompilacja kodu źródłowego, generowanie dokumentacji, pakowanie kodu źródłowego do formatu JAR itp.), jest realizowane przez specjalny plugin.

Najpopularniejsze pluginy Mavena

maven-compiler-plugin: Ten plugin jest używany do kompilacji kodu źródłowego projektu. Domyślnie korzysta z JDK, które jest ustawione w środowisku, ale możemy skonfigurować wersję Java, z której chcemy korzystać w konfiguracji pluginu.
maven-surefire-plugin: Plugin ten jest używany do wykonania testów jednostkowych w projekcie. Domyślnie uruchamia wszystkie testy, które pasują do wzorca **/Test*.java, **/*Test.java, **/*Tests.java, **/*TestCase.java.
maven-failsafe-plugin: Ten plugin jest używany do obsługi testów integracyjnych. Jest podobny do pluginu maven-surefire-plugin, ale jest zaprojektowany tak, aby zapewnić "bezpieczne" niepowodzenie dla testów integracyjnych.
maven-jar-plugin: Plugin ten jest używany do budowania plików JAR.
maven-war-plugin: Plugin ten jest używany do budowania plików WAR dla aplikacji webowych.
maven-install-plugin: Ten plugin jest używany do instalowania artefaktu projektu w lokalnym repozytorium.
maven-deploy-plugin: Ten plugin jest używany do umieszczania artefaktu projektu w zdalnym repozytorium.
maven-clean-plugin: Plugin ten jest używany do czyszczenia plików generowanych podczas fazy budowy.
maven-site-plugin: Ten plugin jest używany do generowania dokumentacji projektu w formie strony internetowej.
maven-javadoc-plugin: Ten plugin jest używany do generowania dokumentacji JavaDoc dla projektu.
maven-shade-plugin: Ten plugin jest używany do tworzenia tzw. "fat JARs", które zawierają wszystkie zależności projektu wewnątrz jednego pliku JAR.

Każdy z tych pluginów ma różne cele, które są związane z różnymi fazami cyklu życia budowy Mavena.

java doc

JavaDoc to narzędzie generowania dokumentacji dla języka Java, które jest dostarczane z pakietem JDK. JavaDoc analizuje komentarze zawarte w kodzie źródłowym i tworzy dokumentację API w formacie HTML.

Komentarze JavaDoc zaczynają się od /** i kończą na */. Wewnątrz tych komentarzy można używać specjalnych tagów, które zaczynają się od @, aby podać dodatkowe informacje, takie jak autor, zobacz, odwołania do innych klas/metod, parametry metody, wartość zwracaną itd.

Przykładowy komentarz JavaDoc może wyglądać tak:

/**
 * Klasa zawierająca metody pomocnicze do operacji na liczbach.
 */
public class NumberUtils {

    /**
     * Dodaje dwie liczby całkowite.
     *
     * <p>Przykład użycia:</p>
     * <pre>
     * int a = 5;
     * int b = 10;
     * int suma = NumberUtils.add(a, b);
     * System.out.println(suma);  // Wypisze "15"
     * </pre>
     *
     * @param a pierwsza liczba do dodania
     * @param b druga liczba do dodania
     * @return suma dwóch liczb
     */
    public static int add(int a, int b) {
        return a + b;
    }
}

Fragment pliku pom.xml, który generuje dokumentację JavaDoc, może wyglądać tak:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
        </plugin>
    </plugins>
  <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-javadoc-plugin</artifactId>
            <version>3.3.0</version>
            <executions>
                <execution>
                    <id>generate-javadocs</id>
                    <phase>package</phase>
                    <goals>
                        <goal>javadoc</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

zadabie 3

dodaj plugin maven-javadoc-plugin do projektu i wygeneruj dokumentacje javadoc

zadanie 4

dodaj opis w java doc niektorych metod i wygeneruj dokumentacje javadoc ponownie

zadanie 5

dodaj odpowiedni plugin i wtgneruj plik jar dla projektu