SOLID mit Java 8

SOLID mit Java 8
Java Forum Stuttgart 2016

Roland Mast
Sybit GmbH
Agiler Software-Architekt
Scrum Master
roland.mast@sybit.de

Roland Mast
Sybit GmbH

5 Principles
• Single responsibility
• Open Closed
• Liskov Substitution
• Interface Segregation
• Dependency Inversion
SOLID und Uncle Bob

Single Responsibility
Principle?
Principle?
A class should have
one, and only one,
reason to change.
A class should have
one, and only one,
reason to change.

// Strings in einem Array nach deren Länge sortieren
Arrays.sort(strings, new Comparator<String>() {
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
});
Arrays.sort(strings, (a, b) -> Integer.compare(a.length(), b.length()));
// Strings alphabetisch sortieren
Arrays.sort(strings, String::compareToIgnoreCase);
Lambdas

List<Person> persons = Arrays.asList(
// name, age, size
new Person("Max", 18, 1.9),
new Person("Peter", 23, 1.8),
new Person("Pamela", 23, 1.6),
new Person("David", 12, 1.5));
Double averageSize = persons
.stream()
.filter(p -> p.age >= 18)
.collect(Collectors.averagingDouble(p -> p.size));
Lambdas in Streams
Iteration über
die Daten
Filtern anstatt
if (age >= 18) {
keep();
}
Collectors berechnet
den Durchschnitt

public interface BinaryOperation {
long identity();
long binaryOperator(long a, long b);
}
public class Sum implements BinaryOperation {
@Override
public long identity() { return 0L; }
@Override
public long binaryOperator(long a, long b) {
return a + b;
}
}
private long[] data;
public long solve() {
int threadCount = Runtime.getRuntime().availableProcessors();
ForkJoinPool pool = new ForkJoinPool(threadCount);
pool.invoke(this);
return res;
}
protected void compute() {
if (data.length == 1) {
res=operation.binaryOperator(operation.identity(), data[0]);
} else {
int midpoint = data.length / 2;
long[] l1 = Arrays.copyOfRange(data, 0, midpoint);
long[] l2 = Arrays.copyOfRange(data, midpoint, data.length);
SolverJ7 s1 = new SolverJ7(l1, operation);
SolverJ7 s2 = new SolverJ7(l2, operation);
ForkJoinTask.invokeAll(s1, s2);
res = operation.binaryOperator(s1.res, s2.res);
}
}
Daten müssen
selbst aufgeteilt und
zusammengeführt
werden
Interface
und Klasse
definieren
Operation
Parallele Summenberechnung
Threadpool muss selbst
erzeugt werden

private long[] data;
public long sumUp() {
return LongStream.of(data)
.parallel()
.reduce(0, (a, b) -> a + b);
}
Parallel ReduceSingle Responsibility

Single Responsibility Principle
Lambdas + Streams
Kapseln Verantwortlichkeiten

Open/Closed
Principle?
Open/Closed
Principle?
You should be able to
extend a classes
behavior, without
modifying it.
You should be able to
extend a classes
behavior, without
modifying it.

public interface Iterable<T> {
Iterator<T> iterator();
}
Iterable Interface
void forEach(Consumer<? super T> action);
Spliterator<T> spliterator();
}
Open/Closed

default void forEach(Consumer<? super T> action) {
for (T t : this) { action.accept(t); }
}
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
Default-ImplementationOpen/Closed

Open/Closed Principle
Default-Implementierungen in Interfaces
Flexibel Frameworks erweitern

Liskov's Substitution
Principle?
Liskov's Substitution
Principle?
“No new exceptions should be thrown by methods of the subtype,
except where those exceptions are themselves subtypes of exceptions
thrown by the methods of the supertype.”
Derived classes must
be substitutable for
their base classes.
Derived classes must
be substitutable for
their base classes.

/**
* Find the first occurrence of a text in files
* given by a list of file names.
*/
public Optional<String> findFirst(
String text, List<String> fileNames) {
return fileNames.stream()
.map(name -> Paths.get(name))
.flatMap(path -> Files.lines(path))
.filter(s -> s.contains(text))
.findFirst();
}
Checked Exception in StreamsLiskov‘s Substitution
public final class Files {
public static Stream<String> lines(Path path)
throws IOException {
BufferedReader br =
Files.newBufferedReader(path);
try {
return br.lines()
.onClose(asUncheckedRunnable(br));
} catch (Error|RuntimeException e) {
….. 8< ……………………
br.close();
….. 8< ……………………
}
}
IOException

/**
* Find the first occurrence of a text in files
* given by a list of file names.
*/
public Optional<String> findFirst(
String text, List<String> fileNames) {
return fileNames.stream()
.map(name -> Paths.get(name))
.flatMap(path -> mylines(path))
.filter(s -> s.contains(text))
.findFirst();
}
Handle IOExceptionLiskov‘s Substitution
private Stream<String> mylines(Path path){
try (BufferedReader br =
Files.newBufferedReader(path)) {
return br.lines()
.onClose(asUncheckedRunnable(br));
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}

private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
throw new UncheckedIOException(e);
}
};
}
Close StreamLiskov‘s Substitution
java.io.BufferedReader::lines +
java.nio.file.Files::find, lines, list, walk
werfen UncheckedIOException beim Zugriff innerhalb des Streams

