Как сделать пользователя с полями и списком объектов иммутабельным

Как сделать пользователя с полями и списком объектов иммутабельным

Иммутабельность (Immutability) означает, что объект не может измениться после создания. Это критически важно для потокобезопасности, безопасного кэширования и функционального программирования. Создание иммутабельного объекта с вложенными списками требует особых подходов.

Проблема: Поверхностная vs Глубокая иммутабельность

// ПЛОХО: выглядит иммутабельным, но на самом деле нет
public class UserBad {
    private final String name;
    private final List<Address> addresses;  // final только для самой ссылки!
    
    public UserBad(String name, List<Address> addresses) {
        this.name = name;
        this.addresses = addresses;
    }
    
    public List<Address> getAddresses() {
        return addresses;  // Проблема: можно изменить список снаружи!
    }
}

// Использование
List<Address> list = new ArrayList<>();
list.add(new Address("Moscow"));

User user = new UserBad("John", list);
list.add(new Address("SPB"));  // ОЙ! Изменили список в user

user.getAddresses().clear();  // ОЙ! Очистили все адреса

Ключевая проблема: final на поле означает, что сама ссылка не может измениться, но объект, на который она ссылается, может быть изменён. Нужно создавать защищённые копии.

Решение 1: Копирование в конструкторе и getter

Базовый подход с Collections.unmodifiableList():

public class Address {
    private final String city;
    private final String street;
    
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
    
    public String getCity() { return city; }
    public String getStreet() { return street; }
}

public class User {
    private final String name;
    private final int age;
    private final List<Address> addresses;  // Храним как неизменяемый список
    
    public User(String name, int age, List<Address> addresses) {
        this.name = name;
        this.age = age;
        // Копируем входящий список, чтобы внешние изменения не влияли
        this.addresses = List.copyOf(addresses);
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public List<Address> getAddresses() {
        // Возвращаем неизменяемый вид
        return Collections.unmodifiableList(addresses);
        
        // Или в Java 9+:
        // return List.copyOf(addresses);
    }
}

// Использование
List<Address> addresses = new ArrayList<>();
addresses.add(new Address("Moscow", "Red Square"));

User user = new User("John", 30, addresses);

// Попытка изменить снаружи
addresses.add(new Address("SPB", "Nevsky"));  // Не повлияет на user

// Попытка изменить через getter
user.getAddresses().add(new Address("Kazan", "Test"));  // UnsupportedOperationException

Решение 2: List.copyOf() в Java 9+

Самый современный и безопасный способ:

public class UserModern {
    private final String name;
    private final int age;
    private final List<Address> addresses;  // Неизменяемый список
    
    public UserModern(String name, int age, List<Address> addresses) {
        this.name = name;
        this.age = age;
        // List.copyOf() создаёт неизменяемую копию
        this.addresses = List.copyOf(addresses);
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    
    // Безопасно возвращать напрямую (уже неизменяемый)
    public List<Address> getAddresses() {
        return addresses;
    }
}

// Если в списке null — выбросит NullPointerException
List.copyOf(Arrays.asList(null));  // NPE

Решение 3: Collections.unmodifiableList()

Для Java 8 и более старых версий:

public class UserLegacy {
    private final String name;
    private final List<Address> addresses;
    
    public UserLegacy(String name, List<Address> addresses) {
        this.name = name;
        // Сначала копируем, потом оборачиваем в unmodifiable
        this.addresses = Collections.unmodifiableList(
            new ArrayList<>(addresses)
        );
    }
    
    public String getName() { return name; }
    
    public List<Address> getAddresses() {
        return addresses;  // Уже неизменяемый
    }
}

Решение 4: Builder Pattern для удобства

Для создания сложных иммутабельных объектов:

public class UserBuilder {
    private String name;
    private int age;
    private List<Address> addresses = new ArrayList<>();
    
    public UserBuilder name(String name) {
        this.name = name;
        return this;
    }
    
    public UserBuilder age(int age) {
        this.age = age;
        return this;
    }
    
    public UserBuilder addAddress(Address address) {
        this.addresses.add(address);
        return this;
    }
    
    public UserBuilder addresses(List<Address> addresses) {
        this.addresses = new ArrayList<>(addresses);
        return this;
    }
    
