Architecting modern java EE applications designing lightweight, business-oriented enterprise applications in the age of cloud, containers, and Java EE 8
Find out how to craft effective, business-oriented Java EE 8 applications that target customer's demands in the age of Cloud platforms and container technology. About This Book Understand the principles of modern Java EE and how to realize effective architectures Gain knowledge of how to design...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, England ; Mumbai, [India] :
Packt
2017.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630727806719 |
Tabla de Contenidos:
- Cover
- Copyright
- Credits
- Foreword
- About the Author
- Acknowledgments
- About the Reviewer
- www.PacktPub.com
- Customer Feedback
- Dedication
- Table of Contents
- Preface
- Chapter 1: Introduction
- New demands in enterprise systems
- Modern way of realizing enterprise systems
- Relevance of Java EE in modern systems
- Java EE 8 update and roadmap
- Java Community Process
- What to expect in the book
- Chapter 2: Designing and Structuring Java Enterprise Applications
- The purpose of enterprise applications
- What developers should focus on
- Meeting customer's demands
- Outer enterprise project structure
- Business and team structures
- Software projects contents
- Application source code
- Software structures
- Version control systems
- Binaries
- Build systems
- Single versus multi-module projects
- Illusion of reusability
- Technical dependencies
- Organizational challenges
- Reusability considerations
- Project artifacts
- One project per artifact
- Build systems for Java EE
- Apache Maven
- Gradle
- Structuring for modern frontend technologies
- Enter JavaScript frameworks
- Organizing modern frontends
- Enterprise project code structure
- Situation in enterprise projects
- Horizontal versus vertical layering
- Business-driven structure
- Designing reasonable modules
- Realizing package structures
- Package contents
- Horizontal package layering
- Flat module package
- Entity Control Boundary
- Packages
- Package access
- Don't over-enforce architecture
- Summary
- Chapter 3: Implementing Modern Java Enterprise Applications
- Use case boundaries
- Core domain components of modern Java EE
- EJB and CDI - differentiation and integration
- CDI producers
- Emitting domain events
- Scopes
- Patterns in Java EE
- Design patterns revisited
- Singleton
- Abstract factory.
- Factory method
- Object pool
- Decorator
- Facade
- Proxy
- Observer
- Strategy
- Further patterns
- Domain-Driven Design
- Services
- Entities
- Value objects
- Aggregates
- Repositories
- Factories
- Domain event
- External and cross-cutting concerns in enterprise applications
- Communication with external systems
- How to choose communication technology
- Synchronous HTTP communication
- Representational State Transfer
- Java API for RESTful web services
- Mapping HTTP content types
- Validating requests
- Mapping errors
- Accessing external systems
- Stability when consuming HTTP
- Accessing Hypermedia REST services
- Asynchronous communication and messaging
- Asynchronous HTTP communication
- Message-oriented communication
- Server-sent events
- WebSocket
- Connecting enterprise technology
- Database systems
- Integrating RDBMS systems
- Mapping domain models
- Integrating database systems
- Transactions
- Relational databases versus NoSQL
- Cross-cutting concerns
- Configuring applications
- Caching
- Flow of execution
- Synchronous execution
- Asynchronous execution
- Asynchronous EJB methods
- Managed Executor Service
- Asynchronous CDI events
- Scopes in asynchronicity
- Timed execution
- Asynchronous and reactive JAX-RS
- Concepts and design principles of modern Java EE
- Preserving maintainable code with high quality
- Summary
- Chapter 4: Lightweight Java EE
- Lightweight enterprise technology
- Why Java EE standards?
- Convention over configuration
- Dependency management of Java EE projects
- Lightweight way of packaging applications
- Java EE application servers
- One application per application server
- Summary
- Chapter 5: Container and Cloud Environments with Java EE
- Motivations and goals
- Infrastructure as code
- Stability and production readiness
- Containers.
- Java EE in the container
- Container orchestration frameworks
- Realizing container orchestration
- Java EE in orchestrated containers
- Connecting external services
- Configuring orchestrated applications
- 12-factor applications and Java EE
- Have one codebase tracked in revision control, many deploys
- Explicitly declare and isolate dependencies
- Store config in the environment
- Treat backing services as attached resources
- Strictly separate build and run stages
- Execute the app as one or more stateless processes
- Export services via port binding
- Scale out via the process model
- Maximize robustness with fast startup and graceful shutdown
- Keep development, staging, and production as similar as possible
- Treat logs as event streams
- Run admin/management tasks as one-off processes
- Cloud, Cloud native, and their benefits
- Cloud native
- Summary
- Chapter 6: Application Development Workflows
- Motivation and goals of productive development workflows
- Realizing development workflows
- Version control everything
- Building binaries
- Java artifacts
- Artifact versions
- Building containers
- Quality assurance
- Deployment
- Configuration
- Credentials
- Data migration
- Adding database structures
- Changing database structures
- Removing database structures
- Implementing migration
- Testing
- Build metadata
- Going to production
- Branching models
- Technology
- Pipeline-as-code
- Workflows with Java EE
- Continuous Delivery culture and team habits
- Responsibility
- Check in early and often
- Immediately fixing issues
- Visibility
- Improve continuously
- Summary
- Chapter 7: Testing
- The necessity of tests
- Requirements of well-crafted tests
- Predictability
- Isolation
- Reliability
- Fast execution
- Automation
- Maintainability
- What to test.
- Definition of test scopes
- Unit tests
- Component tests
- Integration tests
- System tests
- Performance tests
- Stress tests
- Implementing tests
- Unit tests
- Implementation
- Technology
- Component tests
- Motivation
- Implementation
- Delegating test components
- Technology
- Integration tests
- Embedded containers
- Embedded databases
- Running integration tests
- Code level integration tests versus system tests
- Shortcomings of integration tests
- Shortcomings of system tests
- Conclusion
- System tests
- Managing test scenarios
- Simulating external concerns
- Designing system tests
- Deploying and controlling external mocks
- Performance tests
- Motivation
- Key performance indicators
- Developing performance tests
- Insights
- Running tests locally
- Maintaining test data and scenarios
- Importance of maintainable tests
- Signs of lack of test quality
- Test code quality
- Test technology support
- Summary
- Chapter 8: Microservices and System Architecture
- Motivations behind distributed systems
- Challenges of distribution
- Communication overhead
- Performance overhead
- Organizational overhead
- How to design systems landscapes
- Context maps and bounded contexts
- Separation of concerns
- Teams
- Project life cycles
- How to design system interfaces
- API considerations
- Interface management
- Change-resilient APIs
- Breaking the business logic
- Hypermedia REST and versioning
- Documenting boundaries
- Consistency versus scalability
- Event sourcing, event-driven architectures, and CQRS
- Shortcomings of CRUD-based systems
- Scalability
- Competing transactions
- Reproducibility
- Event sourcing
- Benefits
- Eventually consistent real world
- Event-driven architectures
- Eventual consistency in event-driven architectures
- Enter CQRS
- Principles
- Design.
- Benefits
- Shortcomings
- Communication
- Microservice architectures
- Sharing data and technology in enterprises
- Shared-nothing architectures
- Interdependent systems
- 12-factor and cloud native applications
- When to use and when not to use microservices
- Implementing microservices with Java EE
- Zero-dependency applications
- Application servers
- Implementing application boundaries
- Implementing CQRS
- System interfaces
- Example scenario using Apache Kafka
- Integrating Java EE
- CDI events
- Event handlers
- State representation
- Consuming Kafka messages
- Producing Kafka messages
- Application boundaries
- Integrating further CQRS concepts
- Java EE in the age of distribution
- Discovering services
- Communicating resiliently
- Validating responses
- Breaking timeouts and circuits
- Bulkheads
- Shaking hands and pushing back
- More on being resilient
- Summary
- Chapter 9: Monitoring, Performance, and Logging
- Business metrics
- Collecting business metrics
- Emitting metrics
- Enter Prometheus
- Realization with Java EE
- Integrating the environment
- Meeting performance requirements in distributed systems
- Service level agreements
- Achieving SLAs in distributed systems
- Tackling performance issues
- Theory of constraints
- Identifying performance regression with jPDM
- Subsystems
- Actors
- Application
- JVM
- Operating system and hardware
- jPDM instances - production situations
- Analyzing the jPDM instances
- Dominating consumer - OS
- Dominating consumer - none
- Dominating consumer - JVM
- Dominating consumer - application
- Conclusion
- Technical metrics
- Types of technical metrics
- High frequency monitoring versus sampling
- Collecting technical metrics
- Boundary metrics
- Logging and tracing
- Shortcomings of traditional logging
- Performance
- Log levels.
- Log format.
