| Description |
1 online resource (344 pages) |
| Physical Medium |
polychrome |
| Description |
text file |
| Summary |
The ease with which we write an application has been increasing, but with increasingly complex application come the need to address their performance. A balancing act between implementing complex applications easily and keeping its performance optimum is need of the hour. In this book we explore how to achieve this crucial balance while ... |
| Contents |
Cover -- Title Page -- Copyright and Credits -- Dedication -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: Money -- The Quote Manager Application -- Setting up the environment -- The application architecture -- Application project highlights -- The build -- The persistence layer -- The service layer -- The JAX-RS layer -- The WebSocket layer -- Provision some data -- Application summary -- The application business -- The application design -- The application server -- Testing the application -- Get a quote price the JAX-RS way -- Get the price, the WebSocket way -- Setting up MySQL -- Conclusion -- Summary -- Chapter 2: Looking Under the Cover -- What is This EE Thing? -- Context and Dependency Injection -- what did you do to my beans? -- IoC -- a pretty simple example -- The main features of CDI -- Injections -- Scopes -- Interceptors/decorators -- Events -- Dynamic lookups -- JAX-RS -- the servlet router -- The router -- Marshalling -- Filter and interceptors -- @Suspended or asynchronous operation -- JPA -- the database link -- From JPA to the database -- Model and implications -- The Java Transaction API -- Server resources -- DataSource configuration -- Java EE and performances -- Ensure you know the server -- Ensure you know your application -- Ensure you know your resources -- Summary -- Chapter 3: Monitor Your Application -- Java tools to know what my application is doing -- The jcmd command -- the small command line utility that does a lot -- Thread.print -- Memory -- JVisualVM -- the UI for JVM monitoring -- How to connect remotely -- Java Mission Control -- GlassFish ad hoc monitoring -- Libraries monitor your application -- Counters, gauges, timers, and more -- Instrumenting the code -- CDI instrumentation -- Implementing your own configurable monitoring interceptor. |
|
Javaagent -- a complex but powerful instrumentation -- Sirona javaagent -- SQL Monitoring -- Data aggregation -- Tracing -- APM -- Summary -- Chapter 4: Application Optimization -- Memory Management and Server Configuration -- Java and the memory -- Garbage collector -- Garbage collector algorithms -- The serial collector -- Parallel and parallel compacting collectors -- Concurrent Mark Sweep (CMS) -- Garbage First (G1) -- Common memory settings -- Debugging GC behavior -- Heap dump -- Java EE and the resources -- DataSource -- Java EE and pools -- Java EE and HTTP pools -- Java EE implicit features -- Summary -- Chapter 5: Scale Up -- Threading and Implications -- Java EE threading model -- Thread data and consistency -- Concurrent data access -- Java and thread safety -- Synchronized -- Locks -- java.util.concurrent -- The volatile data -- Java EE and threads -- CDI asynchronous events -- EJB @Asynchronous -- EE concurrency utilities for Java EE -- ManagedExecutorService -- ManagedScheduledExecutorService -- Java EE threads -- ContextService -- EJB @Lock -- HTTP threads -- Server side -- Client side -- Reactive programming and Java EE -- Message passing and Java EE -- Summary -- Chapter 6: Be Lazy -- Cache Your Data -- Caching challenges -- How does the cache work? -- The cache key -- Eviction policy -- Least Recently Used (LRU) -- First In First Out (FIFO) -- Random -- Least Frequently Used (LFU) -- Cache eviction trigger -- Cache storage -- memory or not -- Consistency of the data -- HTTP and caching -- Cache-Control -- ETag -- Vary -- HTTP caching and the Java EE API -- HTTP 2 promise -- JCache -- the standard cache of Java EE -- Setting up JCache -- Programmatic API -- JCache configuration -- CDI integration -- Cache configuration -- @CacheDefaults -- Cache key -- Cache once -- Summary -- Chapter 7: Be Fault-Tolerant -- It will fail, no doubt! |
|
Load balancing -- pick the best one -- Transparent load balancing -- client versus server -- Common strategies -- The round-robin algorithm -- Random load balancing -- Link to failover -- Sticky session -- The scheduling algorithm -- Load balancing or proxy -- additional features -- Failover -- Switching to another system -- Local fallback -- Fallback code structure -- Microprofile to the rescue -- Failover extension -- Fallback handling -- caching, an alternative solution -- Circuit breaker -- Bulk head -- Timeouts -- Timeouts for code without timeouts -- Summary -- Chapter 8: Loggers and Performances -- A Trade-Off -- I log, you log, they log -- Logging frameworks and concepts -- Logger -- Logger Factory -- LogRecord -- Handler -- Filter -- Formatter -- Level -- Logging invocations -- Filters -- Formatters -- Using handlers -- Logging components and Java EE -- Logging patterns -- Testing your level -- Using templates in your messages -- Asynchronous or not? -- Logging implementations -- which one to pick -- Logging facade -- the good bad idea -- Logging frameworks -- Log4j -- Log4j2 -- Logback -- JUL -- Choosing an implementation -- Summary -- Chapter 9: Benchmarking Your Application -- Benchmarking -- validating your application against your SLA -- Benchmark, benchmark, benchmark -- Preparing your benchmark -- Defining the benchmark criteria -- Defining the metric -- Defining acceptance criteria -- Defining the scenario -- Defining the environment -- The machines -- The network -- Databases and remote services -- The server -- Automatize your scenarios -- JMeter -- Gatling -- Other tools -- Ensuring you have support -- Time boxing your optimization benchmark -- Installing and resetting procedures -- Benchmark iterations -- Iterating -- Changing a single setting at a time -- Resetting any state between runs -- Warming up your system -- After your benchmark. |
|
Writing a report -- Updating your default configurations -- Reviewing the conclusions -- Enriching your project backlog -- Summary -- Chapter 10: Continuous Performance Evaluation -- Writing performance tests -- the pitfalls -- Writing performance tests -- JMH -- the OpenJDK tool -- Writing a benchmark with JMH -- The state -- Creating your first JMH benchmark -- BlackHole to be a star -- Running the benchmarks -- Integrating JMH with JUnit -- ContiPerf -- Arquillian and ContiPerf -- the diabolic pair -- JMeter and build integration -- Gatling and continuous integration -- Deploying your (benchmark) application -- Continuous integration platform and performance -- Summary -- Another Book You May Enjoy -- Index. |
| Local Note |
eBooks on EBSCOhost EBSCO eBook Subscription Academic Collection - North America |
| Subject |
Java (Computer program language)
|
|
Java (Computer program language) |
|
Application software -- Development.
|
|
Application software -- Development. |
|
Computers -- Systems Architecture -- Distributed Systems & Computing. |
|
Computers -- Programming Languages -- General. |
|
Programming & scripting languages: general. |
|
Distributed systems. |
|
Computers -- Programming Languages -- Java. |
| Genre/Form |
Electronic books.
|
| Other Form: |
Print version: Manni-Bucau, Romain. Java EE 8 High Performance : Master techniques such as memory optimization, caching, concurrency, and multithreading to achieve maximum performance from your enterprise applications. Birmingham : Packt Publishing, ©2018 |
| ISBN |
9781788472159 (electronic book) |
|
1788472152 (electronic book) |
|
178847306X |
|
9781788473064 |
| Standard No. |
9781788473064 |
|
