When we create enterprise software, we need to make sure it can handle massive scale, system failures, security concerns, and more.

But if we have to design these services manually, it will slow down development.

We want to get enterprise functionality and still build our application quickly.

And to do that, we need to use EJBs (Enterprise Java Beans).


Why do we use EJBs?

EJBs help us build enterprise applications quickly. They automatically take care of lower level details like:

  1. Load-balancing & Failover
  2. Transaction Management & Persistence
  3. Security

EJBs are special java components that run inside a container. And this container handles the services mentioned above.

How do we use EJBs?

What You’ll Need

Create an EJB Project

We’ll create a project that calls an EJB from a servlet.
  1. Add a Maven Repository.
    • Go to JBoss Developer Studio (or Window) -> Preferences
    • Type jboss maven integration -> Click Configure Maven Repositories
      Screen Shot 2017-02-22 at 10.07.53 AM.png
    • Click Add Repository and fill in the following

      Profile ID: jboss-ga-repository
      ID: jboss-ga-repository
      Name: jboss-ga-repository
      URL: http://maven.repository.redhat.com/techpreview/all
      Active by default: Enabled
  2. Add Maven dependencies
    • In the Dependencies tab of your pom.xml, click Add
    • Add jboss-ejb-api_3.1_spec & jboss-servlet-api_3.0_spec
  3. Change maven packaging and properties
    • In your pom.xml, change the packaging to WAR.
    • Update the maven-war-plugin. Add this before the </project> tag
  4. Update Maven
    Screen Shot 2017-02-21 at 9.32.39 AM.png
  5. Create a Stateless EJB
    • Create a new class called MyEJB
    • Add @Stateless annotation
      public class MyEJB
    • Add a helloWorld method
      public String helloWorld(String name) {
          return "Hello " + name;
  6. Create a Servlet
    • Create a class called SimpleServlet that extends HttpServlet
    • Add @WebServlet annotation
      public class SimpleServlet extends HttpServlet
    • Declare an EJB and add a doGet method that calls it
      MyEJB ejb;
      public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException{
          PrintWriter out = response.getWriter();
          out.println("<h1>" + ejb.helloWorld("yourname") + "</h1>");
  7. Add JBoss Web descriptor
    • In the /src/main/webapp/WEB-INF directory, create a file called jboss-web.xml
      <?xml version="1.0" encoding="UTF-8"?> 
  8. Run on serverScreen Shot 2017-02-22 at 3.32.35 PM.pngscreen-shot-2017-02-14-at-12-26-24-pm
  9. You should see a successful EJB and web deployment in the Console
    Registered web context: /simple-ejb-project
  10. Point your browser to

    Hello World!

Let’s review what we just did..

Maven (Steps 1-4)

  • We added the necessary APIs for EJBs and servlets.
  • We changed the packaging to WAR (Web ARtifact) since we’re making a web application
  • Servlet applications (before version 3.0) must have a web.xml file. We updated our version to 3.0 so we can skip that file. Otherwise you’ll see this error:
web.xml is missing and is set to true

 Stateless EJB (5)

  • We created an EJB using the @Stateless annotation
  • Stateless EJBs have no instance variables.

Servlet (6)

  • We created a servlet, a java class that responds to an HTTP request
  • We mapped our servlet to a path (/SimpleEJB) with the @WebServlet annotation
  • We declared our EJB using the @EJB annotation and called helloWorld()

Note: Since the container handles instantiation of our EJB, we don’t need to use the new keyword

JBoss Web Descriptor (7)

We changed the context root so we can access our servlet here:


instead of the default


What’s a best practice for using EJBs?

It’s a good practice to separate business logic (EJBs) from view logic (Servlets etc). This makes it easy to reuse business logic in other parts of your application.

But for small projects like this one, sometimes that is unnecessary.


  1. EJBs help us build enterprise applications quickly because they automatically handle massive scale, failure recovery, security, and more.
  2. We use annotations to define and declare EJBs
  3. Separate your business (EJB) and view logic (Servlet) for easy code re-use

Source Code & Useful Links

  1. Project Source Code
  2. A full history of  EJBs
  3. The difference between a JAR, WAR, EAR

Next time we’ll look at other ways to invoke EJBs

Happy Coding,


Proudly powered by WordPress | Theme: Baskerville 2 by Anders Noren.

Up ↑