[Codemotion 2015] patrones de diseño con java8

Alonso Torres @alotor
Design Patterns

“
”
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

Los patrones definen:
soluciones a problemas frecuentes

¿
?
Son las soluciones con Java 8 las
mismas que con versiones anteriores

Alonso Torres
@alotor
mobro.co/alotor

1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3

1994
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3

1998 - J2SE 1.2
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3
Adopción masiva del
lenguaje

2004 - J2SE 5.0
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3
Genéricos
Anotaciones
Enumerados
Nueva sintaxis
Concurrencia

2011 - Java SE 7
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3
InvokeDynamic
NIO 2
Nueva concurrencia

2014 - Java SE 8
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3

Java 8
● Lambda expressions
● Functional interfaces
● Default methods
● Streams

Las lambdas son lo mejor que le ha
pasado a Java desde….

Las lambdas son lo mejor que le ha
pasado a Java.

C#
1990 1995 2000 2005 2010 2015
1.0 1.2 1.4 5 6 7 81.3

ActionScript Groovy Perl
C# Haskell PHP
C++ JavaScript Python
Clojure Lisp R
Curl Logtalk Racket
D Lua Ruby
Dart Mathematica Scala
Dylan Maple Scheme
Erlang Matlab Smalltalk
Elixir Maxima Standard ML
F# OCaml TypeScript
Go Object Pascal Tcl
Gosu Objective-C VisualBasic .NET

Fortran 1957
C 1969
Ada 1977
Cobol 1989

Features
● Default methods
● Streams

public Integer addition(Integer x, Integer y) {
return x + y;
}
public void sayHello(String name) {
System.out.println("Hello " + name);
}
public Float giveMePi() {
return 3.15f;
}

(Integer x, Integer y) -> {
return x + y;
};
(String name) -> {
System.out.println("Hello" + name);
};
() -> {
return 3.15f;
};

(Integer x, Integer y) -> x + y;
(String name) -> {
};
() -> 3.15f

(String name) -> {
};
() -> 3.15f
PARÁMETROS CUERPO

(String name) -> System.out.println("Hello" + name);
() -> 3.15f

Thread th = new Thread(new Runnable(){
@Override
public void run() {
System.out.println(">> Another thread"));
}
});
th.start();
Creando hilos

Thread th = new Thread(() ->
th.start();
Creando hilos

Me váis a llamar loco
pero…

Client Invoker
Receiver
+action()
ConcreteCommand
+execute()
Command
+execute()

new Invoker().addCommand(new Command() {
@Override
public void execute() {
receiver.action();
}
});

new Transaction().doWithTransaction(new Command() {
@Override
myBusinessLogic.calculateInterests();
}
});

new Context().doAsync(new Command() {
@Override
networkManager.downloadFile();
}
});

Client Invoker
Receiver
+action()
ConcreteCommand
+execute()
Command
+execute()
Lambda

new Invoker().addCommand(
() -> receiver.action();
);

new Invoker().addCommand(
receiver::action
);
Method Reference

Method Reference:
Transformar un método en una
lambda

() -> receiver.action()
(el) -> el.toString()
() -> Runtime.getInstance()
() -> new Receiver()

() -> receiver.action() receiver::action
(el) -> el.toString() Object::toString
() -> Runtime.getInstance() Runtime::getInstance
() -> new Receiver() Reciver::new

Instance method reference
(objeto concreto)
Instance method reference
(cualquier objeto)
Static method reference
Constructor reference
receiver::action
Object::toString
Runtime::getInstance
Reciver::new

(Integer x, Integer y) ->
receiver.action(x, y)
Math.max(x, y)
(String str) ->
new String(str)

receiver.action(x, y)
receiver::action
Math.max(x, y)
Math::max
(String str) ->
new String(str)
String::new

new Transaction().doWithTransaction(
myBusinessLogic::calculateInterests
);
new ThreadPool().doInThread(
networkManager::downloadFile
);
new Transaction().doWithTransaction(
networkManager::downloadFile
);
new ThreadPool().doInThread(
myBusinessLogic::calculateInterests
);

