Resin Documentation

features - resin and resin professional

Resin is a high-performance, scalable Java/PHP application server. We release two versions of Resin: an open source version under the GPL, and a professional version with enhanced performance, clustering, and reliability features.

Resin is provided in two versions, Resin Professional and Resin Open Source. Resin Professional adds features and enhancements commonly needed in a professional production environment. Resin Open Source is suitable for hobbyists, developers, and low traffic websites that do not need the performance and reliability enhancements of Resin Professional.

• See Resin-Ioc documentation.

Resin uses its own IoC/Dependency Injection engine for all of its JavaEE configuration. With the new WebBeans (JSR-299) specification draft, Resin provides the same capabilities to application code. Components and singleton beans can be configured in the resin-web.xml for full XML configurability, or scanned for the class annotations for lightweight injection to match the style of the application.

Because Resin-IoC is fully integrated with Resin's EJB 3.0 support, all application components and beans can use EJB aspects such as @TransactionAttribute, @Stateless, @InterceptorClass, and @AroundInvoke.

The WebBeans IoC capabilities provide finely-controlled interception with @InterceptorType binding, and type-safe dependency-injection with @BindingType annotations. Testing with mock components are automatically supported with custom @ComponentType annotations.

Event handling is fully integrated with the WebBeans API using a flexible @Observes parameter attribute, enabling any bean or component to listen to any matching typed event thrown through the WebBeans Container interface.

Resin-managed classes are automatically enlisted in the IoC engine. So Servlets, Filters, application listener classes, remote objects, and EJBs can all use Resin-IoC capabilities without any additional configuration.

Resin-IoC provides a straightforward driver for integrating Resin-IoC capabilities with popular frameworks. Struts2, Spring, Mule, and Wicket have already been integrated.

• See Quercus/PHP documentation

Resin includes Quercus, our PHP 5 implementation, written entirely in Java. Quercus is a reliable PHP, compiling to Java code and taking advantage of the JDK's JIT compiler for maximum performance. Because Quercus is in Java, it's security is far superior to a C implementation. The JVM automatically protects Quercus from stack overruns, pointer overflows, and third party C-modules.

And the performance is great. The compiled Quercus code is 4 to 6 times faster than raw, mod_php code. Even when compared with PHP accelerators, Quercus code is equal or slightly faster, depending on the application.

Quercus integrates tightly with Java, naturally since it is written in Java. Resin-IoC applications can easily provide beans and components to a Quercus/PHP presentation layer through a simple java_bean call. For more involved integration, Quercus provides a complete API for generating PHP facades over Java libraries. All the PHP libraries are written to this public API.

With Quercus, Java sites have access to the PHP killer applications. For blogs, Quercus supports the extremely popular Wordpress. For wikis, Quercus supports MediaWiki, the engine behind Wikipedia.

Resin provides a robust connection pool for any JDBC 1, JDBC 2, or JDBC 3 database driver. Resin's database pools integrate with full 2-phase XA transaction capabilities. In addition, the database connections can use round robin load balancing and backup failover for increased performance and reliability.

• See Resin databases documentation

• See Resin EJB 3.0 documentation
• See Amber (JPA) documentation

Resin's EJB support is fully integrated with Resin-IoC and WebBeans. This integration means you can use only the EJB capabilities you need without the overhead of .ear packaging. (Although, .ears are fully supported.) A servlet, for example, can use EJB's @TransactionAttribute without any special packaging.

• See Resin Comet documentation.

As web users are expecting dynamic responses from web sites, the server push HTTP processing model has become important. Also called Comet, server push sends event or streaming data from the server to the client without waiting for a client poll.

Resin's Comet support focuses on solving the concurrency issues around server push. Since the servlet is now responding to events from internal services as well as managing HTTP data, the synchronization issues become more complex. The Resin Comet API is designed to cleanly separate the concurrency roles, letting the servlet continue to operate as a single-threaded request, while letting the event services send asynchronous messages.

JavaScript browsers and Flash applications are both supported by Resin's Comet. Flash can take advantage of Resin's Hessian support to stream binary-encoded events.

• See Resin JSP documentation

Resin's JSP implementation is tightly integrated with the JSTL and JSF implementations. Because of the tight binding, Resin can generate optimized JSP code, improving performance, reducing code size and reducing memory consumption.

Even JSP tag libraries can run faster with Resin's JSP. Resin bytecode-analyzes your tag libraries to determine which capabilities your actually using, and generates only that code necessary to run the features you're using.

The JSP implementation aggressively reuses your tag library instances, reducing memory consumption and improving performance. Because of Resin's reuse, application libraries must strictly follow the JSP tag specification.

