Organisieren Sie die Verwendung von Javas org.Immutables.

Die offizielle Website ist unten. (Grundsätzlich basiert der Inhalt dieses Artikels darauf) https://immutables.github.io/

Voreinstellung

Legen Sie die Abhängigkeit in pom.xml von maven fest.

<dependency>
  <groupId>org.immutables</groupId>
  <artifactId>value</artifactId>
  <version>2.8.2</version>
  <scope>provided</scope>
</dependency>

Grundlegende Verwendung

Erstellen Sie ein unveränderliches Objekt, indem Sie eine Wertklasse erstellen, in der Daten gespeichert werden, und darauf basierend eine automatisch generierte unveränderliche Klasse erstellen. Wird beim Erstellen eines Objekts verwendet, das nicht geändert werden soll.

Value

Mit unveränderlicher Anmerkung deklarieren.
Jede Schnittstelle oder Klasse ist in Ordnung.
Die unveränderliche Klasse wird beim Kompilieren automatisch generiert.
Der Klassenname der Immutable-Klasse lautet ImmutableXxx. (Xxx ist der Klassenname der Value-Klasse)
Die automatisch generierte unveränderliche Klasse sollte standardmäßig in Ziel / generierten Quellen / Anmerkungen erstellt werden, wenn sie mit maven compile kompiliert wird.

import java.util.List;

import org.immutables.value.Value.Immutable;

@Immutable
public interface User {
    String name();
    String address();
    int age();
    List<String> hobbies();
}

Builder

Es wird eine unveränderliche Klasse verwendet, die automatisch aus der Wertklasse (Benutzerklasse im obigen Beispiel) generiert wird.
Rufen Sie die Builder-Methode der Immutable-Klasse auf, weisen Sie die Daten zu und rufen Sie schließlich die Build-Methode auf.
Dadurch wird ein unveränderliches Objekt erstellt. --Daten können mit der Methode der Wertklasse abgerufen werden.

        User user = ImmutableUser.builder()
            .name("Tom")
            .age(21)
            .address("Tokyo, Japan")
            .addHobbies("reading", "skiing")
            .build();

        System.out.println(user.toString());
        // User{name=Tom, address=Tokyo, Japan, age=21, hobbies=[reading, skiing]}

        System.out.println(user.name());
        // Tom

        System.out.println(user.age());
        // 21

Sie können einem unveränderlichen Objekt keine Daten hinzufügen. (UnsupportedOperationException tritt auf, wenn versucht wird, Daten zur List-Klasse oder Map-Klasse hinzuzufügen.)

        //listMap ist ein unveränderliches Objekt
        listMap.list().add("item"); // java.lang.UnsupportedOperationException
        listMap.map().put("key", "value"); //java.lang.UnsupportedOperationException

from()

Verwenden Sie die from-Methode, um ein anderes unveränderliches Objekt basierend auf einem unveränderlichen Objekt zu erstellen.

        User userTemp = ImmutableUser.builder()
            .name("Tom")
            .age(21)
            .address("Tokyo, Japan")
            .addHobbies("reading", "skiing")
            .build();

        User user = ImmutableUser.builder()
            .from(userTemp)
            .address("Osaka, Japan")
            .build();

        System.out.println(user.toString());
        // User{name=Tom, address=Osaka, Japan, age=21, hobbies=[reading, skiing]}

Constructor --Wenn Sie mit dem Konstruktor ein unveränderliches Objekt erstellen, fügen Sie der Methode die Annotation Parameter hinzu.

import org.immutables.value.Value.Immutable;
import org.immutables.value.Value.Parameter;

@Immutable
public interface Item {
    @Parameter
    String name();
    @Parameter
    int price();
}

--Erstellen Sie ein unveränderliches Objekt, indem Sie der of-Methode der Immutable-Klasse Daten geben.

        Item item = ImmutableItem.of("apple", 213);

        System.out.println(item);
        // Item{name=apple, price=213}

Optional

--Verwenden Sie Optional, wenn Sie ein optionales Element in der Klasse Unveränderlich definieren.

import java.util.Optional;

import org.immutables.value.Value.Immutable;

@Immutable
public interface Address {
    String country();
    String city();
    String blockNmuber();
    Optional<String> apartmentName();
}

