See Also

Overview

Injecting Resources

@Named and bindings

Since many applications use multiple resources like named databases, your injection may need to specify a name or other binding to uniquely identify the resource you want. In the case of a unique resource like UserTransaction or MBeanServer or an application with a single DataSource, the @Current is enough information. When you have multiple databases, you'll want to use @Name to specify the database name.

import javax.sql.DataSource;
import com.caucho.config.Name;

public class MyServlet extends GenericServlet {
  @Name("foo")
  private DataSource _ds;

  ...
}

<web-app xmlns="http://caucho.com/ns/resin">

  <database>
    <name>foo</name>
    <driver type="org.gjt.mm.mysql.Driver">
      <url>jdbc:mysql://localhost:3306/foo</url>
    </driver>
  </database>

  <database>
    <name>bar</name>
    <driver type="org.gjt.mm.mysql.Driver">
      <url>jdbc:mysql://localhost:3306/bar</url>
    </driver>
  </database>

</web-app>

Injection using a @Name binding annotation is still typed. You can have a database with @Name("foo") and a JMS queue with @Name("foo"), i.e. each type has its own namespace. The typed injection is a big improvement from the JNDI java:comp/env/jdbc/foo vs java:comp/env/jms/foo conventions.

Although many applications will just use @In and @Name, you can also create your own @BindingType annotations to match resources and components.

field, method, and constructor injection

Since Resin implements all three flavors of dependency injection: field, method and constructor, the choice of style is up to you.

You can mark any field with @Current, @New, @Name or any other @BindingType to tell Resin to inject the field. When a @BindingType is used, Resin will only match components configured with that binding type.

import com.caucho.config.Name;

public class MyBean {
  @Name DataSource _ds;
  ...
}

Method injection can use any binding annotation on any of the parameters. When Resin introspects the component class and it finds any @BindingType or @Current parameter on a method, it will schedule that method to be injected. Method parameters can also use @New. The method does not need to follow bean-style setting conventions; any method will work.

import com.caucho.config.Name;

public class MyBean {
  void foo(@Name("jdbc/foo") DataSource myDataSource) { ... }
  ...
}

Construction injection is available for components and singleton beans. Like method injection, the @BindingType values like @Name assigned to the parameters determine the values to be injected.

If the bean has multiple constructors, exactly one must be marked @Current or have a @BindingType value.

import javax.inject.Current;

public class MyBean {
  @Current
  public MyBean(DataSource myDataSource) { ... }
  ...
}

Java Injection simple beans (injectable objects)

Any Resin-managed object can use the entire Java Dependency-Injection system and all of the managed objects, while objects you create using new are still plain Java objects. Once you've got a root object managed by the system, any futher Java injection components or singletons you bring in will also be managed. The starting set of managed objects is pretty broad and includes:

• <my:MyBean> (simple beans) defined in the META-INF/beans.xml, resin.xml or resin-web.xml
• EJB message-driven beans
• EJB session beans
• Filters (servlet)
• JSF resources (currently only model beans)
• JSP pages
• JSP tag libraries
• Servlets
• Servlet Listeners defined in the web.xml
• Simple beans discovered through the classpath scan (see below)
• Java Injection simple beans injected with @New (see below)
• Remote services defined by <servlet> (e.g. Hessian or SOAP).

Resin global resources

Resin automatically provides several global resources to any injectable code. Since these resources are unique, your application will use @Current as the annotation.

javax.inject.manager.Manager provides a reference to the Java Injection manager itself. Applications can use the Manager to raise javax.event events, and lookup components programmatically.

javax.context.Conversation injects the Java Injection conversation scope for a JSF application. The conversatio scope lets JSF views store data local to the page itself, separate from the HTTP session scope.

javax.management.MBeanServer injects the JMX management server. JMX manages Resin's resources, so an application can use JMX to view the current state of Resin. See the JavaDoc for an overview of Resin's resources.

javax.transaction.TransactionManager injects the XA transaction manager. Advanced applications which want to add their own XAResource or Synchronization objects to an active transaction can use @Current TransactionManager.

javax.transaction.UserTransaction injects the XA user transaction manager. Applications controlling XA transactions programmatically will use the UserTransaction to begin(), rollback(), and commit() distributed transactions.

java.util.concurrent.ScheduledExecutorService lets applications schedule threads and timed events controlled by Resin's thread pool, and restricted by the thread-max configuration in the resin.xml. This ScheduleExecutorService is classloader-safe, so Resin will automatically close your scheduled tasks when restarting a web-app.