Resin-IoC beans are always available through JSP EL expressions. This IoC integration means your custom components and beans are directly accessible to your HTML generating code.

• See Resin JSTL documentation

Resin's JSTL works together with its JSP implementation to provide efficient, generated Java code. Since Resin's JSP is fully JSTL-aware, it can implement the JSTL tags directly in Java code, without involving the overhead of the JSTL tag libraries.

• See Resin servlet documentation

Since the servlet engine of Resin is built on a Resin-IoC foundation, servlets can use WebBeans dependency injection, event observation, and interception. Remember that Resin-IoC is fully integrated with its EJB support? By transitivity, Resin servlets automatically have access to EJB transaction aspects without any extra overhead.

Remote services are tied into servlet capabilities as well. Because remote services are URL-based, they naturally fit into the the familiar servlet processing model. There's no need to introduce complexities like standard EJB deployment or add extra frameworks just to expose a service as a URL.

• See Resin embedding documentation

Resin embedding is a lightweight facade over the core Resin server suitable for automated testing frameworks and IDE environments. With Resin's embedded testing interface, your tests can send HTTP requests directly to the server, skipping the overhead of TCP connections, and saving time on test setup and teardown.

The embedded API gives you hooks into Resin-IoC, so you can inject mock services into your tests, and still ensure that your application is tested in the full application server environment. Since integration testing uses the actual, deployment environment, elusive production bugs are easier to catch and destroy.

• See Resin remoting documentation

Resin remoting builds on the strengths of the Servlet architecture. As developers turn away from complicated remoting frameworks, the simplicity and elegance of the Servlet model becomes more appealing. Multithreaded, IoC-enabled, designed for HTTP and the web's URL architecture, well-known, well-documented, and well-integrated with application servers, the Servlet model has enjoyed phenomenal success.

Services expose remote APIs with the same interfaces and classes their clients will use, taking advantage of the Java compiler to enforce protocol compatiblity. Since Resin remoting protocols are available using a simple driver API based on Servlets, your services can choose the protocol to expose at deployment time, whether its a fast, binary wire-protocol like Hessian, or an XML-based wire-protocol like SOAP. Resin remoting clients select the wire-protocol matched with service API, and register with Resin-IoC/WebBeans, so application code can obtain the client proxy with simple, typed dependency injection.

• See Resin's Amber documentation

• See Resin watchdog documentation

The Resin watchdog service manages each Resin instance, allowing for graceful recovery and restart from critical server deadlocks and crashes. As a management capability, it offers a centralized interface for starting, stopping, and checking the status of multiple JVM instances. Because the watchdog is well-placed to gather information, it is responsible for management and logging of the server's debugging or warning messages.

For unix systems, the watchdog also improves system security. While the watchdog will run as the root user, Resin JVM instances run as low-authorization users, protecting your system from application bugs and security holes.

As a side benefit of the watchdog, JVM parameters like heap settings, agent configuration, remote JMX and system properties can be configured in the resin.conf itself. The watchdog can read the same resin.conf as the server itself, putting all configuration relevant to the server in one location.

For more complicated configurations like an ISP setting, the watchdog can use a separate configuration file readable only by root. The watchdog will launch Resin JVMs with assigned resin.conf files, ports, and user assignment, protecting each Resin JVM user from each other.

• See Resin messaging documentation

Resin's messaging focuses on simplifying the use and deployment of messaging applications. At the core, a messaging system is really just a queue with extra reliability and performance features like persistence, transactions, and clustered distribution. So Resin provides the standard queueing APIs like the JDK BlockingQueue as facades to the JMS API.

On the receiving end, MessageListener implementations are just Java services implementing a single onMessage method to receive the message, so there's no need for complications. The only configuration needed is a binding between the service class and the queue it wants to receive messages from. Three lines of XML is sufficient for that binding, with no need for any extra packaging.

Of course, the message listeners are can use all Resin-IoC capabilities, including injecting JPA EntityManager for database management, or other queues to filter and pass the message along.

Resin's transaction manager handles full two-phase XA transaction suppport, including transaction logging for reliable transaction recovery. The transaction capabilities are integrated throughout Resin, so your databases, JCA connections, and EJBs work together. Since Resin's UserTransaction and TransactionManager are registered with Resin-IoC, injecting these managers into any IoC-enabled component is just adding an @In annotation.

Resin and Resin-Professional are tested and supported on the following operating systems:

• Linux
• Solaris
• Windows
• Mac OS X

Resin is known to work on the following operating systems:

• AIX
• HP-UX
• Free-BSD

Resin is used on these operating systems, however there may or may not be difficulties with Apache integration, and the JNI code that Resin uses to increase performance may not be available.