Client Invoker
Receiver
+action()
Command
+execute()

() -> 3.15f
¿Qué TIPO tienen las lambdas?

Object addition =
Object sayHello =
Object giveMePi =
() -> 3.15f
¿Qué TIPO tienen las lambdas?

The target type of this expression must be a
functional interface

() -> 3.15f
Integer addition(Integer x, Integer y)
void sayHello(String name)
Float giveMePi()

Functional interfaces
public interface Addition {
Integer addition(Integer x, Integer y);
}
public interface SayHello {
void sayHello(String name);
}
public interface GiveMePi {
Float giveMePi();
}

public Integer addition(Integer x, Integer y);
}
1 sólo método

}
Addition addition =

}
public interface Operation<T extends Number> {
public T do(T x, T y);
}
Operation<Integer> addition =

PROBLEMA
Sólo funciona con interfaces
● NO pueden ser clases
● NI clases abstractas

Default Methods
default Integer substraction(Integer x, Integer y) {
return addition(x, -y);
}
}

}
Addition addition =
Si tenemos que definir una “Functional Interface”
por cada lambda...
¿Qué hemos ganado?

Java 8
viene con las interfaces más comunes
DE SERIE

import java.util.function.*
BiConsumer<T,U> IntBinaryOperator LongUnaryOperator
BiFunction<T,U,R> IntConsumer ObjDoubleConsumer<T>
BinaryOperator<T> IntFunction<R> ObjIntConsumer<T>
BiPredicate<T,U> IntPredicate ObjLongConsumer<T>
BooleanSupplier IntSupplier Predicate<T>
Consumer<T> IntToDoubleFunction Supplier<T>
DoubleBinaryOperator IntToLongFunction ToDoubleBiFunction<T,U>
DoubleConsumer IntUnaryOperator ToDoubleFunction<T>
DoubleFunction<R> LongBinaryOperator ToIntBiFunction<T,U>
DoublePredicate LongConsumer ToIntFunction<T>
DoubleSupplier LongFunction<R> ToLongBiFunction<T,U>
DoubleToIntFunction LongPredicate ToLongFunction<T>
DoubleToLongFunction LongSupplier UnaryOperator<T>
DoubleUnaryOperator LongToDoubleFunction
Function<T,R> LongToIntFunction

() -> 3.15f
¿Qué TIPO tienen?
public Integer addition(Integer x, Integer y)
public void sayHello(String name)
public Float giveMePi()

BiConsumer<T,U> IntBinaryOperator LongUnaryOperator
BiFunction<T,U,R> IntConsumer ObjDoubleConsumer<T>
BinaryOperator<T> IntFunction<R> ObjIntConsumer<T>
BiPredicate<T,U> IntPredicate ObjLongConsumer<T>
BooleanSupplier IntSupplier Predicate<T>
Consumer<T> IntToDoubleFunction Supplier<T>
DoubleBinaryOperator IntToLongFunction ToDoubleBiFunction<T,U>
DoubleConsumer IntUnaryOperator ToDoubleFunction<T>
DoubleFunction<R> LongBinaryOperator ToIntBiFunction<T,U>
DoublePredicate LongConsumer ToIntFunction<T>
DoubleSupplier LongFunction<R> ToLongBiFunction<T,U>
DoubleToIntFunction LongPredicate ToLongFunction<T>
DoubleToLongFunction LongSupplier UnaryOperator<T>
DoubleUnaryOperator LongToDoubleFunction
Function<T,R> LongToIntFunction
import java.util.function.*

BinaryOperator<Integer> addition =
Consumer<String> sayHi =
Supplier<Float> giveMePi =
() -> 3.15f

BinaryOperator<Integer> addition =
(x, y) -> x + y;
Consumer<String> sayHi =
(name) -> System.out.println("Hello" + name);
Supplier<Float> giveMePi =
() -> 3.15f

