Resin is a leading high performance, scalable Java/PHP application server that is deployed by over 8,000 companies worldwide including Fortune 500 and some of the highest traffic sites of the Internet. According to the May 2008 Netcraft report, Resin is the most popular Java server, with over 340,000 deployed hosts.

Founded in 1998, Caucho Technology has earned an industry reputation as the most reliable application server on the market. Resin Professional adds a number of reliability features, including disaster recovery mechanisms that recover from application errors.

Performance is a basic requirement at Caucho. Highly optimized delivery of static content means that Resin outperforms Apache on small to medium sized static files. Optimizations for performance are included throughout Resin, including a fast JSTL implementation that translates directly to Java code, a heavily optimized implementation of JSF, and aggressive caching and profiler based optimization. Benchmarks comparing Resin to Tomcat show that Resin handles 80% more requests per second for a simple 8k jsp file.

Resin is a focused and complete solution, providing the infrastructure that developers need without the burden of extraneous and specialized projects. In a single integrated and well tested package Resin provides Servlet, JSP, JSF, JSTL, transaction management, messaging, remote services (SOA), distributed sessions, SSL, a complete logging solution, PHP, a fast and fully capable HTTP server, and load balancing. With production features already part of the package, Resin users are confident that the monitoring, administration, deployment, scalability, and troubleshooting features they need when a site goes live are available.

With a low overhead and careful memory management, Resin is a rock-steady performer that provides all of the core services and leaves system resources to applications.

An early adopter and innovator of the inversion of control pattern, Resin now provides complete inversion of control capabilities using standard Java and JavaEE standard annotations and very simple configuration options. POJO objects can be injected, annotated for lifecycle hooks, intercepted for AOP style programming, code for event handling, and marked with transaction boundaries using java.* and javax.* standard annotations from WebBeans (JSR-229) and EJB. Integration is provided with many popular frameworks, including Spring, Struts2, Wicket, and Mule, providing Resin configured beans to the frameworks environment.

Resin provides the ability to separate Resin code from application code, providing for a server root of the sites applications and configuration that is separate from the Resin program files. This separation makes upgrades to the Resin server simple. Merge paths and file mappings allow for the creation of a virtual file system that is the aggregate of files and code from disparate file system locations. Conditional configuration constructs are available in all configuration files, allowing for a single configuration file that can adapt to development, staging, and production environments.

Resin Professional provides a number of reliability features, including automatic server restart, detection and restart of locked or stalled servers, and monitoring of JVM memory usage for applications with memory leaks.

In many situations, Resin is able to recover even from misbehaving applications with problems such as memory leaks and thread deadlocks. Resin monitors the JVM process closely, and when a problem is detected logging is emitted that describes the problem and the process is restarted. This enables the rapid recovery of website functionality, and provides the information necessary for administrators and developers to track down the problem.

Hooks are provided through the ping functionality to allow applications to provide their own indication of the health of a server. Applications can create custom checks of important areas such as database connectivity and indicate success or failure.

Most Resin users find that Resin itself requires little or no monitoring or maintenance in the production environment. Resin does provide a number of monitoring features, including basic information obtained through an administration application, and an extensive amount of information available via JMX.

Convenient configuration is provided for applications to implement their own JMX mbeans, making it much simpler for applications to add monitoring information than when using the JMX API directly, and thus encouraging developers to provide monitoring information.

Support is provided for industry standard SNMP, allowing sites to integrate Resin with their existing SNMP based monitoring infrastructure. Convenient configuration allows applications to expose application specific attributes via SNMP.

Resin provides the simplest deployment environment in the industry. Based on the presence of files on the filesystem, administrators can easily add or remove applications and even virtual hosts by adding or removing files. Because no GUI is required, administrators are free to customize their deployment strategy to suit their requirements, with the flexibility to choose scripting, shared mounts, package management tools like RPM, or version control based checkouts.

Resin provides support for the deployment of versions of applications, solving the problem presented when new versions of applications have incompatible sessions. Resin is configured to recognize a version number scheme on deployed applications, and will run two versions of the same application, directory requests with existing sessions to the old version and directing requests with newly established sessions to the new version.

Merge paths allow the specification of multiple paths that are merged together and presented to the application as if it was one unified path. Merge paths are useful for specifying customization directories that allow for the insertion of files that replace the usual file that is shipped with a web application. The also provide users a great deal of flexibility in the deployment of files to servers, allowing for example static files to be located in a location on the filesystem that is completely distinct from the web applications directory, yet appear to the application code as part of the web application.

Resin provides a number of troubleshooting aids for situations commonly arising in production environments. The administration application provides the ability to obtain sorted thread dumps, and invaluable tool for determining what is occurring with servers. Also provided are heap dumps, and a profiler that can be run with minimal performance impact on production servers. Carefully chosen logging can be increased in configuration or at runtime to help pinpoint problems.

