TDC2018SP | Trilha Java - Java SE 8 for Java EE Developers

Java SE 8 for Java
EE Developers
Reza Rahman
Senior Vice President, Author, Blogger
reza_rahman@lycos.com
@reza_rahman

https://axoniq.io

Java SE 8 and Java EE
• Java SE 8 is one of the most significant releases in years
• Extremely well adopted
• Java EE 7 runtimes already support Java SE 8
• Specific Java SE 8 alignment done in Java EE 8

Lambdas
• Introducing functional programming without breaking Java
• Requires change in thinking to become true believer
• Practical benefits for the rest of us
• Streams, CompletableFuture
• An actual syntax change at the language level
• Syntactic sugar over anonymous inner classes?

Lambdas
The Problem
List<Student> students = ...
double highestScore = 0.0;
for (Student s : students) {
if (s.gradYear == 2011) {
if (s.score > highestScore) {
highestScore = s.score;
}
}

Lambdas
An Inelegant Solution
List<Student> students = ...
double highestScore = students.
filter(new Predicate<Student>() {
public boolean op(Student s) {
return s.getGradYear() == 2011;
}
}).
map(new Mapper<Student,Double>() {
public Double extract(Student s) {
return s.getScore();
}
}).
max();

Lambdas
The Elegant Solution
SomeList<Student> students = ...
double highestScore = students.
filter(Student s -> s.getGradYear() == 2011).
map(Student s -> s.getScore()).
max();

Asynchronous Servlet and Lambdas
@WebServlet(urlPatterns={"/report"}, asyncSupported=true)
public class AsyncServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response) {
...
final AsyncContext asyncContext = request.startAsync();
asyncContext.start(() -> {
ReportParameters parameters =
parseReportParameters(asyncContext.getRequest());
Report report = generateReport(parameters);
printReport(report, asyncContext);
asyncContext.complete();
});
}
}

Streams
• Applying lambdas to the Collections API
• Bulk operations
• Sequence (“stream”) of data
int sum = transactions.stream().
filter(t -> t.getBuyer().getCity().equals(“Philly”)).
mapToInt(Transaction::getPrice).
sum();
Source
Intermediate operation
Terminal operation

