Resin Architecture

Resin’s Java EE certified architecture is cloud-enabling. You can choose to have Resin power your SaaS application or utilize it as the backbone of your PaaS/IaaS platform. Resin’s lightweight and modular base allows you to position your application in a public, private or hybrid cloud.

icon_21532Complete Solution

Enhance your continuous integration using our complete solution to focus on adding features as fast as possible. Bring tools to the shop that support your application development process whether working with Servlets, JSP’s, EJB’s, or the fastest HTTP server.

icon_6692Data Reliable

Deploy Resin’s caching, enterprise clustering and replication to give you the resiliency you need with your data. Applications running on Resin will have reliability, accuracy, and completeness, while providing the ability to monitor the process for consistency.

Ease of Deployment

Use Resin’s easy setup and configuration to enable new web apps quickly. Speed up your application upgrades by facilitating our integrated framework and management solutions in the cloud. Complete all your processes to numerous machines while your deployment remains live.


Use Resin to scale your architecture seamlessly from one server to thousands in both physical and virtual environments. Benefit from the interaction your clustering and replication to optimize your cloud deployment. Use Resin’s consistent and rock solid method to scale your servers up or down, to add or remove servers, and to match production levels.

icon_6692Versioned Deployment

You have the control to make the upgrade process transparent to both users with existing sessions, moving them to older versions of the same application within the same server so that upgrading requires zero downtime for active sites.

icon_6692Load Balancing

Increase your up-time with a smart software load balancer that understands your toplogy. Optimize resources, maximize throughput, minimize response time and avoid overloading your resources. Make your servers session aware, efficient and persistent.

The Resin Stack

The entire Resin product line’s incredible growth is driven by fast performance, built-in server monitoring capabilities and extreme reliability. Resin’s unsurpassed reliability is a testament of its Health System and Watchdog process. Resin’s Health System provides server monitoring and JVM monitoring and full server recoverability (self healing).


Resin Smart Load Balancer

As traffic increases beyond a single server, Resin’s load-balancing lets you add new machines to handle the load and simultaneously improves uptime and reliability by failing over requests from a downed or maintenance server to a backup transparently.

<resin:LoadBalance> is part of Resin’s rewrite capabilities, Resin’s equivalent of the Apache mod_rewrite module, providing powerful and detailed URL matching and decoding. More sophisticated sites might load-balance based on the virtual host or URL using multiple tags.

Documenation: Smart Load Balancing

Once your traffic increases beyond the capacity of a single application server, your site needs to add a HTTP load balancer as well as the second application server. Your system is now a two tier system: an app-tier with your program and a web-tier for HTTP load-balancing and HTTP proxy caching. Since the load-balancing web-tier is focusing on HTTP and proxy caching, you can usually handle many app-tier servers with a single web-tier load balancer. Although the largest sites will pay for an expensive hardware load balancer, medium and small sites can use Resin’s built-in load-balancer as a cost-effective and efficient way to scale a moderate number of servers, while gaining the performance advantage of Resin’s HTTP proxy caching.


Resin HTTP Proxy Cache

Server caching can speed dynamic pages to near-static speeds. When pages created by database queries only change every 15 minutes, e.g. CNN or Wikipedia or Slashdot, Resin can cache the results and serve them like static pages. Because Resin’s caching only depends on HTTP headers, it will work for any JSPs, servlet or PHP page.response.

Resin’s caching operates like a proxy cache, looking at HTTP headers to compare hash codes or digests or simply caching for a static amount of time. Since the proxy cache follows the HTTP standards, applications like Mediawiki will automatically see dramatic performance improvement with no extra work. You can even cache REST-style GET requests.

Documentation: Proxy Cache

Because the cache supports advanced headers like “Vary”, it can cache different versions of the page depending on the browser’s capabilities. Gzip-enabled browsers will get the cached compressed page while more primitive browsers will see the plan page. With “Vary: Cookie”, you can return a cached page for anonymous users, and still return a custom page for logged-in users.


