618

What is the difference between a .war and .ear file?

Improve this question
1
  • 14
    Welcome to the Java world where someone thought that leaving a zip file with the .zip extension is not enterprisey enough and so it must be renamed to .jar / .ear or .war based on where you are eventually moving it.
    – pistacchio
    Commented Jul 2, 2019 at 12:32

9 Answers 9

Reset to default
667

A WAR (Web Archive) is a module that gets loaded into a Web container of a Java Application Server. A Java Application Server has two containers (runtime environments) - one is a Web container and the other is a EJB container.

The Web container hosts Web applications based on JSP or the Servlets API - designed specifically for web request handling - so more of a request/response style of distributed computing. A Web container requires the Web module to be packaged as a WAR file - that is a special JAR file with a web.xml file in the WEB-INF folder.

An EJB container hosts Enterprise java beans based on the EJB API designed to provide extended business functionality such as declarative transactions, declarative method level security and multiprotocol support - so more of an RPC style of distributed computing. EJB containers require EJB modules to be packaged as JAR files - these have an ejb-jar.xml file in the META-INF folder.

Enterprise applications may consist of one or more modules that can either be Web modules (packaged as a WAR file), EJB modules (packaged as a JAR file), or both of them. Enterprise applications are packaged as EAR files ― these are special JAR files containing an application.xml file in the META-INF folder.

Basically, EAR files are a superset containing WAR files and JAR files. Java Application Servers allow deployment of standalone web modules in a WAR file, though internally, they create EAR files as a wrapper around WAR files. Standalone web containers such as Tomcat and Jetty do not support EAR files ― these are not full-fledged Application servers. Web applications in these containers are to be deployed as WAR files only.

In application servers, EAR files contain configurations such as application security role mapping, EJB reference mapping and context root URL mapping of web modules.

Apart from Web modules and EJB modules, EAR files can also contain connector modules packaged as RAR files and Client modules packaged as JAR files.

Improve this answer
3
  • 37
    +1 because this answer describes why you might want to use one or the other.
    – Jason Wheeler
    Commented Mar 7, 2014 at 22:58
  • 9
    @KNU yes, .jar, .warand .ear files are simple zip archives, thus able to be opened by any program that can handle ordinary .zip files.
    – acdcjunior
    Commented Jun 12, 2014 at 1:45
  • Is it possible to define a context-root for an ejb module ? why a websocket in an ejb module is not accessible but in a war module is accessible ?!!! Is there any solution?
    – Hosein Aqajani
    Commented Sep 9, 2020 at 6:52
518

From GeekInterview:

In J2EE application, modules are packaged as EAR, JAR, and WAR based on their functionality

JAR: EJB modules which contain enterprise java beans (class files) and EJB deployment descriptor are packed as JAR files with .jar extension

WAR: Web modules which contain Servlet class files, JSP Files, supporting files, GIF and HTML files are packaged as a JAR file with .war (web archive) extension

EAR: All the above files (.jar and .war) are packaged as a JAR file with .ear (enterprise archive) extension and deployed into Application Server.

Improve this answer
3
  • 66
    This posts makes me think that EAR is just both JARS and WARS together in a big EAR, which I think is not that simple.
    – Lay González
    Commented Feb 16, 2014 at 2:13
  • 4
    All in essence are Archive(JAR) but with different extension to imply their nature/content.
    – KNU
    Commented Jun 5, 2014 at 16:39
  • 1
    EARs and separate JARs for beans are unnecessary in most cases. A simple WAR with all classes in one archive is normal. Here is a more elaborate explanation: adam-bien.com/roller/abien/entry/ears_wars_and_size_matters
    – Kaspars Rinkevics
    Commented Jun 28, 2017 at 7:41
42

war - web archive. It is used to deploy web applications according to the servlet standard. It is a jar file containing a special directory called WEB-INF and several files and directories inside it (web.xml, lib, classes) as well as all the HTML, JSP, images, CSS, JavaScript and other resources of the web application

