Injecting into a Jersey Resource class

后端 未结 2 1290
情歌与酒
情歌与酒 2020-12-30 16:32

I did try going through the following links How to wire in a collaborator into a Jersey resource? and Access external objects in Jersey Resource class But still i am unable

2条回答
  •  没有蜡笔的小新
    2020-12-30 16:45

    This solution works well and I wanted to share what I found to enable CDI on jersey resources.

    Here is the simplest bean ever :

    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;
        }
    }
    

    In your resource class, we just inject this bean, as we would do in a any normal context :

    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;
        }
    }
    

    And here is the key. We define a Jersey "InjectionProvider" which will be responsible of beans' resolution :

    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 {
    
        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() {
                public Object getValue() {
                    return instance;
                }
            };
        }
    }
    
    
    

    InjectableProvider is typed with the kind of annotation we are handling, and the context type (here, normal java type)

    ApplicationBeans is just a simple helper for bean resolution. Here is its content :

    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 
       *          Bean's type
       * @param beanType
       *          Bean's type
       * @param annotations
       *          Bean's annotations
       * @return Bean instance or null if no
       */
      public static  T get(final Class beanType, Annotation... annotations)
      {
        return instance().getBean(beanType, annotations);
      }
    
      /**
       * Gets bean instance from context
       * 
       * @param 
       *          Bean's type
       * @param beanType
       *          Bean's type
       * @param annotations
       *          Bean's annotations
       * @return Bean instance or null if no
       */
      public  T getBean(final Class beanType, Annotation... annotations)
      {
        return getBeanFromManager(beanManager, beanType, annotations);
      }
    
      @SuppressWarnings("unchecked")
      private static  T getBeanFromManager(BeanManager beanManager, final Class beanType, Annotation... annotations)
      {
        Set> 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 bean = (Bean)beans.iterator().next();
        final CreationalContext context = beanManager.createCreationalContext(bean);
        return (T)beanManager.getReference(bean, beanType, context);
      }
    
      private static String beansToString(Collection> beans)
      {
        String[] beansLabels = new String[beans.size()];
        int i = 0;
        for (final Bean bean : beans)
        {
          beansLabels[i++] = bean.getName();
        }
    
        return Arrays.toString(beansLabels);
      }
    
    }
    

    Hope this will help those who want to enable CDI injection in their Jersey resources.

    Bye !

    提交回复
    热议问题