Resin configured resources

All Resin configured resources are available through WebBeans, since Resin uses WebBeans as its internal registry.

<my:MyBean> is an application-specific custom bean. They can either use Java Inject annotations or just be POJO objects. The simple beans default to @Dependent scope, which means a new instance is created each time they're referenced or injected. The injected type will depend on the class attribute of the bean.

<database> is a JDBC pooled database. The name attribute is assigned to the @com.caucho.config.Name binding. Databases are injected as javax.sql.DataSource types.

EJB stateless beans are automatically registered with Java Injection. The Resin @Name value is the ejb-name. Stateless beans can use the <Stateless> annotation for custom configuration, or rely on the standard EJB discovery mechanism. Each EJB 3.0 @Local interface is registered separately in the Java Injection registry.

EJB stateful beans are automatically registered with Java Injection. The Resin @Name binding is the ejb-name. Stateful beans can use the <Stateful> tag for custom configuration, or rely on the standard EJB discovery mechanism. Each injection or bean lookup will return a new stateful bean reference, modified by the bean's scope (see below.) Each EJB 3.0 @Local interface is registered separately in the WebBeans registry.

EntityManager and EntityManagerFactory objects from JPA are automatically registered with WebBeans. The default Resin @Name value is the persistence-unit name.

<env-entry> tags register their values with Java Inject. The default @Name value is the env-entry-name. The registered type is the env-entry-type.

<jms-connection-factory> automatically registers the configured factory with WebBeans. Connection factories can also be configured with <bean> or <resource>, depending on the JMS provider. The registered type is the class of the connection factory, usually javax.jms.ConnectionFactory

<jms-topic> automatically registers the configured topic with WebBeans. The default @Named value is the topic name. Topic can also be configured with <bean> or <resource>, depending on the JMS provider. The registered type is javax.jms.Topic

<jms-queue> automatically registers the configured queue with WebBeans. The default @Named value is the queue name. Queue can also be configured with <bean> or <resource>, depending on the JMS provider. The registered type is javax.jms.Queue

<remote-client> registers remoting clients with WebBeans. The <remote-client> tag will configure the protocol used and the expected proxy class. The registered type is the API class of the remote service.

<web-app xmlns="http://caucho.com/ns/resin">

  <remote-client class="example.HelloService">
    <url>hessian:http://localhost:8080/hello/</url>
  </remote-client>

</web-app>

public class MyServlet extends GenericServlet {
  @Current example.HelloService _hello;
  ...
}

Application components

Annotation-based Component Discovery

At startup, Resin will scan jars and class directories for a META-INF/beans.xml file. The presence of that file tells Resin to start scanning all the classes in the jar or directory Resin will register each class with the Java Injection registry. The META-INF/beans.xml can be trivial, since its primary purpose is speeding up startup time by letting Resin scan only the jars which contain components. So, applications will generally want to minimize the number of classes in beans.xml jars to make startup fast.

<Beans xmlns="urn:java:ee">
</Beans>

The component itself can be any Java class. Since Resin manages the component, it can use @Current, @BindingType annotations and Resin's @Name to inject any other component or resource. Resin will take care of any circular dependencies automatically.

import javax.annotation.PostConstruct;

public class Movie {
  private String _title;
  private String _director;

  public String getTitle() { return _title; }
  public void setTitle(String title) { _title = _title; }

  public String getDirector() { return _director; }
  public void setDirector(String director) { _director = director; }

  @PostConstruct
  public void init()
  {
    ...
  }
}

The @PostConstruct annotation tells Resin to call the init() method once all the injection and configuration is complete.

Any other component or Resin-managed class like servlets can now use @Current Movie to inject the movie resource.

import javax.inject.In;

public class MyServlet extends GenericServlet {
  @Current Movie _movie;

  ...
}

Most application components will use the Java Injection class scanning mechanism. Except for the META-INF/beans.xml marker file, no additional housekeeping code or XML is required. As described below, applications can reduce the configuration by one more step with the @New annotation replacing @Current. The target class of the @New annotation is automatically registered with Java Injection even if the META-INF/beans.xml is missing. In other words, any plain Java class can become a part of the Java Injection system without overhead.

Scopes: @ApplicationScoped, @Dependent, @RequestScoped