Resin includes a throttling mechanism that limits the number of concurrent requests allowed for any particular client IP address. This allows site administrators to handle situations where malicious or errant users are attempting a denial of service attack or are using the server too aggressively.

Resin is a focused and complete solution, providing the infrastructure that developers need without the burden of extraneous and specialized projects.

Unlike other similar products, Resin is a clean room implementation that does not borrow or include third party libraries. All code has been developed by Caucho and integrated into an extensive QA process. Because Resin is using only it's own code, applications do not need to worry about incompatibility between versions of third-party libraries they use and versions of the same libraries used by the application server.

Resin has always been developed using an agile, test first approach. The first line of code written in 1998 was a test. Over 25,000 tests are run on a nightly basis. Additionally, each release receives extensive stress testing and compatibility testing for various environments.

Caucho takes great pride in it's short release cycle. Typically a new release is provided every 6-8 weeks, providing users with an extremely fast turnaround on bug fixes and feature requests.

Caucho focuses on making the best Java web server product on the market. With a strong focus on engineering and performance, Caucho dedicates almost all company resources to engineers. With a very demanding hiring and selection process, Caucho has built a team containing engineers of the highest calibre.

Caucho has made a deliberate decision to focus company resources on product development and does not provide consulting services directly. This was done in recognition that consulting services motivate complicated and cumbersome products. The focus of Caucho is on developing the simplest, fastest, and most effective application server available on the market.

The Caucho engineering team is led by Scott Ferguson, who has been called a "master craftsman" and was recognized in theserverside.com's Top 50 "Who's Who in Enterprise Java". Starting in 1998, Scott and the Caucho engineering team have innovated and lead in the Java web server field, providing the first product to focus on a Java HTTP web server, server-side scripting, and development of the Hessian binary web services protocol. Resin was also the first Java web server to integrate low-level native networking code to maximize web server capabilities while still taking advantage of the general flexibility and safety of the Java environment.

In 2005 Caucho announced Quercus, a complete implementation of the PHP language and libraries in Java that executes as bytecode in the JVM. With this announcement Caucho again demonstrated itself to be a leader in new technology capable of solving some of the most demanding engineering tasks.

The leadership continues, with recent innovations including the integration of IoC capabilities using the WebBeans API, configuration based export of POJOs using multiple web services protocols, a fault tolerant cluster based solutions for JMS with linear scalability, explicit integration support for a multitude of open source packages, and an interface for COMET style programming.

Caucho has a reputation for providing great support, with knowledgeable hands on responses, a fast turnaround time, and quick resolution of issues and bug fixes.

Every engineer on the Caucho team is involved in providing support. Technical support is not outsourced and not delegated to a separate support team. That means that support questions go directly to the engineers that are working on the product every day.

Resin serves static files as fast or faster than the Apache web server. Performance measurements show that Resin serves static files 20% faster on 1k files, slightly faster for 64k files, and slightly slower for a 7 megabyte file.

Resin has been lauded since it's inception over 10 years ago as the high performance solution for Servlet and JSP. Optimizations for performance are included throughout, including a fast JSTL implementation that translates directly to Java code, and aggressive caching and profiler based optimization. Benchmarks comparing Resin to Tomcat show that Resin handles 80% more requests per second for a simple 8k jsp file.

Resin provides an implementation of JavaServer Faces (JSR-127, JSR-252). Resin's implementation integrates directly with Resin's other core features which allows for optimizations not available in other containers.

Resin's transaction manager handles full two-phase XA transaction support, and includes transaction logging for reliable transaction recovery. The transaction capabilities are integrated throughout Resin, so databases, JCA connections, and EJBs work together. WebBeans IoC injection is provided for UserTransaction and TransactionManager, bringing full annotation based transaction capability to standard JSP/Servlet based applications. In combination with Quercus, Resin brings support for transactions to PHP.

Resin includes a buffered and optimized access logging facility. The default format for entries is designed to match the expectations of common log analysis tools, and is customizable with a number of escape sequences that provide the most commonly required information. Flexibility in configuration allows logging to be done on a server wide basis, or per virtual host and/or web application.

Log rollover capabilities increase the manageability of log files, and provide date and/or size based rollover, as well as automatic compression of log files for efficient use of disk space.

Customized handling is easily configured in addition to or as a replacement of Resin's access logging, allowing for example custom logging directly to a database or a data warehouse.

URL rewriting is an indispensable tool for the long term management of a web site. Resin includes a comprehensive URL rewriting facility with possible criteria for rules that include most aspects of the requests such as headers, cookies, security, and request parameters. The Resin rewriting facility also allows for the dynamic enabling and disabling of rewrite rules, providing the ability for rewriting to be used as part of a sites management strategy, for example allowing time-based redirections during planned outages.

Resin Professional provides a memory and disk based caching system for increased performance benefits. Server caching can speed dynamic pages to near static speeds. Small but frequently accessed resources such as images and CSS files are cached in memory and served directly to the client, avoiding even a read from the disk.