Liskov´s Substitution Principle
Files + BufferedReader
UncheckedIOException nur bei neuen Methoden

Interface Segregation
Principle?
Interface Segregation
Principle?
Make fine grained
interfaces that are
client specific.
Make fine grained
interfaces that are
client specific.

public interface ParserContext {
Reader getReader();
void handleLine(String line);
void handleException(Exception e);
}
public void parse(final ParserContext context) {
try (BufferedReader br = new BufferedReader(context.getReader())) {
String line;
do {
line = br.readLine();
if (line != null) { context.handleLine(line); }
} while (line != null)
} catch (IOException e) { context.handleException(e); }
}
InterfacesInterface Segregation
1 Interface mit
3 Methoden

<T> T withLinesOf(Supplier<Reader> reader,
Function<Stream<String>, T> handleLines,
Function<Exception, RuntimeException> transformException) {
try (BufferedReader br = new BufferedReader(reader.get())) {
return handleLines.apply(br.lines());
throw transformException.apply(e);
}
}
Functional InterfacesInterface Segregation
3 separate
Interfaces

withLinesOf(
() -> reader,
lines -> lines
.filter(line -> line.contains("ERROR"))
.map(line -> line.split(":")[1])
.collect(toList()),
LogAnalyseException::new);
Functional InterfacesInterface Segregation

LocalTimeInterface Segregation

Interface Segregation Principle
Functional Interfaces
Ermutigen zum Auftrennen von Interfaces

Dependency Inversion
Principle?
Dependency Inversion
Principle?
Depend on abstractions,
not on concretions.
Depend on abstractions,
not on concretions.

Warning: JDK internal APIs are unsupported and
private to JDK implementation that are
subject to be removed or changed incompatibly
and could break your application.
Please modify your code to eliminate
dependency on any JDK internal APIs.
For the most recent update on JDK internal API
replacements, please check:
https://wiki.openjdk.java.net/display/JDK8/Jav
a+Dependency+Analysis+Tool
jdeps -jdkinternalsDependency Inversion

jdeps -jdkinternals classes
classes -> C:Program FilesJavajdk1.8.0_74jrelibrt.jar
de.sybit.warranty.facade.impl.DefaultWarrantyFacade (classes)
-> com.sun.xml.internal.fastinfoset.stax.events.Util
JDK internal API (rt.jar)
jdepsDependency Inversion
return (Util.isEmptyString(param) || "*".equals(param));

public List<String> filterError(Reader reader) {
try (BufferedReader br =new BufferedReader(reader)){
return br.lines()
.collect(toList());
throw new LogAnalyseException(e);
}
}
LambdasDependency Inversion
Filterimplementierung ist
abhängig von konkreten
Implementierungen

private Parser parser = new Parser();
public List<String> filterError(Reader reader) {
return parser.withLinesOf(
reader,
lines -> lines
.collect(toList()),
LogAnalyseException::new);
}
filterError() ist nur
noch abhängig von
Abstraktionen

public class Parser {
<T> T withLinesOf(Reader reader,
Function<Stream<String>, T> handleLines,
Function<Exception, RuntimeException> onError) {
try (BufferedReader br = new BufferedReader(reader)) {
return handleLines.apply(br.lines());
throw onError.apply(e);
}
}
}
withLinesOf()
kapselt die
Abhängigkeiten

Dependency Inversion Principle
Lambdas
Sind starke Abstraktionen

module MyClient {
requires MyService;
}
module MyService {
exports de.sybit.myservice;
}
SOLID mit Java 9 - Jigsaw

“The principles of software design still apply, regardless
of your programming style. The fact that you've decided
to use a [functional] language that doesn't have an
assignment operator does not mean that you can ignore
the Single Responsibility Principle; or that the Open
Closed Principle is somehow automatic.”
Robert C. Martin: OO vs FP (24 November 2014)
http://blog.cleancoder.com/uncle-bob/2014/11/24/FPvsOO.html
SOLID mit Java – OO vs FP

Roland Mast, Sybit GmbH

SOLID mit Java 8

More Related Content

What's hot (20)

Viewers also liked (10)

Recently uploaded (20)

SOLID mit Java 8