Thread th = new Thread(() ->
th.start();
java.lang.Runnable

JButton button = new JButton("Button");
button.addActionListener((event) ->
System.out.println("Mouse: " + event);
);
java.awt.ActionListener

ConcreteObserverA
+notify()
ConcreteObserverB
+notify()
Observer
+notify()
ObservedClass
+registerObserver()
+unregisterObserver()
+notifyObservers()
Functional Interface
Lambdas!

@FunctionalInterface
public static interface Observer {
public void notify(Object change);
}

}
El compilador fallará si no
cumple con las condiciones
de una FI.

}
El compilador fallará si no
cumple con las condiciones
de una FI.
Tu yo del futuro te lo agradecerá

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.

}
}
}
}
Nuevo método de Java 8

observed.addObserver((change) -> {
new Thread(UIThread::update).start()
});
sbj.notifyChange("Change");

Hipótesis
¿Puede haber un patrón de más alto nivel?

new Invoker().addCommand(receiver::action);
observed.addObserver(receiver::action);

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);

List<Person> personList = new LinkedList<>();
Collections.sort(
personList,
(p1, p2) -> p1.age - p2.age
);
java.lang.Comparable<T>

List<Person> personList = new LinkedList<>();
Collections.sort(
personList,
(p1, p2) -> p1.age - p2.age
);
java.lang.Comparable<T>
DATOS
COMPORTAMIENTO

Collections.sort(
list,
(p1, p2) -> p1.getAge() - p2.getAge());
Collections.sort(
list,
(p1, p2) -> p1.getName().compareTo(p2.getName()));
Collections.sort(
list,
(p1, p2) -> -p1.getName().compareTo(p2.getName()));

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());
}
}

Collections.sort(
list,
PersonSortCriterias::sortByAge);
Collections.sort(
list,
PersonSortCriterias::sortByName);
Collections.sort(
list,
PersonSortCriterias::sortByNameReverse);

Set<Person> = new TreeSet<>(
PersonSortCriterias::sortByAge
);
Person theOlder = Collections.max(
list,
PersonSortCriterias::sortByAge
);
list.sort(PersonSortCriterias::sortByAge);

for (String str : list) {
System.out.println(str);
}

for (String str : list) {
if (str.length <= 5) {
}
}

for (String str : Collections.sort(list)) {
}
}

for (String str : Collections.sort(list).sublist(0, 10)) {
}
}

for (String str : Collections.sort(list).sublist(0, 10)) {
System.out.println(str.toUpperCase());
}
}

Problemas
● Susceptible a errores
● Difícil de razonar
● Difícil de reutilizar

Streams
● Interfaz fluida
● Evaluación perezosa
● Iterable
● Aprovechan toda la expresividad de las
lambdas

list.stream()
.forEach(System.out::println);

list.stream()
.filter(s -> s.length <= 5)

list.stream()
.sorted()

list.stream()
.sorted()
.limit(10)

list.parallelStream()
.sorted()
.limit(10)

Funciones importantes
● Map
● Filter
● Reduce

MAP - FILTER - REDUCE
list.stream()
.map(String::toUpperCase)
"banana"
"apple"
"pear"
"pineapple"
"lemon"
"mango"
"raspberry"
"melon"
"BANANA"
"APPLE"
"PEAR"
"PINEAPPLE"
"LEMON"
"MANGO"
"RASPBERRY"
"MELON"

list.stream()
"banana"
"apple"
"pear"
"pineapple"
"lemon"
"mango"
"raspberry"
"melon"
"apple"
"pear"
"lemon"
"mango"
"melon"

list.stream()
.reduce("", (acc, elem) -> acc + ", " + elem);
"banana"
"apple"
"pear"
"pineapple"
"lemon"
"mango"
"raspberry"
"melon"
"banana,apple,pear,pineapple,...

Chain of
responsibility
PATRÓN

HANDLER HANDLER HANDLER HANDLER HANDLER
request

HANDLER HANDLER HANDLER HANDLER HANDLERrequest

public interface Handler {
public Request handleRequest(Request req);
}

public interface Handler extends Function<Request, Request> {
}

