Servlet container and application servers in Java

Servlet container is a server program that provides system support for servlets and ensures their life cycle in accordance with the rules defined in the specifications. It can act as a full-fledged stand-alone web server, provide pages for another web server, or integrate into a Java EE application server.

The servlet container provides data exchange between the servlet and clients, takes on such functions as creating a software environment for a functioning servlet, identifying and authorizing clients, organizing a session for each of them.

The most famous implementations of servlet containers are:

  • Apache Tomcat
  • Jetty
  • JBoss
  • WildFly
  • GlassFish
  • IBM WebSphere
  • Oracle Weblogic

Why do you need application servers when there are servlet containers?

  • Database connection pools
    • The ability to periodically test the availability of the DBMS and update the connection in the event of failure recovery
    • Replacing access rights when connecting
    • Load balancing between several DBMS, determining the availability or inaccessibility of a particular node
    • Protection of the connection pool from incorrect code in the application, which inadvertently does not return connections, just picking it up after some timeout.
  • JMS
    • Out-of-the-box availability of a message queue server.
    • The ability to cluster queues, i.e. availability of building distributed queues located on several servers at once, which significantly increases the scalability and availability of the application.
    • Ability to migrate queues - if one of the servers crashes, its queues are automatically moved to another, saving unprocessed messages.
    • Some application servers maintain a Unit-of-Order — a guaranteed order in which messages are processed that meet certain criteria.
  • JTA Built-in support for distributed transactions to ensure consistency of data across different DBMS or queues.
  • Safety
    • Multiple security and authentication providers:
      • in an embedded or external LDAP server
      • in the database
      • in various Internet-directory (specialized applications for managing access rights)
    • Availability of Single-Sign-On (the ability to split the user session between applications) through Security Assertion Markup Language (SAML) 1/2 or Simple and Protected Negotiate (SPNEGO) and Kerberos: one of the servers acts as a base for storing users, all other servers when authenticating a user, they refer to this database.
    • The ability to authorize using the eXtensible Access Control Markup Language (XACML) protocol, which allows you to describe rather complex policies (for example, the application is available to the user only during business hours).
    • Clustering all of the above
  • Scalability and High Availability Clustering is usually also possible for a servlet container, but it will be rather primitive as it has the following limitations:
    • The complexity of transferring a user session from one data center (DC) to another via the Internet
    • Inability to effectively configure session replication on a large (consisting of 40-50 server instances) cluster
    • Inability to ensure migration of application instances to another server
    • Unavailability of mechanisms for automatic monitoring and response to errors
  • Controllability
    • The presence of a single control center, the so-called AdminServer and NodeManager analog, which provides
      • Ability to run multiple server instances simultaneously
      • Viewing the status of running server instances, handlers of a particular queue, on a particular server, the number of connections to a particular database
  • Administrative Channel and Production Mode Deployment. Some application servers allow you to enable a so-called "administrative channel", a separate port on which requests have priority.
    • Viewing the status (running transactions, threads, queues) in case of server unavailability ("hangup")
    • Updating applications on the fly, no downtime:
      • adding a new version of the application to the server in a "closed" mode while users continue to work with the previous one
      • testing the correctness of the deployment of the new version
      • "hidden" transfer to use the new version of all users

Read also:


Comments

Post a Comment

Popular posts from this blog

Methods for reading XML in Java

Image
DOM (Document Object Model) - object - reads XML, recreating it in memory in the form of an object structure, while the XML document is represented as a set of tags - nodes. Each node can have an unlimited number of child nodes. Each child can also contain several levels of descendants or none at all. Thus, the result is a kind of tree. Pluses: Easy to program. If there are many objects in XML with cross-references to each other, it is enough to go through the document twice: first time create objects without references and fill in the name-object dictionary, the second time - restore links. If an error occurs in XML, a half-created XML structure remains in memory, which will be automatically destroyed. Suitable for both reading and writing. Minuses: Low speed. Wastes a lot of memory. SAX (Simple API for XML) - event-driven - reads an XML document, responding to emerging events (opening or closing tag, string, attribute) by calling the event handlers provided by the appl...
Read more

XML, well-formed XML and valid XML

Image
XML, the eXtensible Markup Language, is a language with a simple formal syntax, well suited for creating and manipulating documents with programs, and at the same time easy to read and create documents by humans. XML is extensible, it does not fix the markup used in documents, and the developer is free to create markup in accordance with the needs of a particular area, being limited only by the syntax rules of the language. DTD A DTD, Document Type Definition, is a predefined set of rules that defines the relationships between elements and attributes. For example, the DTD for HTML says that the DIV tag must be inside the BODY tag and can appear multiple times, TITLE - in HEAD and only once, and SCRIPT - both there and there as many times as you want. A DTD is usually described directly in the document as a formulation line starting with <!DOCTYPE ... > or in a separate file. Difference between well-formed XML and valid XML Depending on the level of compliance, the document...
Read more

ArrayList and LinkedList in Java, memory usage and speed

Image
How much extra memory is needed when calling ArrayList.add()? If there is enough space in the array to accommodate a new element, then no additional memory is required. Otherwise, a new array is created, 1.5 times larger than the existing one (this is true for JDK above 1.7, in earlier versions the size of the increase is different). How much extra memory is allocated when you call LinkedList.add()? One new instance of the nested Node class is created. How much memory to store one byte primitive in LinkedList? Each LinkedList element stores a link to the previous element, the next element, and a data link. private static class Node<E> { E item; Node<E> next; Node<E> prev; //... } For 32-bit systems, each link is 32 bits (4 bytes). The object (header) of the nested Node class itself takes 8 bytes. 4 + 4 + 4 + 8 = 20 bytes, and since the size of each object in Java is a multiple of 8, so we get 24 bytes. A byte primitive occupies 1 by...
Read more