In Optional definierte Elemente müssen nicht mit Daten festgelegt werden. Elemente, die nicht mit IllegalStateException festgelegt wurden, treten jedoch auf, wenn keine Daten festgelegt wurden.

        Address address1=ImmutableAddress.builder()
            .country("Japan")
            .city("Yokohama")
            .blockNmuber("1-2-3")
            .build(); // OK

        Address address2=ImmutableAddress.builder()
            .country("Japan")
            .city("Chiba")
            .blockNmuber("1-2-3")
            .apartmentName("YYY Apartment")
            .build(); // OK
        
        Address address3=ImmutableAddress.builder()
            .country("Japan")
            .city("Chiba")
            .build(); // java.lang.IllegalStateException: Cannot build Address, some of required attributes are not set [blockNmuber]

Default

Fügen Sie die Standardanmerkung zu dem Element hinzu, für das Sie den Standardwert haben möchten, und definieren Sie die Standardmethode.

import org.immutables.value.Value.Default;
import org.immutables.value.Value.Immutable;

@Immutable
public interface AddressWithDefault {
    @Default
    default String country(){
        return "Japan";
    }
    String city();
    String blockNmuber();
}

Wenn Sie die Daten beim Erstellen des unveränderlichen Objekts nicht festlegen, wird der Standardwert festgelegt.

        AddressWithDefault address = ImmutableAddressWithDefault.builder()
            .city("Saitama")
            .blockNmuber("4-5-6")
            .build();

        System.out.println(address.toString());
        // AddressWithDefault{country=Japan, city=Saitama, blockNmuber=4-5-6}

Derived

Fügen Sie die abgeleitete Anmerkung hinzu und definieren Sie die zu verarbeitenden Elemente basierend auf dem Datensatz im unveränderlichen Objekt.

import java.util.Map;

import org.immutables.value.Value.Derived;
import org.immutables.value.Value.Immutable;

@Immutable
public abstract class Receipt {
    abstract Map<String, Integer> items();

    @Derived
    public int total() {
        //Summieren Sie die Werte der Elemente
        return items().values().stream().reduce(0, Integer::sum);
    }
}

       Receipt receipt = ImmutableReceipt.builder()
            .putItems("bread", 210)
            .putItems("milk", 100)
            .build();

        System.out.println(receipt.total());
        // 310

Precondition check

Definieren Sie den Prüfvorgang, wenn ein unveränderliches Objekt mit der Anmerkung "Prüfung" erstellt wird.

import java.util.List;

import org.immutables.value.Value.Check;
import org.immutables.value.Value.Immutable;

@Immutable
public abstract class Cart {
    abstract List<String> items();

    @Check
    protected void check() {
        if (items() == null || items().isEmpty()) {
            throw new IllegalStateException();
        }
    }
}

--Wenn die Prüfbedingungen nicht erfüllt sind, kann beim Erstellen eines unveränderlichen Objekts ein Fehler generiert werden.

        ImmutableCart.builder().build(); // java.lang.IllegalStateException

Erweiterte Version

Wrapper Types

Wenn Sie eine Wrapped-Schnittstelle und eine Wrapper-Klasse haben, ist die Definition der Value-Klasse einfach und Sie müssen nicht immer wieder ähnlichen Code schreiben.
Umhüllte Schnittstelle

    @Value.Style(
            typeAbstract = "_*",
            typeImmutable = "*",
            visibility = ImplementationVisibility.PUBLIC,
            defaults = @Value.Immutable(builder = false, copy = false))
    public @interface Wrapped {
    }

--Wrapper-Klasse

    public static abstract class Wrapper<T> {
        @Value.Parameter
        public abstract T value();

        @Override
        public String toString() {
            return getClass().getSimpleName() + "(" + value() + ")";
        }
    }

Die Value-Klasse und deren Aufruf lauten wie folgt.

    @Value.Immutable
    @Wrapped
    public static abstract class _FirstName extends Wrapper<String> {
    }

    @Value.Immutable
    @Wrapped
    public static abstract class _LastName extends Wrapper<String> {
    }

    @Value.Immutable
    @Wrapped
    public static abstract class _Age extends Wrapper<Integer> {
    }

    FirstName firstName = FirstName.of("Taro");

    LastName lastName = LastName.of("Yamada");

    Age age = Age.of(45);

Wenn die Kompilierung fehlschlägt

Reinigen und dann kompilieren, wie mvn clean compile.
Setzen Sie in der Option useIncrementalCompilation den Wert false.
- https://immutables.github.io/getstarted.html#troubleshooting

[JAVA] Verwendung von org.immutables

Voreinstellung

Grundlegende Verwendung

Erweiterte Version

Wenn die Kompilierung fehlschlägt