ear - enterprise archive. It is used to deploy enterprise application containing EJBs, web applications, and 3rd party libraries. It is also a jar file, it has a special directory called APP-INF that contains the application.xml file, and it contains jar and war files.

Improve this answer
2
  • did you mean META-INF instead of APP-INF directory?
    – Zavael
    Commented May 21, 2020 at 9:55
  • Is it possible to define a context-root for an ejb module ? why a websocket in an ejb module is not accessible but in a war module is accessible ?!!! Is there any solution?
    – Hosein Aqajani
    Commented Sep 9, 2020 at 6:54
28

WAR (web archive) files contain servlet class files, JSPs (Java servlet pages), HTML and graphical files, and other supporting files.

EAR (enterprise archive) files contain the WAR files along with the JAR files containing code.

There may be other things in those files but their basically meant for what they sound like they mean: WAR for web-type stuff, EAR for enterprise-type stuff (WARs, code, connectors et al).

Improve this answer
6
  • 2
    In my case i always deploy WAR with jars in WEB-INF/lib folder and that works. So why should i use EAR archive?
    – swapyonubuntu
    Commented Feb 21, 2015 at 6:36
  • 2
    @swapyonubuntu, if you're just deploying a single web application (more specifically, a single servlet context), there's nothing wrong with just doing WAR files. EAR files are way better for full blown enterprise apps, including those with many web apps.
    – paxdiablo
    Commented Feb 21, 2015 at 9:27
  • 2
    In this era of microservices, wouldn't it make more sense to keep each WAR completely separate and deploy separately instead of bundling them together into a monolithic EAR?
    – Sayo Oladeji
    Commented Nov 9, 2015 at 18:02
  • Is it possible to define a context-root for an ejb module ? why a websocket in an ejb module is not accessible but in a war module is accessible ?!!! Is there any solution?
    – Hosein Aqajani
    Commented Sep 9, 2020 at 6:54
  • 1
    @HoseinAqajani: why are you asking a question in a comment box of a decade-old answer? It should be asked as a new question so you'll get more responses than just from me (who, incidentally, hasn't done any Java stuff for about five years)
    – paxdiablo
    Commented Sep 9, 2020 at 7:55
25

JAR Files

A JAR (short for Java Archive) file permits the combination of several files into a single one. Files with the '.jar'; extension are utilized by software developers to distribute Java classes and various metadata. These also hold libraries and resource files, as well as accessory files (such as property files).

Users can extract and create JAR files with Java Development Kit's (JDK) '.jar' command. ZIP tools may also be used.

JAR files have optional manifest files. Entries within the manifest file prescribe the JAR file's use. A 'main' class specification for a file class denotes the file as a detached or ‘stand-alone' program.

WAR Files

A WAR (or Web Application archive) files can comprise XML (extensible Markup Language) files, Java classes, as well as Java Server pages for purposes of Internet application. It is also employed to mark libraries and Web pages which make up a Web application. Files with the ‘.war' extension contain the Web app for use with server or JSP (Java Server Page) containers. It has JSP, HTML (Hypertext Markup Language), JavaScript, and various files for creating the aforementioned Web apps.

A WAR file is structured as such to allow for special directories and files. It may also have a digital signature (much like that of a JAR file) to show the veracity of the code.

EAR Files

An EAR (Enterprise Archive) file merges JAR and WAR files into a single archive. These files with the ‘.ear' extension have a directory for metadata. The modules are packaged into on archive for smooth and simultaneous operation of the different modules within an app server.

The EAR file also has deployment descriptors (which are XML files) which effectively dictate the deployment of the different modules.

enter image description here

Improve this answer
2
  • 2
    should be top answer just for the excellent graphic, thank you, great help!
    – fl0w
    Commented Jun 13, 2018 at 11:29
  • Is it possible to define a context-root for an ejb module ? why a websocket in an ejb module is not accessible but in a war module is accessible ?!!! Is there any solution?
    – Hosein Aqajani
    Commented Sep 9, 2020 at 6:54