    public User build() {
        return new User(name, age, addresses);
    }
}

// Использование
User user = new UserBuilder()
    .name("John")
    .age(30)
    .addAddress(new Address("Moscow", "Red Square"))
    .addAddress(new Address("SPB", "Nevsky"))
    .build();

Решение 5: Lombok @Value

Ломбок автоматически генерирует иммутабельный код:

// Зависимость: org.projectlombok:lombok

@Value  // Генерирует getter, hashCode, equals, toString
@Builder  // Генерирует Builder
public class Address {
    String city;
    String street;
}

@Value
@Builder
public class User {
    String name;
    int age;
    List<Address> addresses;
    
    // Lombok автоматически:
    // - Делает все поля private final
    // - Генерирует неизменяемые getters
    // - Копирует списки при инициализации
}

// Использование
User user = User.builder()
    .name("John")
    .age(30)
    .addresses(List.of(
        new Address("Moscow", "Red Square"),
        new Address("SPB", "Nevsky")
    ))
    .build();

Решение 6: Records (Java 16+)

Новый способ создания иммутабельных типов:

// Java 16+ feature
public record Address(String city, String street) {}

public record User(
    String name,
    int age,
    List<Address> addresses
) {
    // Compact constructor для валидации и копирования
    public User {
        Objects.requireNonNull(name);
        Objects.requireNonNull(addresses);
        addresses = List.copyOf(addresses);  // Защитная копия
    }
}

// Использование
User user = new User(
    "John",
    30,
    List.of(
        new Address("Moscow", "Red Square"),
        new Address("SPB", "Nevsky")
    )
);

// Records автоматически:
// - Создают неизменяемые поля
// - Генерируют getters
// - Генерируют equals, hashCode, toString

Вложенные иммутабельные объекты

Когда сам Address тоже должен быть иммутабельным:

// Все объекты в списке тоже должны быть иммутабельными
public class Address {
    private final String city;
    private final String street;
    private final List<String> zipCodes;  // Вложенный список
    
    public Address(String city, String street, List<String> zipCodes) {
        this.city = city;
        this.street = street;
        // Защита от изменений
        this.zipCodes = List.copyOf(zipCodes);
    }
    
    public String getCity() { return city; }
    public String getStreet() { return street; }
    public List<String> getZipCodes() { return zipCodes; }
}

public class User {
    private final String name;
    private final List<Address> addresses;
    
    public User(String name, List<Address> addresses) {
        this.name = name;
        // Защита на всех уровнях
        this.addresses = List.copyOf(addresses);
    }
    
    public String getName() { return name; }
    
    public List<Address> getAddresses() {
        return addresses;  // Уже защищённо
    }
}

Полный пример: Иммутабельный User

public final class User {
    private final String name;
    private final int age;
    private final List<Address> addresses;
    
    public User(String name, int age, List<Address> addresses) {
        this.name = Objects.requireNonNull(name, "Name cannot be null");
        
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        this.age = age;
        
        this.addresses = List.copyOf(
            Objects.requireNonNull(addresses, "Addresses cannot be null")
        );
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    public List<Address> getAddresses() { return addresses; }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return age == user.age &&
               name.equals(user.name) &&
               addresses.equals(user.addresses);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age, addresses);
    }
    
    @Override
    public String toString() {
        return "User{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", addresses=" + addresses +
               '}';
    }
}

Таблица сравнения подходов

Практические советы

public class ImmutabilityBestPractices {
    // 1. Всегда копируй входящие коллекции
    List<Item> items = List.copyOf(inputItems);
    
    // 2. Возвращай неизменяемые представления
    public List<Item> getItems() {
        return items;  // Если уже copyOf
    }
    
    // 3. Делай класс final, чтобы избежать override
    public final class ImmutableClass {}
    
    // 4. Все поля должны быть private final
    private final String field;
    
    // 5. Для вложенных объектов проверяй их иммутабельность
    // Если Address не иммутабелен — User тоже не иммутабелен
    
    // 6. Документируй иммутабельность в JavaDoc
    /** This class is immutable and thread-safe */
}

Иммутабельность — это один из лучших способов избежать багов, особенно в многопоточном коде. Потратьте время на правильную реализацию иммутабельных объектов — это окупится стабильностью.