How to use

BeanProvider

in

org.apache.deltaspike.core.api.provider

Set<Bean<?>> beans = beanManager.getBeans(name);
return getContextualReference(type, beanManager, beans);

public static <T> DependentProvider<T> getDependent(String name)
{
  BeanManager beanManager = getBeanManager();
  return getDependent(beanManager, name);
}

  @Override
  public WeblinkMatcher createWeblinkMatcher(Map<String, ? extends Object> properties) {
    return BeanProvider.injectFields(new DefaultWeblinkMatcher());
  }
}

/**
 * Get a set of {@link Bean} definitions by type independent of the qualifier.
 *
 * @param type the type of the bean in question
 * @param optional if <code>true</code> it will return an empty set if no bean could be found.
 *                 Otherwise it will throw an {@code IllegalStateException}
 * @param includeDefaultScopedBeans specifies if dependent scoped beans should be included in the result
 * @param <T> target type
 * @return the resolved set of {@link Bean} definitions or an empty-set if optional is true
 */
public static <T> Set<Bean<T>> getBeanDefinitions(Class<T> type,
                         boolean optional,
                         boolean includeDefaultScopedBeans)
{
  BeanManager beanManager = getBeanManager();
  
  return getBeanDefinitions(type, optional, includeDefaultScopedBeans, beanManager);
}

@Override
protected void onInit() {
  super.onInit();
  securityDataProvider = BeanProvider.getContextualReference(SecurityDataProvider.class);
  config = BeanProvider.getContextualReference(OctopusConfig.class);
  twoStepConfig = BeanProvider.getContextualReference(TwoStepConfig.class);
  codecUtil = BeanProvider.getContextualReference(CodecUtil.class);
  octopusDefinedAuthenticationInfoList = BeanProvider.getContextualReferences(OctopusDefinedAuthenticationInfo.class, false);
  octopusDefinedAuthorizationInfoList = BeanProvider.getContextualReferences(OctopusDefinedAuthorizationInfo.class, false);
  setCachingEnabled(true);
  setAuthenticationTokenClass(AuthenticationToken.class);
  setPermissionResolver(BeanProvider.getContextualReference(OctopusPermissionResolver.class));
}

  private static <T> T getContextualReference(BeanManager beanManager, Class<T> type)
  {
    Set<Bean<?>> beans = beanManager.getBeans(type);

    if (beans == null || beans.isEmpty())
    {
      return null;
    }

    Bean<?> bean = beanManager.resolve(beans);

    CreationalContext<?> creationalContext = beanManager.createCreationalContext(bean);

    @SuppressWarnings({ "unchecked", "UnnecessaryLocalVariable" })
    T result = (T) beanManager.getReference(bean, type, creationalContext);

    if (bean.getScope().equals(Dependent.class))
    {
      AbstractBeanStorage beanStorage = BeanProvider.getContextualReference(RequestDependentBeanStorage.class);

      //noinspection unchecked
      beanStorage.add(new DependentBeanEntry(result, bean, creationalContext));
    }

    return result;
  }
}

@Override
protected Object createTest() throws Exception
{
  BeanManager beanManager = BeanManagerProvider.getInstance().getBeanManager();
  Class<?> type = getTestClass().getJavaClass();
  Set<Bean<?>> beans = beanManager.getBeans(type);
  Object result;
  if (!USE_TEST_CLASS_AS_CDI_BEAN || beans == null || beans.isEmpty())
  {
    result = super.createTest();
    BeanProvider.injectFields(result); //fallback to simple injection
  }
  else
  {
    Bean<Object> bean = (Bean<Object>) beanManager.resolve(beans);
    CreationalContext<Object> creationalContext = beanManager.createCreationalContext(bean);
    result = beanManager.getReference(bean, type, creationalContext);
  }
  return result;
}

private EntityViewDelegateQueryHandler lookup(EntityViewCdiQueryInvocationContext context) {
  Bean<EntityViewDelegateQueryHandler> selectedBean = lookupCache.get(context.getMethod());
  if (selectedBean == null) {
    Set<Bean<EntityViewDelegateQueryHandler>> beans = BeanProvider
        .getBeanDefinitions(EntityViewDelegateQueryHandler.class, true, true);
    for (Bean<EntityViewDelegateQueryHandler> bean : beans) {
      if (ClassUtils.containsPossiblyGenericMethod(bean.getBeanClass(), context.getMethod())) {
        selectedBean = bean;
      }
    }
    if (selectedBean != null) {
      lookupCache.put(context.getMethod(), selectedBean);
    }
  }
  if (selectedBean != null) {
    CreationalContext<EntityViewDelegateQueryHandler> cc = beanManager.createCreationalContext(selectedBean);
    EntityViewDelegateQueryHandler instance = (EntityViewDelegateQueryHandler) beanManager.getReference(
        selectedBean, EntityViewDelegateQueryHandler.class, cc);
    if (selectedBean.getScope().equals(Dependent.class)) {
      context.addDestroyable(new BeanDestroyable<EntityViewDelegateQueryHandler>(selectedBean, instance, cc));
    }
    return instance;
  }
  return null;
}

Flash flash = facesContext.getExternalContext().getFlash();
  if (facesContext.getViewRoot() != null)
    viewId = facesContext.getViewRoot().getViewId();
    viewId = BeanProvider.getContextualReference(ViewConfigResolver.class)

