Book Image

Java EE 8 High Performance

By : Romain Manni-Bucau
Book Image

Java EE 8 High Performance

By: Romain Manni-Bucau

Overview of this book

The ease with which we write applications has been increasing, but with this comes the need to address their performance. A balancing act between easily implementing complex applications and keeping their performance optimal is a present-day need. In this book, we explore how to achieve this crucial balance while developing and deploying applications with Java EE 8. The book starts by analyzing various Java EE specifications to identify those potentially affecting performance adversely. Then, we move on to monitoring techniques that enable us to identify performance bottlenecks and optimize performance metrics. Next, we look at techniques that help us achieve high performance: memory optimization, concurrency, multi-threading, scaling, and caching. We also look at fault tolerance solutions and the importance of logging. Lastly, you will learn to benchmark your application and also implement solutions for continuous performance evaluation. By the end of the book, you will have gained insights into various techniques and solutions that will help create high-performance applications in the Java EE 8 environment.

Related Content you might be interested in

Current Title:

Small book image
Java EE 8 High Performance
Romain Manni-Bucau
Jan, 2018 | 350 pages
Small book image
Java EE 8 Cookbook
Elder Moraes
Apr, 2018 | 382 pages
Small book image
Mastering Java EE Development with WildFly
Luca Stancapiano
Jun, 2017 | 468 pages
Small book image
Developing Middleware in Java EE 8
Abdalla Mahmoud
Jun, 2018 | 252 pages
Table of Contents (12 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Money – The Quote Manager Application
Money – The Quote Manager Application
Setting up the environment
The application architecture
Application project highlights
Application summary
The application server
Testing the application
Setting up MySQL
Conclusion
Summary
2
Looking Under the Cover – What is This EE Thing?
Looking Under the Cover – What is This EE Thing?
Context and Dependency Injection – what did you do to my beans?
JAX-RS – the servlet router
JPA – the database link
The Java Transaction API
Server resources
Java EE and performances
Summary
3
Monitor Your Application
Monitor Your Application
Java tools to know what my application is doing
GlassFish ad hoc monitoring
Libraries monitor your application
Summary
4
Application Optimization – Memory Management and Server Configuration
Application Optimization – Memory Management and Server Configuration
Java and the memory
Java EE and the resources
Summary
5
Scale Up – Threading and Implications
Scale Up – Threading and Implications
Java EE threading model
Thread data and consistency
Java EE and threads
Reactive programming and Java EE
Summary
6
Be Lazy; Cache Your Data
Be Lazy; Cache Your Data
Caching challenges
HTTP and caching
JCache – the standard cache of Java EE
Cache once
Summary
7
Be Fault-Tolerant
Be Fault-Tolerant
It will fail, no doubt!
Load balancing – pick the best one
Failover
Bulk head
Timeouts
Summary
8
Loggers and Performances – A Trade-Off
Loggers and Performances – A Trade-Off
I log, you log, they log
Logging frameworks and concepts
Logging invocations
Logging patterns
Logging implementations – which one to pick
Summary
9
Benchmarking Your Application
Benchmarking Your Application
Benchmarking – validating your application against your SLA
Preparing your benchmark
Benchmark iterations
After your benchmark
Summary
10
Continuous Performance Evaluation
Continuous Performance Evaluation
Writing performance tests – the pitfalls
Writing performance tests
Continuous integration platform and performance
Summary
11
Another Book You May Enjoy
Another Book You May Enjoy
Leave a review - let other readers know what you think

Java EE threading model

The Java EE philosophy has, for a long time, been able to give its users a well-defined and safe programming model. This is why most of the Java EE defaults are about being thread-safe, and that several specifications such as Enterprise Java Beans (EJB) defaults were preventing custom thread usage. It does not mean Java EE was ignoring threads at all, but explicitly using thread pools from an application was not very natural. Also, most of the time, the adopted coding style was either against Java EE's (strict) rules or were very verbose.

Before detailing the new API added by Java EE to help you develop concurrent applications, let's see the basic Java EE model and how it can already help you to scale.

If we take back the specifications included in Java EE 8 (full profile), we'll get a long list. Now, if we check which specifications use...

Previous Section
End of Section 2
Next Section