Missing Support For `module-name/bean-name` Syntax In `@DependsOn`

Jun 17, 2025 by ADMIN 67 views

Missing Support for Module-Name Bean-Name Syntax in DependsOn

Introduction

In this article, we delve into a critical issue encountered in GlassFish, a popular open-source application server, concerning the @DependsOn annotation within the Jakarta Enterprise Beans (EJB) specification. Specifically, we address the missing support for the module-name/bean-name syntax, which is crucial for defining dependencies between EJBs across different modules within an enterprise application. This article will guide you through the problem, the steps to reproduce it, and the potential impact on application development and deployment. The correct implementation of the @DependsOn annotation is paramount for ensuring proper startup and shutdown sequences within complex EJB applications, where dependencies between beans in different modules are common. In this article, we will explore the issue in detail, providing a comprehensive understanding of the problem and its implications.

Problem Description

The core issue revolves around the GlassFish application server's failure to correctly interpret the module-name/bean-name syntax within the @DependsOn annotation. According to the EJB specification, this syntax should allow developers to specify dependencies on EJBs located in different modules within the same application. However, GlassFish does not recognize this syntax, leading to deployment failures or unexpected behavior. The initial discussion regarding this issue can be found in this email thread, which highlights the expectation that the ejb-link syntax, including module-name/bean-name, should be supported in @DependsOn. This discrepancy between the specification and the implementation in GlassFish creates a significant challenge for developers who rely on this feature for managing EJB dependencies in complex applications. The absence of this support can lead to unpredictable startup sequences and runtime errors, making it essential to address this issue to ensure the reliability and stability of EJB-based applications deployed on GlassFish.

Steps to Reproduce the Issue

To demonstrate the problem, we can follow a series of steps that involve building and deploying a sample application on both GlassFish and OpenLiberty, another popular application server that correctly implements the module-name/bean-name syntax. This comparison will clearly highlight the discrepancy in behavior between the two servers. The following steps outline the process:

1. Build the EARchives

First, we need to clone the repository containing the sample application and build the EAR (Enterprise Archive) files. This involves using Maven, a popular build automation tool, to compile the code and package it into deployable archives.

git clone https://github.com/pzrep/ejb-depends-on-module-name
cd ejb-depends-on-module-name
./mvnw clean package

This command sequence clones the repository, navigates into the project directory, and then executes the Maven build process, which compiles the code, runs tests, and packages the application into EAR files.

2. Start OpenLiberty

Next, we need to set up and start an instance of OpenLiberty. This involves downloading the OpenLiberty distribution, extracting it, and then running the server.

wget https://repo.maven.apache.org/maven2/io/openliberty/openliberty-jakartaee10/25.0.0.6/openliberty-jakartaee10-25.0.0.6.zip
unzip -q openliberty-jakartaee10-25.0.0.6.zip
cd wlp
pwd # LIBERTY_HOME
bin/server run

These commands download the OpenLiberty distribution, unzip it, navigate to the wlp directory, print the current working directory (which will be used as LIBERTY_HOME), and then start the OpenLiberty server in run mode.

3. Start GlassFish

Similarly, we need to set up and start an instance of GlassFish. This involves downloading the GlassFish distribution, extracting it, and then starting the domain.

wget https://repo.maven.apache.org/maven2/org/glassfish/main/distributions/glassfish/7.0.25/glassfish-7.0.25.zip
unzip -q glassfish-7.0.25.zip
cd glassfish7
pwd # GLASSFISH_HOME
glassfish/bin/asadmin start-domain --verbose

These commands download the GlassFish distribution, unzip it, navigate to the glassfish7 directory, print the current working directory (which will be used as GLASSFISH_HOME), and then start the GlassFish domain in verbose mode.

4. Deploy the First EAR

Now, we deploy the first EAR file, ejb-singletons.file-name-ear, to both OpenLiberty and GlassFish. This EAR uses the file name in the @DependsOn annotation.

cp ./ejb-singletons.ears/ejb-singletons.file-name-ear/target/ejb-singletons.file-name-ear-1.0-SNAPSHOT.ear ${LIBERTY_HOME}/usr/servers/defaultServer/dropins
cp ./ejb-singletons.ears/ejb-singletons.file-name-ear/target/ejb-singletons.file-name-ear-1.0-SNAPSHOT.ear ${GLASSFISH_HOME}/glassfish/domains/domain1/autodeploy

These commands copy the EAR file to the respective deployment directories for OpenLiberty and GlassFish, triggering the deployment process.

5. Check the Output

Once deployed, we check the output by making HTTP requests to the deployed application on both servers.

# OpenLiberty:
curl http://localhost:9080/fn/inspector
# GlassFish:
curl http://localhost:8080/fn/inspector

We expect the output to be the same on both servers, indicating that the application has deployed successfully and is functioning correctly.

6. Deploy the Second EAR

Next, we deploy the second EAR file, ejb-singletons.module-name-ear, which uses the module-name/bean-name syntax in the @DependsOn annotation. This is where the difference in behavior between OpenLiberty and GlassFish becomes apparent.

cp ./ejb-singletons.ears/ejb-singletons.module-name-ear/target/ejb-singletons.module-name-ear-1.0-SNAPSHOT.ear ${LIBERTY_HOME}/usr/servers/defaultServer/dropins
cp ./ejb-singletons.ears/ejb-singletons.module-name-ear/target/ejb-singletons.module-name-ear-1.0-SNAPSHOT.ear ${GLASSFISH_HOME}/glassfish/domains/domain1/autodeploy