public static Set<RequestParameter> getViewConfigPageParameters()
{
  ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();
  Set<RequestParameter> result = new HashSet<RequestParameter>();
  if (externalContext == null || //detection of early config for different mojarra versions
      externalContext.getRequestParameterValuesMap() == null || externalContext.getRequest() == null)
  {
    return result;
  }
  NavigationParameterContext navigationParameterContext =
      BeanProvider.getContextualReference(NavigationParameterContext.class);
  for (Map.Entry<String, String> entry : navigationParameterContext.getPageParameters().entrySet())
  {
    //TODO add multi-value support
    result.add(new RequestParameter(entry.getKey(), new String[]{entry.getValue()}));
  }
  return result;
}

  @Override
  public void processAction(ActionEvent actionEvent)
  {
    if (this.activated)
    {
      ViewConfigDescriptor viewConfigDescriptor = BeanProvider.getContextualReference(ViewConfigResolver.class)
          .getViewConfigDescriptor(FacesContext.getCurrentInstance().getViewRoot().getViewId());

      ViewControllerUtils.executeViewControllerCallback(viewConfigDescriptor, PreViewAction.class);
    }

    this.wrapped.processAction(actionEvent);
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void notify(final ExceptionEvent<T> event, BeanManager beanManager) throws Exception
{
  CreationalContext<?> ctx = null;
  try
  {
    ctx = beanManager.createCreationalContext(null);
    @SuppressWarnings("unchecked")
    Object handlerInstance = BeanProvider.getContextualReference(declaringBeanClass);
    InjectableMethod<?> im = createInjectableMethod(handler, getDeclaringBean(), beanManager);
    im.invoke(handlerInstance, ctx, new OutboundParameterValueRedefiner(event, this));
  }
  finally
  {
    if (ctx != null)
    {
      ctx.release();
    }
  }
}

UIViewRoot originalViewRoot = context.getViewRoot();
context.setViewRoot(result);
      BeanProvider.getContextualReference(ViewRootAccessHandler.class);
  ViewConfigResolver viewConfigResolver = BeanProvider.getContextualReference(ViewConfigResolver.class);
      BeanProvider.getContextualReference(JsfModuleConfig.class)
        .isAlwaysUseNavigationHandlerOnSecurityViolation())
    if (!context.isPostback() && context.getViewRoot() != null)
      context.getViewRoot().setViewId(null);

private void checkSecuredView(FacesContext facesContext)
{
  if (!this.securityModuleActivated)
  {
    return;
  }
  try
  {
    BeanProvider.getContextualReference(ViewRootAccessHandler.class).checkAccessTo(facesContext.getViewRoot());
  }
  catch (ErrorViewAwareAccessDeniedException accessDeniedException)
  {
    SecurityUtils.tryToHandleSecurityViolation(accessDeniedException);
    facesContext.renderResponse();
  }
}

ClientWindow clientWindow = BeanProvider.getContextualReference(ClientWindow.class);
if (!facesContext.getResponseComplete() && !"default".equals(windowId))
  facesContext.getExternalContext().setClientWindow(new ClientWindowAdapter(clientWindow));

BeanManager beanManager = getBeanManager();
Set<Bean<?>> beans = beanManager.getBeans(name);
return getContextualReference(type, beanManager, beans);

public static void tryToRestoreMessages(FacesContext facesContext)
{
  JsfModuleConfig jsfModuleConfig = BeanProvider.getContextualReference(JsfModuleConfig.class);
  if (!jsfModuleConfig.isAlwaysKeepMessages())
  {
    return;
  }
  try
  {
    WindowMetaData windowMetaData = BeanProvider.getContextualReference(WindowMetaData.class);
    @SuppressWarnings({ "unchecked" })
    List<FacesMessageEntry> facesMessageEntryList = windowMetaData.getFacesMessageEntryList();
    List<FacesMessage> originalMessageList = new ArrayList<FacesMessage>(facesContext.getMessageList());
    if (facesMessageEntryList != null)
    {
      for (FacesMessageEntry messageEntry : facesMessageEntryList)
      {
        if (isNewMessage(originalMessageList, messageEntry.getFacesMessage()))
        {
          facesContext.addMessage(messageEntry.getComponentId(), messageEntry.getFacesMessage());
        }
      }
      facesMessageEntryList.clear();
    }
  }
  catch (ContextNotActiveException e)
  {
    //TODO discuss how we handle it
  }
}

  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException
  {
    Class<? extends Runnable> jobClass =
      ClassUtils.tryToLoadClassForName(context.getJobDetail().getKey().getName(), Runnable.class);

    Runnable runnableBean = BeanProvider.getContextualReference(jobClass);

    try
    {
      runnableBean.run();
    }
    catch (Throwable t)
    {
      //just in this case to reduce the implementation(s) of runnable (annotated with @Scheduled)
      //to an absolute minimum.
      //(custom implementations of org.quartz.Job need to do it on their own)
      this.beanManager.fireEvent(new ExceptionToCatchEvent(t));
    }
  }
}

public void init(InvocationContext context) {
  if (config == null) {
    // WLS12C doesn't inject into interceptors
    config = BeanProvider.getContextualReference(OctopusConfig.class);
    infoProducer = BeanProvider.getContextualReference(SecurityViolationInfoProducer.class);
    annotationAuthorizationChecker = BeanProvider.getContextualReference(AnnotationAuthorizationChecker.class);
  }
}

public QueryInOutMapper<?> getQueryInOutMapperInstance(EntityViewCdiQueryInvocationContext context) {
  if (!hasQueryInOutMapper()) {
    return null;
  }
  QueryInOutMapper<?> result = null;
  lazyInit();
  if (!queryInOutMapperIsNormalScope) {
    final DependentProvider<? extends QueryInOutMapper<?>> mappedProvider = BeanProvider.getDependent(mapper);
    result = mappedProvider.get();
    context.addDestroyable(new DependentProviderDestroyable(mappedProvider));
  } else {
    result = BeanProvider.getContextualReference(mapper);
  }
  return result;
}