Hands-On Software Architecture with Java

Hands-On Software Architecture with Java

Despite being a technology born in 1995, Java is still alive and well.

Every now and then, an article pops up saying that Java is old and should be dismissed and replaced by other languages. But the reality is, Java is here to stay.

There are many reasons for that, but the most important is that it just works: it solves common issues in the software development world so well.

Java technology is the main topic of this book. However, in each of the chapters, we will have the opportunity to talk about many different ideas, and I think that most of them go beyond the Java programming language and are likely to be useful in other situations too.

Indeed, in this book, I’ve tried to distill concepts around many aspects of software development, particularly development in the enterprise world, in big and complex businesses and projects. The goal is to give you insights by focusing on the most important topics. Of course, given the breadth and complexity of the topics, it would be impossible to take a deep dive into every aspect. But you will be provided with some good starting points, and you can easily find more resources if you want further details.

Following more or less the timeline of a typical software project, we will start with the fundamentals of software architecture, from requirement gathering to modeling architecture basics. We will also look at the most common development models, including, of course, DevOps.

In the second section of the book, we will explore some common software architecture patterns. This will include Java architecture patterns, as well as middlewares (both for traditional and cloud-native approaches) and other essential parts of software architecture, such as integration, user interfaces, and data stores.

In the third and final section of the book, we will cover some additional topics, including cross-cutting concerns (such as security, monitoring, and tracing) as well as some considerations around software life cycle management. Finally, we will have a quick look at the latest version of the Java technology.

Who this book is for

This book is for Java software engineers who want to become software architects and learn the basic concepts that a modern software architect needs to know. The book is also for software architects, technical leaders, engineering managers, vice presidents of software engineering, and CTOs looking to extend their knowledge and stay up to date with the latest developments in the field of software architecture.

No previous knowledge is required, and even if you are already familiar with the Java language and the basic concepts of software development, you will still benefit from this book’s recap of the different architecture-related topics.

What this book covers

Chapter 1, Designing Software Architectures in Java – Methods and Styles, introduces the approach toward the examples that we will take throughout this book. We will introduce a number of different scenarios and some real-world examples, in order to clarify abstract concepts and shift our point of view toward implementation.

Chapter 2, Software Requirements – Collecting, Documenting, Managing, explains some techniques for requirement gathering and some tools to document and track them.

Chapter 3, Common Architecture Design Techniques, covers the most commonly used architecture definition formats and the goals they aim to achieve. We will look at an example application, described using different architecture diagrams. Moreover, we will walk through some examples of modeling use cases using BPMN and a business rule using DMN.

Chapter 4, Best Practices for Design and Development, is where we will have a look at the different methods that can be used to help us with both our understanding of the overall solution and the implementation of it.

Chapter 5, Exploring the Most Common Development Models, is where we will have an overview of the most common software development models and their implications, including more traditional and historical ones (such as waterfall) as well as more modern approaches such as agile and DevOps.

Chapter 6, Exploring Essential Java Architectural Patterns, looks at architectural patterns. There are some architecture patterns that are so common that they have become more or less standard. While sometimes being overused, these architectures must be considered as basic building blocks that we need to know about in order to solve common architectural problems.

Chapter 7, Exploring Middleware and Frameworks, is where we will see how to use middleware and frameworks, understanding their role in designing and building our architecture.

Chapter 8, Designing Application Integration and Business Automation, is where, as a follow-up to the previous chapter, we will see two typical middleware implementations. Indeed, application integration and business automation are two commonly used middleware functions, used to build efficient and reusable enterprise architectures.

Chapter 9, Designing Cloud-Native Architectures, is where we will have a look at what a cloud-native application is, what the recommended practices are, and how to enhance existing applications to better suit a cloud-enabled world.

Chapter 10, Implementing User Interaction, is where we will detail the omnichannel approach by having a look at the different entry points for customer interaction.

Chapter 11, Dealing with Data, is where we will have a look at the different kinds of data persistence and how and when to mix them together.

Chapter 12, Cross-Cutting Concerns, is where we will summarize the most important cross-cutting topics to be taken into account, including identity management, security, and resilience.

Chapter 13, Exploring Software Life Cycle, will discuss all the ancillary concepts of software development projects, such as source code management, testing, and releasing. This will include some interesting concepts, such as Continuous Integration and Continuous Delivery/Deployment (also known as CI/CD).

Chapter 14, Monitoring and Tracing Techniques, will explore concepts related to the visibility and maintenance of applications running in production. This includes things such as log management, metric collection, and application performance management.

Chapter 15, What’s New in Java?, will focus on the latest Java release (17) as well as a bit of the history of the language (including versioning schemes) and the ecosystem of Java vendors.


  • 关于本书的内容介绍、目录、详情等请在 AmazonGoolge Books 等售书网站搜索查看,本站仅展示封面作为参考。
  • 如无特殊说明,本站提供的所有pdf均为文字版(aka True PDF or Digitally Created PDF)。
  • 本站已经列出的所有图书均可以找到。
  • 收到PDF链接之后建议尽快下载或者保存到自己的百度网盘,防止链接过期失效。


扫描下方二维码添加微信号 bookyage 回复本书编号 1003356 即可,我们会尽快(一般24小时之内)将本书PDF文件以百度网盘链接的形式发送给您。