Resin Web Server

Behind the scenes, Resin is powered by its own full web server developed 100% in-house at Caucho. Because we have full control and can optimize each individual component, Resin Web Server is able to serve static pages faster than nginx™!

Resin Web Server includes the following:

  • Powerful and Easy to configure URL rewrite rules
  • Easy to configure Virtual Hosting
  • FastCGI so you can work with Python (Django), Ruby (RoR), native PHP, and more
  • Built-in HTTP proxy cache so you can speed dynamic pages to near-static speeds
  • Built-in PHP language support via Quercus, a PHP clone written in Java
  • Cluster aware load balancer that auto shares loads to new application server nodes
  • Security: Immune to buffer overflow attacks that plague other Web Servers (mostly Java with small, tight, fast JNI/C)

Resin Application Server

Highly interactive web applications for tablets and phones will dominate the web in the next generation. Caucho’s relentless quest for performance and reliability paved the way for Resin Java Application Server to be a leading open source web and application server. Our Java EE Web Profile implementation includes Servlet, JSP, JSTL, EJB Lite, CDI, JSF, JMS and others. Resin provides an ideal environment for lightweight web development – where you can deploy a fast and highly responsive site.

Resin was the first Java EE Web Profile certified Java application server. Resin 4 is built from the ground up around Java Dependency Injection (CDI). Resin 4 is optimized to work in cloud computing environments like Amazon EC2.

With built-in support for both internal and external virtualized
environments, Resin makes it possible for existing applications to
take advantage of an elastic infrastructure. Our clustering supports
running multiple versions of the same application within the same
server so that upgrading requires zero downtime. Resin’s cloud support
includes remote cluster-wide and synchronized application deployment,
data and session replication, failover to improve reliability and
responsive dynamic servers.

Documentation: Enterprise Clustering for Cloud Environments

Short Video with Animations Describing Resin Cloud Support

The Resin 4 core and configuration is built around the Java EE
standard CDI dependency injection. Every Resin configuration from the
resin.xml to resin-web.xml uses CDI as its configuration engine. CanDI
is Resin’s implementation of Java CDI and it is core to Resin 4 Java
Application Server.

JavaEE Integration

  • Usable from servlets, filters, EJBs, and JSF managed beans
  • Integrated with JavaEE scopes (session, request, application)
  • Deploy managed beans through servlet WEB-INF and JavaEE-visible jars
  • Cross-fertilized aspects from EJBs: transactions, interception, security, locking

Service Centered Design

  • Centralized registration and lookup.
  • Uniform lifecycle management.
  • Self-documented service declaration and binding.
  • Automatic discovery and wiring.

Resin Distributed Cache

Java caching can speed application performance and lower database load by annotating cacheable methods. Resin application server that supports both CDI and JCache, you can add caching easily without much configuration. It uses the method parameters as a cache key, and stores the method result in the cache. On the next method call, the enhanced method will look for the saved result in the cache, and return it, saving the effort of the method.

You’ll want to cache to:

  • Improve latency
  • Reduce database load
  • Reduce CPU use

Resin Cache features:

  • Larger cache size – based on host OS disks and not RAM size
  • Automatic data persistence
  • Triple redundancy backed by Triad servers
  • Interface with JCache
  • Garbage Collection-less (GC-less) in-memory cache
  • Cache dynamically updated in cloud environment
  • Memcached wire protocol support

“Resin’s cache support is fast, durable and fully elastic,
allowing for the addition or removal of nodes as needed without
getting extra hits to your database. We also provide a JCache
interface, so you can have characteristics of an infinite cache
or fine grain controls and configuration of caches, as per JCache
(JSR 107, which we track closely). If you use JCache, we have
implemented a GC-less in-memory cache; if the item is in this
first level cache then the performance can be 1000x faster than
going an external cache. This is an easy setup that provides
in-memory speeds to applications.”
– Scott Ferguson, Software Architect at Caucho Technology.