The scope of the component determines when Resin will create a new component and when it will reuse an old one. Singletons will always return the same object, while dependent components will always return a new object instance. Long-lived services will typically be singletons, while scratch-space modules will be dependent components.

Components default to @Dependent scope. Since many components will be used as pieces of other components, @Dependent is the least-surprising value as a default.

You can specify a component's scope with an annotation or in the <my:MyBean> tag. The predefined scope values are: @Dependent, @RequestScoped, @ConversationScoped, @SessionScoped, and @ApplicationScoped.

• @Dependent creates a new instance each time.
• @RequestScoped creates a new instance for each servlet request, reusing the instance for the same request.
• @ConversationScoped creates a new instance for each JSF conversation, i.e. for each JSF view page.
• @SessionScoped creates a new instance for each HTTP session, reusing the instance for the same session.
• @ApplicationScoped uses a single instance for the application. For web applications, this will be the same lifecycle as <web-app> For virtual hosts, this will be the same lifecycle as <host>.

An example scoped resource might be a Calculator object which is used only for a single instance. It might fill the arguments while processing a form and then calculate the result. The @RequestScoped makes sure scripts receive the same instance each time it's called.

package example;

import javax.context.RequestScoped;

@RequestScoped
public class Calculator {
  private int _a;
  private int _b;

  public void setA(int a) { _a = a; }
  public void setB(int b) { _b = b; }

  public int getSum() { return _a + _b; }
}

You could also register the same calculator using XML:

<Beans xmlns="urn:java:ee" xmlns:example="urn:java:example">

  <example:Calculator>
    <RequestScoped/>
  </example:Calculator>

</Beans>

@New bean discovery

The @New annotation automatically registers the target class with the Java Injection registry and tells Resin to create a new instance of the bean, even if the bean has an application scope definition. Since @New replaces @Current, it can be used anywhere @Current can be used.

import javax.inject.New;

public class MyServlet extends GenericServlet {
  @New Movie _movie;

  ...
}

The Movie is identical to the movie class defined above, but doesn't need the META-INF/web-beans.xml marker file. In many cases, the @New annotation can replace the Java new operator. If your application starts using @New consistently, it can add injection capabilities to a growing share of your code, letting you simplify and refactor incrementally.

package example;

public class Movie {
  private String _title;

  public String getTitle() { return _title; }
  public void setTitle(String title) { _title = title; }

  @PostConstruct
  public void init() { ... }
}

Lifecycle: @PostConstruct and @PreDestroy

If your service needs to initialize itself after being configured, it can annotation an initialization method with @PostConstruct. After Resin creates, injects, and configures your component, it will call any @PostConstruct methods. Long-lived services or services that need to register themselves with other services will typically need to use the @PostConstruct annotation.

At the end of a component's lifetime, you might need to close some resources, e.g. closing a socket or delisting from a timer service. Resin will call any component method marked with @PreDestroy before it destroys the method.

For example, a TimerService may want to schedule a event every 2 seconds. The @PostConstruct method will start the timer and the @PreDestroy method will stop the timer.

import javax.annotation.PostConstruct;
import javax.inject.Current;
import java.util.concurrent.ScheduledExecutorService;
import com.caucho.config.Service;

@Service
public class TimerService {
  @Current ScheduledExecutorService _timer;

  @PostConstruct
  public void init()
  {
    _timerFuture = _timer.scheduleAtFixedRate(this, 0, 2, TimeUnit.SECONDS);
  }

  ...

  @PreDestroy
  public void close()
  {
    _timerFuture.cancel(false);
  }
}

XML configuration

bean and component registration

The <my:MyBean> tags register application classes with Resin. The default scope of a <my:MyBean> is @Dependent. A <my:MyBean> will create a new instance each time it's injected or referenced.

<Beans xmlns="urn:java:ee" xmlns:example="urn:java:example">

  <example:MyService>
    <ApplicationScoped/>
  </example:MyService>

  <example:MyComponent>
  </example:MyComponent>

</Beans>

The <my:MyBean> tags can configure fields and annotations:

Bean property configuration

Resin's Java Injection configuration uses the standard JavaBeans patterns to configure properties. Resin uses the same mechanism for all of its own configuration parsing, including every JavaEE configuration file, the resin-web.xml and the resin.xml itself. So your application will have all the configuration flexibility it needs.

Since the component beans can use Java Injections, injected components are typically not configured in the resin-web.conf, avoiding the need for tags like <ref>.