These commands copy the second EAR file to the deployment directories. However, GlassFish is expected to reject this archive due to the unsupported syntax in the @DependsOn annotation.

7. Check the Output Again

We check the output again, but this time, we only check OpenLiberty since GlassFish rejected the archive.

# OpenLiberty:
curl http://localhost:9080/mn/inspector

This request to OpenLiberty should return the expected output, confirming that OpenLiberty correctly handles the module-name/bean-name syntax.

8. Analyze the Differences

To understand the issue better, we can analyze the differences between the two EAR files. The key differences lie in the pom.xml file and the @DependsOn annotation.

a. pom.xml Differences

The pom.xml files differ in the artifactId and the dependency on the EJB module.

--- a/ejb-singletons.ears/ejb-singletons.file-name-ear/pom.xml
+++ b/ejb-singletons.ears/ejb-singletons.module-name-ear/pom.xml
@@ -8,7 +8,7 @@
         <version>1.0-SNAPSHOT</version>
     </parent>

<artifactId>ejb-singletons.file-name-ear</artifactId>



<artifactId>ejb-singletons.module-name-ear</artifactId>
<packaging>ear</packaging>
<dependencies>
@@ -23,7 +23,7 @@
</dependency>
<dependency>
<groupId>pzrep.ejb-depends-on-module-name</groupId>




       &lt;artifactId&gt;ejb-singletons.ejb-file-name&lt;/artifactId&gt;





       &lt;artifactId&gt;ejb-singletons.ejb-module-name&lt;/artifactId&gt;
       &lt;type&gt;ejb&lt;/type&gt;
   &lt;/dependency&gt;
   &lt;dependency&gt;



@@ -42,7 +42,7 @@
<webModule>
<groupId>pzrep.ejb-depends-on-module-name</groupId>
<artifactId>ejb-singletons.war</artifactId>


                       &lt;contextRoot&gt;/fn&lt;/contextRoot&gt;





                       &lt;contextRoot&gt;/mn&lt;/contextRoot&gt;
                   &lt;/webModule&gt;
               &lt;/modules&gt;
           &lt;/configuration&gt;

This diff shows that the artifactId has been changed from ejb-singletons.file-name-ear to ejb-singletons.module-name-ear, and the dependency has been updated to ejb-singletons.ejb-module-name. The context root has also been changed from /fn to /mn.

b. @DependsOn Differences

The crucial difference lies in the way the @DependsOn annotation is expressed.

--- a/ejb-singletons.ejbs/ejb-singletons.ejb-file-name/src/main/java/pzrep/ejblinksyntax/efn/Choco.java
+++ b/ejb-singletons.ejbs/ejb-singletons.ejb-module-name/src/main/java/pzrep/ejblinksyntax/ebn/Choco.java
@@ -1,4 +1,4 @@
-package pzrep.ejblinksyntax.efn;
+package pzrep.ejblinksyntax.ebn;
import jakarta.ejb.DependsOn;
import jakarta.ejb.Singleton;
@@ -8,11 +8,11 @@
@Singleton
@Startup
@DependsOn({


   &quot;pzrep.ejb-depends-on-module-name-ejb-singletons.ejb-base-1.0-SNAPSHOT.jar#Ant&quot;





   &quot;Base/Ant&quot;



})
public class Choco implements Cat {
@Override
public String color() {


   return &quot;brown (file-name#)&quot;;





   return &quot;brown (module-name/)&quot;;

}
}

This diff clearly shows that the @DependsOn annotation in Choco.java uses the module-name/bean-name syntax ("Base/Ant") in the ejb-singletons.ejb-module-name project, while the ejb-singletons.ejb-file-name project uses a different syntax ("pzrep.ejb-depends-on-module-name-ejb-singletons.ejb-base-1.0-SNAPSHOT.jar#Ant").

Impact of the Issue

The lack of support for the module-name/bean-name syntax in @DependsOn within GlassFish has significant implications for developers and the applications they build. This issue directly violates the EJB specification, which mandates the support for this syntax. The inability to specify dependencies using module names and bean names hinders the development of modular and maintainable applications. When developers cannot rely on the standard syntax for defining dependencies, they are forced to resort to workarounds or alternative approaches that may be less efficient or more error-prone. This can lead to increased complexity in application design and deployment, making it harder to manage dependencies and ensure proper startup and shutdown sequences. The correct management of these sequences is critical for the stability and reliability of the application, especially in enterprise environments where applications often consist of multiple modules with complex interdependencies. The failure to adhere to the EJB specification not only creates technical challenges but also undermines the portability of applications across different application servers. Applications developed with the expectation of the standard syntax being supported may fail to deploy or function correctly on GlassFish, requiring significant rework and testing. This lack of portability can increase the cost and effort associated with application development and maintenance, as developers must account for the specific limitations of the target application server.

Conclusion

The missing support for the module-name/bean-name syntax in @DependsOn within GlassFish is a critical issue that violates the EJB specification and impacts application development and deployment. The steps to reproduce the issue clearly demonstrate the discrepancy in behavior between GlassFish and OpenLiberty. This lack of support hinders the development of modular applications and increases complexity. It is essential for GlassFish to address this issue to ensure compliance with the EJB specification and provide developers with the necessary tools for building robust and maintainable enterprise applications. By adhering to the standards, GlassFish can enhance its appeal to developers and organizations that rely on the EJB specification for building and deploying enterprise applications. Addressing this issue will not only improve the functionality of GlassFish but also contribute to the overall health and vibrancy of the Java EE ecosystem.