Presentada en el Codemotion Madrid 2015.
Abstract:
Han pasado más de 20 años desde la publicación del famoso libro "Patrones de diseño" por el grupo conocido como "Gang of Four".
Durante años, estos patrones han mantenido su actualidad por ser lo suficientemente genéricos para todo tipo de software y resolver problemas comunes de diseño de las aplicaciones que desarrollamos a diario.
Pero algo ha cambiado con Java 8.
Con las nuevas características de Java 8, y en especial las lambdas, es necesario revisitar estos famosos patrones para adaptarlos a sus nuevas funcionalidades.
En esta charla repasaremos algunos de los famosos patrones viendo como adaptarlos a las nuevas características de Java. Además, podremos ver como mejorar nuestro tradicional diseño orientado a objetos gracias a las lambdas y a la programación funcional.
3. “
”
Cada patrón describe un problema recurrente en nuestro
entorno, así como la solución a ese problema, de tal modo que se
pueda aplicar esta solución un millón de veces, sin hacer lo mismo
dos veces.
- Christopher Alexander, A Pattern Language
81. public interface Addition {
public Integer addition(Integer x, Integer y);
}
Addition addition =
(Integer x, Integer y) -> x + y;
Si tenemos que definir una “Functional Interface”
por cada lambda...
¿Qué hemos ganado?
95. @FunctionalInterface
public static interface Observer {
public void notify(Object change);
}
El compilador fallará si no
cumple con las condiciones
de una FI.
Tu yo del futuro te lo agradecerá
96. public static class ObservedClass {
private List<Observer> observers = new LinkedList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyChange(Object change) {
observers.forEach((o) -> o.notify(change));
}
}
97. public static class ObservedClass {
private List<Observer> observers = new LinkedList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyChange(Object change) {
observers.forEach((o) -> o.notify(change));
}
}
Una estructura de datos que
guarda lambdas.
98. public static class ObservedClass {
private List<Observer> observers = new LinkedList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyChange(Object change) {
observers.forEach((o) -> o.notify(change));
}
}
Nuevo método de Java 8
103. Pasar comportamiento como argumentos
● El comportamiento se ejecutará en otro contexto
● “Separation of concerns”
● También conocido como: High Order Functions
new Invoker().addCommand(receiver::action);
observed.addObserver(receiver::action);
108. Reusing lambdas
class PersonSortCriterias {
public static int sortByAge(Person p1, Person p2) {
return p1.getAge() - p2.getName();
}
public static int sortByName(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
public static int sortByNameReverse(Person p1, Person p2) {
return -p1.getName().compareTo(p2.getName());
}
}
147. System.out.println("nProcessing request 1");
Request r1 = chain.apply(new Request());
System.out.println("nProcessing request 2");
Request r2 = chain.apply(new Request());
Processing request 1
>> process session
>> process securityCheck
>> process cookies
>> process getParameters
Processing request 2
>> process session
>> process securityCheck
>> process cookies
>> process getParameters
152. Problema
● El comportamiento y el contexto son diferentes
● Encapsular los datos
● Composición de comportamiento
Solución
● High order functions (Lambdas)
154. Sobre los hombros de gigantes
Mario Fusco Venkat Subramaniam Samir Talwar
https://youtu.be/K6BmGBzIqW0 https://vimeo.com/122645679https://youtu.be/8qcHPEyLkPE