Native code is used to provide significant performance benefits in areas like socket connections, keepalive connections, and file system access - performance benefits not typically available to a Java application. With extra support for keepalive connections that do not require a thread Resin is well suited for modern AJAX based applications which require a more continuous conversation between the browser and the server.

Bandwidth costs are significant for many websites. Resin provides facilities for automatic compression of responses for browsers that support it and is smart enough to workaround issues with the popular Internet Explorer browser. In conjunction with the built in Proxy Cache, gzipped responses can provide a more responsive experience to the user by reducing the network travel time of data as it is delivered to the client.

Resin Professional uses native code to link to the industry standard OpenSSL libraries, a much better and more efficient SSL solution than the SSL facilities provided by the Java JSSE library. Resin supports the full suite of functionality available with OpenSSL, including client side certificates.

Resin's flexible handling and low overhead of virtual hosts makes it a favorite for many production environments that require flexibility and isolation for virtual host configurations. Resin's unique directory-based virtual host deployment provides administrators the ability to deploy and configure new virtual hosts without server restart.

Resin provides an API for COMET, improving the reliability of server push and greatly simplifying application development by taking care of error-prone system tasks like thread and managing large numbers of network connections. A common requirement for Rich Internet Applications, Resin's COMET support enables the development of clients that receive a stream of data from the server without the need for constant polling.

As the server side component of browser-based requests, Resin's COMET support enables the development of interactive Ajax style applications such as chat and notification.

In combination with the Hessian client for Flash/Flex, Resin's COMET support enables the development of more interactive Flash applications without an inordinate increase in complexity and scalability problems.

Clustering provides the ability for multiple servers to appear as one server to clients. This feature provides enhanced reliability and allows sites to scale up as server demand increases, In combination with a load balancer, Resin sites can scale their capacity to handle client requests linearly. Clustering is also used to provide a distributed store for sessions and JMS messages.

Persistent sessions guarantee that a server can restore the contents of the HttpSession object when it is restarted. Distributed sessions provide the ability for multiple servers in a cluster to share the values stored in the HttpSession.

Unlike solutions seen in competing products Resin includes a cluster based persistent sessions mechanism that scales linearly as the cluster grows. Resin carefully chooses a (configurable) number of backup servers for each session, and optimizes the amount of network traffic. Resin users can be confident that their cluster can grow without degradation of performance or an exponential growth in session related traffic.

Hessian based serialization is provided as an option for sessions, greatly reducing the size of the serialized session which improves performance and minimizes storage requirements.

Resin provides a full featured load balancer with enterprise capabilities. Load balancing allows for the allocation of more servers as load demands increase. Resin's load balancer builds upon that requirement, and provides advanced features including sticky sessions, weighing of backend servers by various criteria including CPU load, and the ability for real-time management of the distribution of load. Resin is able to rollover requests to another backend server, so a failure on the backend server, even for a POST request, does not interrupt the users experience. A sophisticated algorithm allows backend servers a warmup time, giving a backend server the opportunity to fill caches and allocate resources gradually as load increases.

Resin provides a built-in build process that causes changes to Java source and Groovy source files to be recognized and compiled immediately, avoiding the overhead of the build step in the code-build-test cycle. Hot swap features allow for changes to class files to be immediately loaded into a running application without requiring a restart of the server or the application being developed.

Configuration is provided to enable developers to match this facility to the structure of their project layout, which can often lead to the ability to avoid the compilation/build/deploy step common with other servers. This ability can result in significant time savings for developers.

Resin includes a profiler, encouraging developers to make profiling a common component of the development cycle. This often results in a significant improvement to the performance of an application.

Resin provides a hands off approach to deployment and development, and does not require the cumbersome and time consuming use of a GUI. Very sophisticated usage of the filesystem and file naming conventions allow most deployment and redeployment tasks to be performed by placing or replacing files.

Resin provides an embedded server that is perfect for JUnit tests. The embedded Resin can be tested without using an external HTTP/TCP connection, providing overhead and a simple setup.

Resin provides integration with Ant, Maven, and Ivy. A Maven repository provides the ability for Maven or Ivy build scripts to include their dependencies on the Resin application and automatically download them. Ant tasks are provided for JSP compilation, XXX:.

Resin is simple enough and fast enough that most developers use Resin without the requirement of a Resin specific plugin. For those who require it, or prefer the server to be integrated directly with the IDE, Eclipse and NetBeans plugins are provided.

Developers can customize Resin to suit their development style. Custom classloaders can be configured to recognize source files in non-standard areas and provides for automatic compilation of source. Merge paths and file mappings allow for the creation of a virtual filesystem that is the aggregate of files and code from disparate file system locations.

Resin uses the Java logging API introduced in JDK 1.4. Resin itself has carefully chosen logging, providing developers useful and relevant information without overwhelming them with unnecessary and difficult to decipher details. More details are incrementally requested from Resin by increasing logging levels.