List<Handler> chain = new LinkedList<>();
chain.add(Request::session);
chain.add(Request::securityCheck);
chain.add(Request::cookies);
chain.add(Request::getParameters);

Request req = new Request();
Request processed =
chain.stream()
.reduce(initial value,
accumulation function)

Request processed =
chain.stream()
.reduce(req,
accumulation function)

Request processed =
chain.stream()
.reduce(req,
(old, handler) -> handler.apply(old))

HANDLER HANDLER HANDLER HANDLER HANDLER
request
CHAIN (HANDLER)

List<Handler> filters = new LinkedList<>();
filters.add(Request::session);
filters.add(Request::securityCheck);
filters.add(Request::cookies);
filters.add(Request::getParameters);
Handler filterChain =
filters.stream()
.reduce(
initial value,
accumulation function);

filters.stream()
.reduce(
(r) -> r,
accumulation function);

filters.stream()
.reduce(
(r) -> r,
(f1, f2) -> f1.andThen(f2));

filters.stream()
.reduce(
Function.identity(),
Function::andThen);

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

Java SE 8
● Default methods
● Streams

Patrones
● Command
● Strategy
● Observer
● Iterator
● Chain of responsibility

Problema
● El comportamiento y el contexto son diferentes
● Encapsular los datos
● Composición de comportamiento
Solución
● High order functions (Lambdas)

Sobre los hombros de gigantes
Mario Fusco Venkat Subramaniam Samir Talwar
https://youtu.be/K6BmGBzIqW0 https://vimeo.com/122645679https://youtu.be/8qcHPEyLkPE

@alotor
mobro.co/alotor
¿Preguntas?
@alotor

Referencias
● https://en.wikipedia.org/wiki/Java_version_history
● http://www.studytrails.com/java/java8/Java8_Lambdas_FunctionalProgramming.jsp
● https://blog.idrsolutions.com/2015/02/java-8-method-references-explained-5-minutes/
● http://www.infoq.com/articles/Java-8-Lambdas-A-Peek-Under-the-Hood
● http://www.javaworld.com/article/2078675/core-java/design-patterns--the-big-picture--part-2--gang-
of-four-classics-revisited.html
● http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns-in-javas-core-libraries
● https://www.questers.com/sites/all/themes/questers/sec_presentation/java8lambdas.html
● http://www.slideshare.net/jaxlondon2012/lambda-a-peek-under-the-hood-brian-goetz
● http://www.infoq.com/presentations/lambda-invokedynamic?
utm_source=infoq&utm_medium=videos_homepage&utm_campaign=videos_row1
● http://www.slideshare.net/DaewonJeong/scala-is-java8next
● http://programmers.stackexchange.com/questions/173441/what-triggered-the-popularity-of-lambda-
functions-in-modern-mainstream-programmi
● http://www.infoq.com/presentations/A-Brief-History-of-the-Java-World

Referencias
● http://j2objc.org/blog/2015/08/07/lambdas-in-java-8-dysfunctional-interfaces.html
● http://gafter.blogspot.com.es/2006/08/closures-for-java.html
● http://www.javaworld.com/article/2077569/core-java/java-tip-68--learn-how-to-implement-the-
command-pattern-in-java.html
● http://www.slideshare.net/mariofusco/fp-in-java-project-lambda-and-beyond?qid=11ae9463-c2e3-
4c54-842f-b228ce109200&v=default&b=&from_search=12
● http://www.norvig.com/design-patterns/design-patterns.pdf
● http://www.techempower.com/blog/2013/03/26/everything-about-java-8/
● http://www.oracle.com/technetwork/server-storage/ts-4961-159222.pdf
● http://talks.samirtalwar.com/design-patterns-in-the-21st-century.html

[Codemotion 2015] patrones de diseño con java8

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie [Codemotion 2015] patrones de diseño con java8

Ähnlich wie [Codemotion 2015] patrones de diseño con java8 (20)

Mehr von Alonso Torres

Mehr von Alonso Torres (8)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

[Codemotion 2015] patrones de diseño con java8