12

Refer: http://www.wellho.net/mouth/754_tar-jar-war-ear-sar-files.html

tar (tape archives) - Format used is file written in serial units of fileName, fileSize, fileData - no compression. can be huge

Jar (java archive) - compression techniques used - generally contains java information like class/java files. But can contain any files and directory structure

war (web application archives) - similar like jar files only have specific directory structure as per JSP/Servlet spec for deployment purposes

ear (enterprise archives) - similar like jar files. have directory structure following J2EE requirements so that it can be deployed on J2EE application servers. - can contain multiple JAR and WAR files

Improve this answer
7

Ear files provide more options to configure the interaction with the application server.

For example: if the hibernate version of the application server is older than the one provided by your dependencies, you can add the following to ear-deployer-jboss-beans.xml for JBOSS to isolate classloaders and avoid conflicts:

<bean name="EARClassLoaderDeployer" class="org.jboss.deployment.EarClassLoaderDeployer">    
  <property name="isolated">true</property>
</bean>

or to src/main/application/META-INF/jboss-app.xml :

<?xml version="1.0"?>
<jboss-app>
<loader-repository>
    loader=nameofyourear.ear
<loader-repository-config>java2ParentDelegation=false</loader-repository-config>
</loader-repository>
</jboss-app>

This will make sure that there is no classloader conflict between your application and the application server.

Normally the classloader mechanism works like this:

When a class loading request is presented to a class loader, it first asks its parent class loader to fulfill the request. The parent, in turn, asks its parent for the class until the request reaches the top of the hierarchy. If the class loader at the top of the hierarchy cannot fulfill the request, then the child class loader that called it is responsible for loading the class.

By isolating the classloaders, your ear classloader will not look in the parent (=JBoss / other AS classloader). As far is I know, this is not possible with war files.

Improve this answer
3
  • KNU: This use of an ear file is more valid than just using it because " it contains Servlet class files,JSP FIles,supporting files, GIF and HTML files " as stated in the accepted answer. As war files can also contain gif, html, jsp's, servlets,... If everyone "answered at his strenght", maybe we all could become wiser on the issue at hand.
    – Mark
    Commented Jun 6, 2014 at 13:23
  • Maven does that for you no? You can specify dependencies per version and they get included in the /lib folder. (in a war file)
    – Sebas
    Commented Jan 9, 2015 at 17:00
  • Yeah, but the application server / servlet container can choose to override these in the lib folder with the libs he provides in his own lib folder. This can prevent that. It all depends on the used classloading mechanism.
    – Mark
    Commented Jan 12, 2015 at 8:53
7

J2EE defines three types of archives:

  1. Java Archives (JAR) A JAR file encapsulates one or more Java classes, a manifest, and a descriptor. JAR files are the lowest level of archive. JAR files are used in J2EE for packaging EJBs and client-side Java Applications.

  2. Web Archives (WAR) WAR files are similar to JAR files, except that they are specifically for web applications made from Servlets, JSPs, and supporting classes.

  3. Enterprise Archives (EAR) ”An EAR file contains all of the components that make up a particular J2EE application.

Improve this answer
1

To make the project transport, deployment made easy. need to compressed into one file. JAR (java archive) group of .class files

WAR (web archive) - each war represents one web application - use only web related technologies like servlet, jsps can be used. - can run on Tomcat server - web app developed by web related technologies only jsp servlet html js - info representation only no transactions.

EAR (enterprise archive) - each ear represents one enterprise application - we can use anything from j2ee like ejb, jms can happily be used. - can run on Glassfish like server not on Tomcat server. - enterprise app devloped by any technology anything from j2ee like all web app plus ejbs jms etc. - does transactions with info representation. eg. Bank app, Telecom app

Improve this answer

Not the answer you're looking for? Browse other questions tagged or ask your own question.