舉報 
會員
Java EE 8 High Performance
Ifyou'reaJavadeveloperlookingtoimprovetheperformanceofyourcodeorsimplywantingtotakeyourskillsuptothenextlevel,thenthisbookisperfectforyou.
最新章節
- Leave a review - let other readers know what you think
- Another Book You May Enjoy
- Summary
- Continuous integration platform and performance
- Deploying your (benchmark) application
- Gatling and continuous integration
品牌：中圖公司
上架時間：2021-06-30 18:31:17
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:15:07
- Another Book You May Enjoy
- Summary
- Continuous integration platform and performance
- Deploying your (benchmark) application
- Gatling and continuous integration
- JMeter and build integration
- Arquillian and ContiPerf – the diabolic pair
- ContiPerf
- Integrating JMH with JUnit
- Running the benchmarks
- BlackHole to be a star
- Creating your first JMH benchmark
- The state
- Writing a benchmark with JMH
- JMH – the OpenJDK tool
- Writing performance tests
- Writing performance tests – the pitfalls
- Continuous Performance Evaluation
- Summary
- Enriching your project backlog
- Reviewing the conclusions
- Updating your default configurations
- Writing a report
- After your benchmark
- Warming up your system
- Resetting any state between runs
- Changing a single setting at a time
- Iterating
- Benchmark iterations
- Installing and resetting procedures
- Time boxing your optimization benchmark
- Ensuring you have support
- Other tools
- Gatling
- JMeter
- Automatize your scenarios
- The server
- Databases and remote services
- The network
- The machines
- Defining the environment
- Defining the scenario
- Defining acceptance criteria
- Defining the metric
- Defining the benchmark criteria
- Preparing your benchmark
- Benchmark benchmark benchmark
- Benchmarking – validating your application against your SLA
- Benchmarking Your Application
- Summary
- Choosing an implementation
- JUL
- Logback
- Log4j2
- Log4j
- Logging frameworks
- Logging facade – the good bad idea
- Logging implementations – which one to pick
- Asynchronous or not?
- Using templates in your messages
- Testing your level
- Logging patterns
- Logging components and Java EE
- Using handlers
- Formatters
- Filters
- Logging invocations
- Level
- Formatter
- Filter
- Handler
- LogRecord
- Logger Factory
- Logger
- Logging frameworks and concepts
- I log you log they log
- Loggers and Performances – A Trade-Off
- Summary
- Timeouts for code without timeouts
- Timeouts
- Bulk head
- Circuit breaker
- Fallback handling – caching an alternative solution
- Failover extension
- Microprofile to the rescue
- Fallback code structure
- Local fallback
- Switching to another system
- Failover
- Load balancing or proxy – additional features
- The scheduling algorithm
- Sticky session
- Link to failover
- Random load balancing
- The round-robin algorithm
- Common strategies
- Transparent load balancing – client versus server
- Load balancing – pick the best one
- It will fail no doubt!
- Be Fault-Tolerant
- Summary
- Cache once
- Cache key
- @CacheDefaults
- Cache configuration
- CDI integration
- JCache configuration
- Programmatic API
- Setting up JCache
- JCache – the standard cache of Java EE
- HTTP 2 promise
- HTTP caching and the Java EE API
- Vary
- ETag
- Cache-Control
- HTTP and caching
- Consistency of the data
- Cache storage – memory or not
- Cache eviction trigger
- Least Frequently Used (LFU)
- Random
- First In First Out (FIFO)
- Least Recently Used (LRU)
- Eviction policy
- The cache key
- How does the cache work?
- Caching challenges
- Be Lazy; Cache Your Data
- Summary
- Message passing and Java EE
- Reactive programming and Java EE
- Client side
- Server side
- HTTP threads
- EJB @Lock
- ContextService
- Java EE threads
- ManagedScheduledExecutorService
- ManagedExecutorService
- EE concurrency utilities for Java EE
- EJB @Asynchronous
- CDI asynchronous events
- Java EE and threads
- The volatile data
- java.util.concurrent
- Locks
- Synchronized
- Java and thread safety
- Concurrent data access
- Thread data and consistency
- Java EE threading model
- Scale Up – Threading and Implications
- Summary
- Java EE implicit features
- Java EE and HTTP pools
- Java EE and pools
- DataSource
- Java EE and the resources
- Heap dump
- Debugging GC behavior
- Common memory settings
- Garbage First (G1)
- Concurrent Mark Sweep (CMS)
- Parallel and parallel compacting collectors
- The serial collector
- Garbage collector algorithms
- Garbage collector
- Java and the memory
- Application Optimization – Memory Management and Server Configuration
- Summary
- APM
- Tracing
- Data aggregation
- SQL Monitoring
- Sirona javaagent
- Javaagent – a complex but powerful instrumentation
- Implementing your own configurable monitoring interceptor
- CDI instrumentation
- Instrumenting the code
- Counters gauges timers and more
- Libraries monitor your application
- GlassFish ad hoc monitoring
- Java Mission Control
- How to connect remotely
- JVisualVM – the UI for JVM monitoring
- Memory
- Thread.print
- The jcmd command – the small command line utility that does a lot
- Java tools to know what my application is doing
- Monitor Your Application
- Summary
- Ensure you know your resources
- Ensure you know your application
- Ensure you know the server
- Java EE and performances
- DataSource configuration
- Server resources
- The Java Transaction API
- Model and implications
- From JPA to the database
- JPA – the database link
- @Suspended or asynchronous operation
- Filter and interceptors
- Marshalling
- The router
- JAX-RS – the servlet router
- Dynamic lookups
- Events
- Interceptors/decorators
- Scopes
- Injections
- The main features of CDI
- IoC – a pretty simple example
- Context and Dependency Injection – what did you do to my beans?
- Looking Under the Cover – What is This EE Thing?
- Summary
- Conclusion
- Setting up MySQL
- Get the price the WebSocket way
- Get a quote price the JAX-RS way
- Testing the application
- The application server
- The application design
- The application business
- Application summary
- Provision some data
- The WebSocket layer
- The JAX-RS layer
- The service layer
- The persistence layer
- The build
- Application project highlights
- The application architecture
- Setting up the environment
- Money – The Quote Manager Application
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewer
- About the author
- Contributors
- PacktPub.com
- Why subscribe?
- Packt Upsell
- Dedication
- Title Page
- coverpage
- coverpage
- Title Page
- Dedication
- Packt Upsell
- Why subscribe?
- PacktPub.com
- Contributors
- About the author
- About the reviewer
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- To get the most out of this book
- Download the example code files
- Download the color images
- Conventions used
- Get in touch
- Reviews
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:15:07