JSON-P Stream
[
{
"name":"Duke",
"gender":"male",
"phones":[
"home":"650‐123‐4567",
"mobile":"650‐111‐2222"
]
},
{
"name":"Jane", ...
]
JsonArray contacts =
Json.createArrayBuilder()
.add(...

JSON-P Stream
JsonArray females =
contacts.getValuesAs(JsonObject.class).stream()
.filter(x -> "female".equals(x.getString("gender")))
.map(x -> (x.getString("name")))
.collect(JsonCollectors.toJsonArray());

Date/Time API
• Significant improvement over current Java date types
• Date, Calendar
• Unified, comprehensive, modern model
• Builder pattern, fluent API
• Manipulating temporal values
• Better internationalization

Date/Time API
Key Artifacts
• LocalTime
• LocalDate
• LocalDateTime
• ZonedDateTime
• Instant
• Duration
• Period

Date/Time API Examples
// Get the current date and time
LocalDateTime now = LocalDateTime.now();
// Returns formatted date and time
// “2013-10-21T20:25:15:16.256”
now.toString();
// Add 5 hours
LocalDateTime later = now.plus(5, HOURS);
// Subtract 2 days
LocalDateTime earlier = now.minus(2, DAYS);

Date/Time API with JPA
@Entity
public class Accident {
@Temporal(TemporalType.TIMESTAMP)
@Past
private Instant when;
}

Date/Time API with JSF
<h:form>
<h:inputText id = “date”
value = “#{registerAccident.when}”
size = “20” required=“true”
label = “when” />
...
@Named @ViewScoped
public class RegisterAccident {
Instant when;
...

Repeatable Annotations
• In Java SE 8, annotations can now be repeated
• A lot of applicability in Java EE
• @DataSourceDefinition
• @NamedQuery
• @JMSDestinationDefinition
• @JMSConnectionFactoryDefinition
• @MailSessionDefinition
• @Schedule

Repeatable Annotations in Java EE
@NamedQueries({
@NamedQuery(name=SELECT_ALL, query="..."),
@NamedQuery(name=COUNT_ALL, query="...")
})
public class Customer {
...
@NamedQuery(name=SELECT_ALL, query="...")
@NamedQuery(name=COUNT_ALL, query="...")
public class Customer {
...

Completable Future
• Futures and callbacks both have serious flaws
• Especially when it comes to significantly “reactive” code
• CompletableFuture significantly better
• Non-blocking, event-driven, composable and functional (via lambdas)
• JavaScript “promises” for Java

Looks are Deceiving…
Person p = ...
Assets assets = getAssets(p);
Liabilities liabilities = getLiabilities(p);
Credit credit = calculateCreditScore(assets, liabilities);
History history = getHealthHistory(p);
Health health = calculateHeathScore(history);
Coverage coverage = underwrite(credit, health);

The Problem with Futures (and Callbacks)
Person p = ...
Future<Assets> f1 = executor.submit(() -> getAssets(p));
Future<Liabilities> f2 = executor.submit(
() -> getLiabilities(p));
Future<Credit> f3 = executor.submit(
() -> calculateCreditScore(f1.get(), f2.get()));
// The unrelated calls below are now blocked for no reason
Future<History> f4 = executor.submit(() -> getHealthHistory(p));
Future<Health> f5 = executor.submit(
() -> calculateHeathScore(f4.get()));
// Unrelated paths join below
Future<Coverage> f6 = executor.submit(
() -> underwrite(f3.get(), f5.get()));
Callbacks don’t block, but introduce callback hell…
https://github.com/m-reza-rahman/reactive_javaee/blob/master/CallbackHell.java

CompletableFuture Basics
public CompletableFuture<Confirmation> processPayment(
Order order) {
CompletableFuture<Confirmation> future =
new CompletableFuture<>();
executor.execute(() -> {
Confirmation status = ...
future.complete(status);
});
return future;
}
paymentService
.processPayment(order)
.thenAccept(
confirmation -> System.out.println(confirmation));

Functional Reactive to the Rescue?
CompletableFuture<Assets> getAssets =
CompletableFuture.supplyAsync(() -> getAssets(person));
CompletableFuture<Liabilities> getLiabilities =
CompletableFuture.supplyAsync(() -> getLiabilities(person));
CompletableFuture<Credit> calculateCreditScore =
getAssets.thenCombineAsync(getLiabilities,
(assets, liabilities) ->
calculateCreditScore(assets, liabilities));
CompletableFuture<Health> calculateHeathScore =
CompletableFuture.supplyAsync(() -> getHealthHistory(person))
.thenApplyAsync(history -> calculateHeathScore(history));
Coverage coverage =
calculateCreditScore.thenCombineAsync(calculateHeathScore,
(credit, health) -> underwrite(credit, health)).join();

CompletableFuture with JAX-RS
CompletionStage<Assets> getAssets = client
.target("assets/{ssn}")
.resolveTemplate("ssn", person.getSsn())
.request("application/json")
.rx()
.get(Assets.class);
CompletionStage<Liabilities> getLiabilities = client
.target("liabilities/{ssn}")
.resolveTemplate("ssn", person.getSsn())
.request("application/json")
.rx()
.get(Liabilities.class);
Coverage coverage = getAssets.thenCombine(getLiabitities,
(assets, liabilities) -> underwrite(assets, liabilities))
.toCompletableFuture().join();

Java EE 8/GlassFish 5 Release
https://blogs.oracle.com/theaquarium/java-ee-8-is-final-and-glassfish-50-is-released

Jakarta EE
https://jakarta.ee

Summary
• Java SE 8 is one of the most significant releases in years
• Most Java EE 7 runtimes support Java SE 8
• Java EE 8 has been aligned with Java SE 8

TDC2018SP | Trilha Java - Java SE 8 for Java EE Developers

TDC2018SP | Trilha Java - Java SE 8 for Java EE Developers

More Related Content

Similar to TDC2018SP | Trilha Java - Java SE 8 for Java EE Developers (20)

More from tdc-globalcode (20)

Recently uploaded (20)

TDC2018SP | Trilha Java - Java SE 8 for Java EE Developers