Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
1. Overview
In this tutorial, we’ll look at the differences between the Java JAR (Java ARchive), WAR (Web Application ARchive) and EAR (Enterprise Application aRchive) artifact files.
We’ll discuss what each file format accomplishes and how to use it.
2. Java Artifact File Formats
The Java specification contains multiple types of artifact files. The most prominent are JAR, WAR, and EAR, but there are others as well. Starting with the JAR, each type builds upon the other, respectively.
Although the JAR file format is part of the JavaSE specification, WAR and EAR files are themselves part of JavaEE, now known as JakartaEE.
3. JAR Files
As we know, the JAR file is the basic artifact for Java applications.
Under the hood, it’s essentially a .zip file with the .jar extension. It includes contents such as classes, resources, and meta information files.
We can create JAR files with the jar program and run them using the java -jar command on any system with just the Java Runtime Environment (JRE) .
4. WAR Files
WAR files are used for bundling Java web applications.
They’re also .zip files under the hood and are an extension of the JAR file format.
Along with classes and resources, WAR files can contain other JARs in the form of libraries, JSP files, Java Servlets, as well as all types of static web files (HTML, CSS, Javascript, etc.).
JakartaEE specifies that correctly-formatted WAR files must contain a WEB-INF directory, which itself contains a web.xml file. This is where we declare the structure and configurations of the web application, such as the web paths of each servlet or the session timeout amount.
In contrast to JARs, WAR files cannot be run as standalone applications and we can only use them as components of another application, like a servlet container or an application server.
The process of putting a WAR file into a server is known as application deployment. Typical Application Servers include Tomcat, Jetty and Wildfly.
5. EAR Files
EAR files are used for enterprise applications composed of multiple modules.
There are multiple types of modules, but the most common are web modules, essentially WAR files, and EJB modules which are special types of JAR files that contain Enterprise Java Bean classes.
Similar to WAR, the EAR is a JAR extension and must contain a special XML file, named application.xml, under a root META-INF directory. In this file, we describe the enterprise application and list its modules. Additionally, we can add security roles for the whole app.
Like WAR, an EAR file also cannot be run as a standalone application. We must deploy it on an application server.
However, in this case, not all types are compatible. We must use a server that supports JakartaEE technologies such as Wildfly, but we can’t use Jetty. As for Tomcat, it’s also incompatible, but there’s a different flavor, named TomEE, which is compatible.
The advantage of the EAR format is that it allows us to specify a complex multi-component application in a single file. Additionally, we can avoid duplication by sharing common resources. Finally, the single file format is very helpful because it eliminates deployment errors.
6. Conclusion
In this article, we looked at the differences between WAR and EAR files. We learned the structure of each file and discussed their typical use cases. Finally, we saw how to use each type of artifact.
