L'injection dans un Jersey de classe de Ressource

Cette solution fonctionne bien et je voulais partager ce que j'ai trouvé pour permettre CDI sur le maillot des ressources.

Ici est la plus simple haricot jamais :

package fr.test;
import javax.annotation.PostConstruct;
import javax.enterprise.context.RequestScoped;
@RequestScoped
public class Test {
private int i;
@PostConstruct
public void create() {
i = 6;
}
public int getI() {
return i;
}
}

Dans votre classe de ressource, nous avons juste injecter cette fève, comme nous le ferions dans un contexte normal :

package fr.test;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
@Path("/login")
public class LoginApi {
@Inject
private Test test;
@GET 
@Produces("text/plain")
public String getIt() {
return "Hi there!" + test;
}
}

Et c'est là la clé. Nous définissons un Maillot "InjectionProvider" qui sera responsable des haricots " résolution :

package fr.test;
import javax.inject.Inject;
import java.lang.reflect.Type;
import javax.ws.rs.ext.Provider;
import com.sun.jersey.core.spi.component.ComponentContext;
import com.sun.jersey.core.spi.component.ComponentScope;
import com.sun.jersey.spi.inject.Injectable;
import com.sun.jersey.spi.inject.InjectableProvider;
import fr.xxxxxxxxxx.ApplicationBeans;
@Provider
public class InjectionProvider implements InjectableProvider<Inject, Type> {
public ComponentScope getScope() {
//CDI will handle scopes for us
return ComponentScope.Singleton;
}
@Override
public Injectable<?> getInjectable(ComponentContext context,
Inject injectAnno, Type t) {
if (!(t instanceof Class))
throw new RuntimeException("not injecting a class type ?");
Class<?> clazz = (Class<?>) t;
final Object instance = ApplicationBeans.get(clazz);
return new Injectable<Object>() {
public Object getValue() {
return instance;
}
};
}
}

InjectableProvider est tapé avec le type de l'annotation, nous sommes la manipulation, et le type de contexte (ici, normal type java)

ApplicationBeans est juste une simple aide pour les haricots résolution. Voici son contenu :

package fr.xxxxxxxxxx;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.inject.Inject;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import fr.xxxxxxxxxxxxx.UnexpectedException;
/**
* Gives direct access to managed beans - Designed to be used from unmanaged code
* 
* @author lgrignon
* 
*/
@ApplicationScoped
public class ApplicationBeans
{
protected static ApplicationBeans instance;
@Inject
private BeanManager beanManager;
/**
* Gets instance
* 
* @return Instance from managed environment
*/
public static ApplicationBeans instance()
{
if (instance == null)
{
BeanManager beanManager;
InitialContext ctx = null;
try
{
ctx = new InitialContext();
beanManager = (BeanManager)ctx.lookup("java:comp/BeanManager");
}catch(NamingException e)
{
try
{
beanManager = (BeanManager)ctx.lookup("java:app/BeanManager");
}catch(NamingException ne)
{
throw new UnexpectedException("Unable to obtain BeanManager.", ne);
}
}
instance = getBeanFromManager(beanManager, ApplicationBeans.class);
}
return instance;
}
/**
* Gets bean instance from context
* 
* @param <T>
*          Bean's type
* @param beanType
*          Bean's type
* @param annotations
*          Bean's annotations
* @return Bean instance or null if no
*/
public static <T> T get(final Class<T> beanType, Annotation... annotations)
{
return instance().getBean(beanType, annotations);
}
/**
* Gets bean instance from context
* 
* @param <T>
*          Bean's type
* @param beanType
*          Bean's type
* @param annotations
*          Bean's annotations
* @return Bean instance or null if no
*/
public <T> T getBean(final Class<T> beanType, Annotation... annotations)
{
return getBeanFromManager(beanManager, beanType, annotations);
}
@SuppressWarnings("unchecked")
private static <T> T getBeanFromManager(BeanManager beanManager, final Class<T> beanType, Annotation... annotations)
{
Set<Bean<?>> beans = beanManager.getBeans(beanType, annotations);
if (beans.size() > 1)
{
throw new UnexpectedException("Many bean declarations found for type %s (%s)", beanType.getSimpleName(), beansToString(beans));
}
if (beans.isEmpty())
{
throw new UnexpectedException("No bean declaration found for type %s", beanType.getSimpleName());
}
final Bean<T> bean = (Bean<T>)beans.iterator().next();
final CreationalContext<T> context = beanManager.createCreationalContext(bean);
return (T)beanManager.getReference(bean, beanType, context);
}
private static String beansToString(Collection<Bean<?>> beans)
{
String[] beansLabels = new String[beans.size()];
int i = 0;
for (final Bean<?> bean : beans)
{
beansLabels[i++] = bean.getName();
}
return Arrays.toString(beansLabels);
}
}

Espère que cela aidera ceux qui veulent activer CDI injection dans leur Maillot de ressources.

Bye !

OriginalL'auteur Louis GRIGNON