Wildfly – Are static variables shared between EARs?

Welcome to the world of Wildfly, where the thrill of Java-based applications meets the excitement of deployment and configuration! As a developer, you’re probably no stranger to the concept of Enterprise Archive (EAR) files, which bundle multiple Java EE modules into a single archive. But have you ever wondered: do static variables get shared between EARs? In this article, we’ll dive into the depths of Wildfly’s architecture and explore the answer to this burning question.

What are static variables, anyway?

Before we dive into the main event, let’s take a quick detour to discuss static variables. In Java, a static variable is a variable that belongs to a class, rather than an instance of the class. This means that all instances of the class share the same static variable. Sounds simple, right?

public class MyClass {
    public static String MY_STATIC_VAR = "I'm a static variable!";
    
    public void doSomething() {
        System.out.println(MY_STATIC_VAR);
    }
}

In this example, `MY_STATIC_VAR` is a static variable that belongs to the `MyClass` class. Any instance of `MyClass` can access and modify `MY_STATIC_VAR`, and the changes will be reflected across all instances.

How do EARs fit into the picture?

Now that we’ve got a handle on static variables, let’s talk about EARs. An EAR (Enterprise Archive) file is a JAR file that contains multiple Java EE modules, such as EJBs, WARs, and JARs. EARs provide a convenient way to package and deploy multiple modules as a single unit.

EJB (Enterprise Java Bean)	WAR (Web Archive)	JAR (Java Archive)
Contains business logic and encapsulates data	Contains web-related components, such as servlets and JSPs	Contains utility classes and libraries

In a Wildfly environment, you can deploy multiple EARs, each containing its own set of modules. But what happens when we throw static variables into the mix?

Are static variables shared between EARs?

Finally, the moment of truth! The short answer is: no, static variables are not shared between EARs. But why not?

It all comes down to the way Wildfly handles class loading and module isolation. When you deploy an EAR, Wildfly creates a separate class loader for each module within the EAR. This means that each module has its own isolated class space, where classes and static variables are loaded independently.

EAR1
    |
    |-- ModuleA.jar
    |    |-- MyClass.class
    |    |-- MY_STATIC_VAR = "I'm in EAR1!"
    |
    |-- ModuleB.war
         |-- AnotherClass.class
         |-- ANOTHER_STATIC_VAR = "I'm in EAR1 too!"

EAR2
    |
    |-- ModuleC.jar
    |    |-- MyClass.class
    |    |-- MY_STATIC_VAR = "I'm in EAR2!"
    |
    |-- ModuleD.war
         |-- AnotherClass.class
         |-- ANOTHER_STATIC_VAR = "I'm in EAR2 too!"

In this example, `MY_STATIC_VAR` and `ANOTHER_STATIC_VAR` are static variables defined in different modules within different EARs. Since each EAR has its own class loader, the static variables are loaded independently and are not shared between EARs.

But what about singleton classes?

A Singleton class is a class that ensures only one instance of itself is created. Singleton classes often use static variables to store their instance. But what happens when we deploy Singleton classes across multiple EARs?

public class SingletonClass {
    private static SingletonClass instance;
    private static String MY_STATIC_VAR = "I'm a singleton!";

    private SingletonClass() {}

    public static SingletonClass getInstance() {
        if (instance == null) {
            instance = new SingletonClass();
        }
        return instance;
    }

    public String getStaticVar() {
        return MY_STATIC_VAR;
    }
}

In this case, even though SingletonClass is a Singleton, the static variable `MY_STATIC_VAR` is still not shared between EARs. Each EAR will have its own instance of SingletonClass, with its own copy of `MY_STATIC_VAR`.

What about synchronized static variables?

Synchronized static variables are a special case. When you synchronize a static variable, you’re ensuring that only one thread can access the variable at a time. But what about across multiple EARs?

public class MyClass {
    public static synchronized String MY_STATIC_VAR = "I'm synchronized!";
    
    public void doSomething() {
        synchronized (MY_STATIC_VAR) {
            System.out.println(MY_STATIC_VAR);
        }
    }
}

Even with synchronization, the static variable `MY_STATIC_VAR` is still not shared between EARs. Each EAR will have its own copy of `MY_STATIC_VAR`, and synchronization only applies within the same EAR.

Conclusion

There you have it! Static variables are not shared between EARs in a Wildfly environment. Each EAR has its own isolated class space, where classes and static variables are loaded independently. This ensures that each EAR is self-contained and doesn’t interfere with other EARs.

Remember, when working with Wildfly and EARs, it’s essential to understand the nuances of class loading and module isolation. By doing so, you’ll be able to design and deploy your applications with confidence, knowing that static variables are safely contained within their respective EARs.

Got any questions or concerns? Feel free to drop them in the comments below!

1. Wildfly – Class Loading
2. Java – Singleton Classes
3. Java – Synchronization

Happy coding, and see you in the next article!

Frequently Asked Question

Wildfly, the popular open-source application server, has many intricacies when it comes to EAR deployments. One such aspect is the sharing of static variables between EARs. Let’s dive into some FAQs to clarify this topic!