package example;

public class Hello {
  private String _greeting = "default";

  public void setGreeting(String greeting) { _greeting = greeting; }
  public String getGreeting() { return _greeting; }
}

The basic example sets a greeting property of a hello, world bean. Resin will apply the configuration to the instance as part of the creation process.

<Beans xmlns="urn:java:ee" xmlns:example="urn:java:example">

  <example:Hello>
    <example:greeting>Hello, World</example:greeting>
  </example:Hello>

</Beans>

Resin's configuration uses 5 basic bean patterns, extending the JavaBeans conventions. It can configure literal values like string and integers as well as configuring other beans. Any component bean configured by Resin has full access to @BindingType injection as well as the standard @PostConstruct annotations. Sub-beans are not automatically registered with Java Inection, i.e. they act like the servlet configuration.

(Currently the patterns are name-based like JavaBeans, since Resin was designed before annotations. We may add configuration annotations in the future.

  public void setFoo(String data);

  public void setFoo(Movie data);

  public void addFoo(Movie data);

  public Movie createFoo();

  public void setText(String data);

1. setFoo(String) configures a standard JavaBeans-style literal.
2. setFoo(Movie) creates a new instance of Movie and recursively configures it.
3. addFoo(Movie) also creates a new instance of Movie and recursively configures it. addFoo is an easy way of configuring lists.
4. Movie createFoo() lets the bean create the Movie instance. Many beans can use createFoo with inner classes to handle complex configuration.
5. setText is called with the text contents of the XML. Value-style beans will use this. (somewhat rare).

As mentioned above, Resin uses these 5 patterns to handle all of the JavaEE configuration files. In particular, the createFoo pattern returning inner classes is very handy for some complicated configuration cases, and for cases where a sub-tag needs information about the parent.

<web-app xmlns="http://caucho.com/ns/resin">

  <example:Theater xmlns:example="urn:java:example">
    <example:name>Balboa</example:name>

    <example:movie title="The Princess Bride"/>

    <example:movie title="The Maltese Falcon"/>
  </example:Theater>

</web-app>

In this example, the Theater classes uses an inner Movie class to illustrate the use of the create pattern.

public class Theater {
  String _name;

  ArrayList<Movie> _movies = new ArrayList<Movie>();

  public void setName(String name) { _name = name; }

  public Movie createMovie()
  {
    return new Movie(this);
  }

  public void addMovie(Movie movie)
  {
    _movies.add(movie);
  }

  public static class Movie {
    private Theater _theater;
    private String _title;

    Movie(Theater theater)
    {
      _theater = theater;
    }

    public void setTitle(String title) { _title = title; }
  }
}

Base configuration: string conversions

Java Injection provides a number of built-in string conversion types as well as supporting JavaBeans PropertyEditor and custom converters.

public class MyBean {
  public MyBean(String value)
  {
    ...
  }
}

public class MyBean {
  ...

  public static MyBean valueOf(String text)
  {
    MyBean bean = new MyBean();
    bean.setTextValue(text);
    bean.init();
    return bean;
  }
}

Compound types

<my-bean>
  <values>
    <value>a</value>
    <value>b</value>
    <value>c</value>
  </values>
</my-bean>

<my-bean>
  <values>
    <value>a</value>
    <value>b</value>
    <value>c</value>
  </values>
</my-bean>

<my-bean>
  <values>
    <list>
      <value>a</value>
      <value>b</value>
      <value>c</value>
    </list>
  </values>
</my-bean>

<my-bean>
  <value>a</value>
  <value>b</value>
  <value>c</value>
</my-bean>

<my-bean>
  <values>
    <entry key="a" value="one"/>
    <entry key="b" value="two"/>
    <entry key="c" value="three"/>
  </values>
</my-bean>

References and EL Expressions

Resin-IoC configuration files can use EL expressions to get references to resources, beans, system properties, and calculate generatal expressions based on those values. Since all Resin's resources are added to the WebBeans registry automatically, application components have access to anything they need.

Both the JSP immediate syntax and deferred syntax are supported (${...} vs #{...}). Currently, there is no distinction between the two, but the deferred syntax is preferred, since Resin-IoC initializes beans lazily to handle circular references.

<web-app xmlns="http://caucho.com/ns/resin">

  <bean name="a" class="qa.FooBean">
    <init bar="#{b}"/>
  </bean>

  <bean name="b" class="qa.BarBean">
    <init foo="#{a}"/>
  </bean>

</web-app>

Because Resin's EL implementation allows method expressions, you can use beans as factories in the EL expressions.

Scripting: PHP, JSF and JSP

Quercus/PHP

In Quercus/PHP, the java_bean(name) method returns the component with the given name. For singletons, Resin will return the unique bean. For other beans, Resin will create the bean if necessary and store it in the configured scope.

<?php

$movie = java_bean("movie");

echo "title: " . $movie->title . "\n";

?>

JSP/JSF EL

Resin automatically provides the Java Injection variables to EL expressions for both JSP and JSF.

<c:out value="${movie.title}"/>

The JSF also uses the expression language, but uses the deferred syntax, since JSF needs to build a component tree first.

<f:view>
  <h:outputText value="#{movie.title}"/>
</f:view>

@BindingType: custom injection binding

@Produces methods

Aspects: Method Interception

Event Handling

Aspect Annotations

@AroundInvoke

@AroundInvoke marks an interception method on the bean or an interceptor class. The interceptor is invoked while processing a business method.

@Target(METHOD)
@Retention(RUNTIME)
public @interface AroundInvoke {
}

import javax.interceptor.*;

public class MyBean {
  @AroundInvoke
  protected Object log(InvocationContext cxt)
    throws Exception
  {
    System.out.println("Before: " + cxt.getMethod());

    Object value = cxt.proceed();

    System.out.println("After: " + cxt.getMethod());

    return value;
  }

  public String hello()
  {
    return "hello, world";
  }
}

@DenyAll

@DenyAll annotation marks a method as forbidden to all users.

@Target({METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DenyAll {
}

@Interceptor

@Interceptor marks a class as an interceptor using WebBeans-style interception. The class will normally also have an @AroundInvoke method as well as any InterceptorBindingType annotations.

@Target({TYPE})
@Retention(RUNTIME)
public @interface Interceptor {
}

@InterceptorBindingType

@InterceptorBindingType is a Java Injection meta-annotation for creating interceptor binding types. Applications will use @InterceptorBindingType to create application-specific interceptors. The Java Injection binding of interception decouples the interception declaration from the interceptor classes.

@Target({TYPE})
@Retention(RUNTIME)
public @interface InterceptorBindingType {
}

@Interceptors

@Interceptors marks an method or class as being intercepted by the named classes. The interceptor classes will implement an @AroundInvoke method to process the InvocationContext.

@Target({TYPE,METHOD})
@Retention(RUNTIME)
public @interface Interceptors {
  public Class []value();
}

import javax.interceptor.*;

public class MyBean {
  @Interceptors(MyInterceptor.class)
  public String hello()
  {
    return "hello, world";
  }
}

public class MyInterceptor {
  @AroundInvoke
  protected Object log(InvocationContext cxt)
    throws Exception
  {
    System.out.println("Before: " + cxt.getMethod());

    Object value = cxt.proceed();

    System.out.println("After: " + cxt.getMethod());

    return value;
  }
}

InvocationContext

The InvocationContext API is used by invocation methods to examine the calling context, and possibly set parameters. A no-op interceptor would just call the proceed() method.

public interface InvocationContext {
  public Object proceed() throws Exception;

  public Map<String, Object> getContextData();
  public Method getMethod();
  public Object[] getParameters() throws IllegalStateException;
  public void setParameters(Object[] parameters) throws IllegalStateException;
  public Object getTarget();
}

@PermitAll

@PermitAll annotation marks a method as allowed for all users.

@Target({METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface PermitAll {
}

@RolesAllowed

@RolesAllowed lists all the roles (i.e. permissions) allowed to access the method. If the user in the security context does not match the role, an exception will be thrown.

@Target({TYPE,METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RolesAllowed {
  String []value();
}

@RunAs

@RunAs changes the security context user to a defined role. Security tests within the context of the @RunAs will match the specified role.

@Target({TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RunAs {
  String value();
}

@TransactionAttribute

Defines the transaction boundary for business methods. The default value is REQUIRED. If @TransactionAttribute annotates the class, it defines the default value.

All Resin-managed beans can use @TransactionAttribute: @Stateful, @Stateless, @MessageDriven and plain Java beans.

• SUPPORTS is typically used for read-only methods
• REQUIRED is typically used for updating (read/write) methods

@Target({TYPE,METHOD})
@Retention(RUNTIME)
public @interface TransactionAttribute {
  TransactionAttributeType value() default REQUIRED;
}

Dependency Injection Annotations

@BindingType

@BindingType is a meta-annotation for creating custom injection binding types. Applications can create their own injection annotations like @Named to provide application-specific binding. For example, a database might have a @XA and a @NonXA connector implemented.

@Target({TYPE})
@Retention(RUNTIME)
public @interface BindingType {
}

package demo;

@BindingType
@Target({TYPE, METHOD, FIELD, PARAMETER})
@Retention(RUNTIME)
public @interface XA {
}

package demo;

import javax.sql.*;

public class MyBean {
  @XA DataSource _xa;
  @NonXA DataSource _nonXa;

  ...
}

@EJB

Configures EJB values for a field or method.

@EJB is essentially a @Resource where it's known that the result is an EJB interface.

@Target({TYPE, METHOD, FIELD, PARAMETER})
@Retention(RUNTIME)
public @interface EJB {
  String name() default "";
  String businessInterface() default "";
  String jndiName() default "";
}

In the following exaple, Resin will call setFoo method with the bean in "java:comp/env/ejb/foo" before the session is started.

@EJB
void setFoo(example.Test test)
{
  _test = test;
}

@Current

Marks a field, method, or parameter for injection. When used with a constructor, it marks the given constructor as the constructor to use when creating new instances.

@Target({CONSTRUCTOR, METHOD, FIELD, PARAMETER, TYPE})
@Retention(RUNTIME)
public @interface Current {
}

@Named

@Named is used to define an EL name for the bean used for JSP, JSF and PHP named objects. type.

@BindingType
@Target({METHOD, FIELD, PARAMETER, TYPE})
@Retention(RUNTIME)
public @interface Named {
  String value();
}

@New

Marks a field, method, or parameter for injection with a new instance of the object. If the type of the @New has not yet been registered with the WebBeans directory, it will be registered automatically..

@Target({METHOD, FIELD, PARAMETER, TYPE})
@Retention(RUNTIME)
public @interface New {
}

@NonBinding

@NonBinding is a meta-annotation used for creating @BindingType annotations. It excludes an annotation property from the binding algorithm. Normally, the injection binding must matches all the propeties in the object's annotations with the properties in the injection property. The @NonBinding annotation skips the check for the annotated property.

@Target({FIELD, METHOD})
@Retention(RUNTIME)
public @interface NonBinding {
}

package demo;

import javax.inject.BindingType;

@BindingType
@Target({TYPE, METHOD, FIELD, PARAMETER})
@Retention(RUNTIME)
public @interface Demo {
  @NonBinding String description() default "";
}

@Resource

@Resource provides JNDI-based resource injection. @Resource can also be used at the Class level to declare a dependency in cases where the session bean loads the JNDI value by itself.

In general, it's better to use the Java Injection annotations: @Current, Resin's @Name or custom @BindingType annotations, since they use the type-safe WebBeans registry instead of JNDI. @Resource is supported for backwards compatibility.

Framework Integration

ObjectFactory pattern

Frameworks like Struts2 provide an ObjectFactory pattern. In this case, the framework gives a Class object and asks the factory to create a new instance. The ObjectFactory is the most powerful pattern, since objects can use @Observes, @InterceptionType, @TransactionAttribute and even @Stateless, as well as the usual dependency injection.

package com.caucho.xwork2;

import com.caucho.config.inject.*;
import com.opensymphony.xwork2.ObjectFactory;
import java.util.*;
import javax.inject.*;

public class ResinObjectFactory extends ObjectFactory
{
  private final InjectManager _webBeans = InjectManager.create();
  
  @Override
  public Object buildBean(Class clazz, Map extraContext)
    throws Exception
  {
    return _webBeans.getObject(clazz);
  }
}

Injection pattern

Some frameworks, like Wicket, prefer to instantiate the object, but can call Resin-IoC for a dependency-injection step. With this kind of framework integration, the created object only gets dependency-injection; it does not get any aspects or interception.

package com.caucho.wicket;

import com.caucho.config.inject.*;

import org.apache.wicket.Component;
import org.apache.wicket.application.*;

public class ResinComponentInjector implements IComponentInstantiationListener
{
  private InjectManager _webBeans = InjectManager.create();
  
  public void onInstantiation(Component component)
  {
    _webBeans.injectObject(component);
  }
}