Resin Adaptive Health Monitoring

Because your site’s reliability is important, Resin monitors its internal sensor net every 60 seconds, recording your server’s memory, cpu, network, database and cluster status. Resin monitors JVM metrics, Java Application Servers metrics and OS metrics. The Resin JAMM saves the data so you can adjust the servers based on load, and can analyze problems after they occur. The data is saved so Resin can identify trends and anomalies.

Each 15 minutes, the health system checks the sensor data and reports a status: OK, WARNING, CRITICAL or FAIL. You can direct Resin’s health system to act based on the health check results, mailing a notification, gathering further thread and memory information or even restarting.

Picture showing graphs of common metrics collected by the Resin Health System

  • health checks: validates system health every minute, recording for further action or review.
  • rule-based health actions: when load is high or memory low, Resin can send mail, dump the heap, dump the threads, perform Java profiling or even restart based on administration rules.
  • flexible monitoring: gathers, archives and displays any JMX value.
  • postmortem analysis: when a server fails, the saved monitors and logs are available to determine and resolve issues.
  • track trends and anomalies: track trends and anomalies with ability to do just in time Java profiling.

Get started today!

All-in-one solution

One install. One management. Everything you need. At Caucho, we pride ourself in having built virtually every component of Resin in-house to allow Resin to outperform all other solutions out there. Resin is all you need to build scalable data-intensive cloud applications.

It is difficult to scale your application when your underlying architecture is built upon many 3rd party packages. Each 3rd party component requires separate update schedules, memory, resources, and expensive licensing; it is a management nightmare. With Resin, you do not waste time with 3rd party components or external dependencies. When you scale Resin, you scale your entire application. You are not straddled with managing multiple components in a complex production environment. Your time is freed to develop and improve your application. The diagram below highlights the advantages of Resin’s uniform solution over multiple 3rd party packages:

resinarch 3rd_party
  • One license covers and horizontally scales your environment ( public, private, hybrid clouds)
  • Simple and easy configuration with optimized and secure components
  • Small memory footprint (35 MB Total), requires less hardware
  • Multiple licenses and updates to maintain, expensive to scale
  • Multiple configuration files for 3rd Party components require “wiring code” introducing points of failure and possible security exploits
  • Large architecture memory overhead, requires more hardware and security management

Next generation

Resin solves the aforementioned problems by providing the first architecture that is built in-house and intended for massively scalable and data-rich applications. Resin provides your application with:

  1. Components that are optimized to work together
  2. No external dependencies
  3. Ability to easily upgrade and test without rearchitecting
  4. Minimal memory footprint so your hardware costs stay low
  5. Support directly from engineers who work on Resin’s code

Resin’s core components provide you with everything needed to build and maintain robust enterprise applications. Resin also comes out of the box with plug-and-play support for the top industry standards in caching, health monitoring, and messaging so you are can easily integrate into your current environment.

Define your use case

Non mission-critical / Less than 10 CPU Mission-critical / Greater than 10 CPU

If your application is small and:

  • Is going to be deployed to non-clustered environments
  • Needs only a subset of Java EE Profile
  • Has a small code base with a very basic architecture

These applications do not have the requirements that mission and business critical applications have and can be implemented on a single server with a variety of Open Source components. For these projects we recommend the GPL version of Resin as it is the best of breed in Open Source Application Servers. For further clarification read through our FAQ

Using 3rd party architecture in this category means your application is susceptible to:

  • Upgrades that require all external frameworks and components to be compatible
  • Bugs in 3rd Party components requiring external support
  • Multiple points of failure when attempting to scale
  • Slow and stagnant development

These applications are in the realm of complexity that require a tested, scalable, and manageable environment to stay productive. It becomes impractical to manage multiple 3rd party components, frameworks, and configuration files.

Next: Get a detailed look at the advantages of Resin’s individual components