Immutability with Immutables

Why Immutability? Why is it important and what do we get out of it? How do we do it in Android.

1. Immutability with Immutables Brian NYTimes (Come work with me!)
2. Why Immutability? • Thread safe • Security
3. Why Immutability? • Thread safe • Security • Less error prone • Shared freely
4. Why Immutability? • Thread safe • Security • Less error prone • Shared freely • Simple
5. Data should be like hot dogs Don’t let people take bites out of your hot dog or data!
6. By Hand • All private and all final fields • No mutator methods
7. By Hand • All private and all final fields • No mutator methods • Exclusive access to mutable components (ref guarding) • Final class
8. By Hand • All private and all final fields • No mutator methods • Exclusive access to mutable components (ref guarding) • Final class • Object creation is hard! (constructors, toString, hashcode…)
9. There must be a better way!
10. Introducing Immutables.org “The core of immutables is modelling. Good modelling is at the heart of creating good applications and services, and of good design in general” • Immutable objects - Constructed once, in a consistent state and can be shared • Mandatory attributes - Will fail if they are missing • No sneaky modifications - When passed to other code • Naturally thread safe • Object definitions are pleasant to write and read • No boilerplate setter and getters • Clean code - based off of tenets of Effective Java
11. Your first value object with immutables!!
12. public interface ValueObject { }
13. @Value.Immutable public interface ValueObject { }
14. @Value.Immutable public interface ValueObject { String name(); List<Integer> counts(); Optional<String> description(); }
15. Builder example ValueObject valueObject = ImmutableValueObject.builder() .name("My value") .addCounts(1) .addCounts(2) .build();
16. Immutables data types -> convenience • String • Primitives • List, Set, Map, MultiMap, MultiSet
17. Immutables data types -> convenience • String • Primitives • List, Set, Map, MultiMap, MultiSet • addFoo(T), addFoo(T…..), addAllFoo(Iterable<? extends T> • putBar(K, V), putAllBar(Map<K, V>), putBar(Map.Entry<K, V>)
18. Three options for handling non-required fields • Optional • Default Value • Nullable Annotation Collections just work!!
19. Optional • Fully supported! • com.google.common.base.Optional<T> • java.util.Optional* from java 8 • com/io.atlassian.fugue.Option • Optional values default to Optional.absent() when omitted
20. What about default attributes?
21. @Value.Immutable public interface ValueObject { }
22. @Value.Immutable public abstract class ValueObject { }
23. @Value.Immutable public abstract class ValueObject { @Value.Default public String name() { return “anonymous” } }
24. Nullability @Value.Immutable interface NullAccepted { @Nullable Integer emptyFirst(); @Nullable Long emptySecond(); } NullAccepted obj = ImmutableNullAccepted.builder() .emptyFirst(null) .build();
25. Serialization • Simple serialization - implement/extend Serializable • @Serial.Version - applies serial version to enclosing types • @Serial.Structural - enables structural serialization so you can evolve your data • Using above annotations will cause generated objects to impl java.lang.Serializable • Just include: org.immutables:serial:2.2.5
26. Gson • Generation of TypeAdapterFactories which use NO reflection • Just include: org.immutables:gson:2.2.5 org.immutables:value:2.2.5
27. @Value.Immutable public interface ValueObject { }
28. @Gson.TypeAdapters @Value.Immutable public interface ValueObject { }
29. @Gson.TypeAdapters @Value.Immutable public interface ValueObject { } gsonBuilder.registerTypeAdapterFactory(new GsonAdaptersValueObject());
30. Mutating the data • with* methods are generated • Modifies values of attributes by returning new immutable obj
31. Mutating the data • with* methods are generated • Modifies values of attributes you want to change Value changedValue = ImmutableValue.copyOf(existingValue) .withName("Changed Name") .withValues(Arrays.asList("Only new value")) .build(); @Value.Immutable public interface Value { String name(); String address(); List<String> values(); }
32. Mutating the data • with* methods are generated • Modifies values of attributes you want to change List<Classroom> classrooms = ImmutableList.<Classroom>builder() .addAll(school.classrooms()) .add(newClassroom) .build(); school = ImmutableSchool.copyOf(school).withClassrooms(classrooms);
33. Fancy • Lazy • Derived • Factory • Precondition check method • Singleton
34. Style annotation • @Value.Style annotation allows for attribute customization of generated code @Value.Style( get = {"is*", "get*"}, // Detect 'get' and 'is' prefixes in accessor methods init = "set*", // Builder initialization methods will have 'set' prefix typeAbstract = {"Abstract*"}, // 'Abstract' prefix will be detected and trimmed typeImmutable = "*", // No prefix or suffix for generated immutable type builder = "new", // construct builder using 'new' instead of factory method build = "create", // rename 'build' method on builder to 'create' visibility = ImplementationVisibility.PUBLIC, // Generated class will be always public defaults = @Value.Immutable(copy = false)) // Disable copy methods by default
35. Sample Project, check it out! github.com/friendlyrobotnyc/FriendlyImmutables