Java RequestScoped類代碼示例

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Produces
@RequestScoped
@Named("userPrincipal")
public UserPrincipal producePrincipal() {
    Object principal = SecurityUtils.getSubject().getPrincipal();
    UserPrincipal result = null;
    if (principal instanceof UserPrincipal) {

        result = (UserPrincipal) principal;
    }
    /*
    FIXME
    if (principal instanceof SystemAccountPrincipal) {
        SystemAccountPrincipal systemAccountPrincipal = (SystemAccountPrincipal) principal;
        String identifier = systemAccountPrincipal.getIdentifier();
        result = new UserPrincipal(identifier);
    }
    */
    if (principal == null) {
        result = new UserPrincipal();
    }
    return result;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Override
public ScopeMetadata resolveScopeMetadata(final BeanDefinition definition) {

    if (definition instanceof AnnotatedBeanDefinition) {
        final AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) definition;
        final ScopeMetadata metadata = new ScopeMetadata();
        final Set<String> annotationTypes = beanDefinition.getMetadata().getAnnotationTypes();

        if (annotationTypes.contains(RequestScoped.class
            .getName())) {
            metadata.setScopeName("request");
            metadata.setScopedProxyMode(ScopedProxyMode.TARGET_CLASS);
        } else if (annotationTypes
            .contains(ApplicationScoped.class.getName())) {
            metadata.setScopeName("singleton");
        } else {
            return super.resolveScopeMetadata(definition);
        }
        return metadata;
    } else {
        return super.resolveScopeMetadata(definition);
    }
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
void applyBeforeFeatureConfig(Class testClass) {
    CdiContainer container = CdiContainerLoader.getCdiContainer();

    if (!isContainerStarted()) {
        container.boot(CdiTestSuiteRunner.getTestContainerConfig());
        containerStarted = true;
        bootExternalContainers(testClass);
    }

    List<Class<? extends Annotation>> restrictedScopes = new ArrayList<Class<? extends Annotation>>();

    //controlled by the container and not supported by weld:
    restrictedScopes.add(ApplicationScoped.class);
    restrictedScopes.add(Singleton.class);

    if (this.parent == null && this.testControl.getClass().equals(TestControlLiteral.class)) {
        //skip scope-handling if @TestControl isn't used explicitly on the test-class -> TODO re-visit it
        restrictedScopes.add(RequestScoped.class);
        restrictedScopes.add(SessionScoped.class);
    }

    this.previousProjectStage = ProjectStageProducer.getInstance().getProjectStage();
    ProjectStageProducer.setProjectStage(this.projectStage);

    startScopes(container, testClass, null, restrictedScopes.toArray(new Class[restrictedScopes.size()]));
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Produces
@RequestScoped
public BlazeStorage createClient() {
	URI uri = URI.create(httpServletRequest.getRequestURL().toString());
	String contextPath = httpServletRequest.getContextPath();
	String basePath = "/api";
	
	if (contextPath != null) {
		basePath = contextPath + basePath;
	}
	
	try {
		uri = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), basePath, null, null);
    } catch (URISyntaxException x) {
        throw new IllegalArgumentException(x.getMessage(), x);
    }
	
	return BlazeStorageClient.getInstance(uri.toString());
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Produces
@Named("storageQuotaPlanItems")
@RequestScoped
public List<SelectItem> getStorageQuotaPlanItems() {
	List<StorageQuotaModelListElementRepresentation> quotaModels = storage.storageQuotaModels().get();
	List<SelectItem> quotaModelPlanItems = new ArrayList<>(quotaModels.size());
	
	for (StorageQuotaModelListElementRepresentation quotaModel : quotaModels) {
		SelectItemGroup group = new SelectItemGroup(quotaModel.getName());
		List<SelectItem> groupItems = new ArrayList<>(quotaModel.getLimits().size());
		
		for (Integer limit : quotaModel.getLimits()) {
			groupItems.add(new SelectItem(new StorageQuotaPlanChoiceRepresentation(quotaModel.getId(), limit), limit + " GB"));
		}
		
		group.setSelectItems(groupItems.toArray(new SelectItem[groupItems.size()]));
		quotaModelPlanItems.add(group);
	}
	
	return quotaModelPlanItems;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Override
protected void releaseResources() {
    for (Listener l : listenerList) {
        try {
            l.onDestroy(this);
        } catch (Exception e) {
            warn(e, "error calling listener onDestroy method");
        }
    }
    Destroyable.Util.destroyAll(destroyableList, RequestScoped.class);
    Destroyable.Util.tryDestroyAll(attributes.values(), RequestScoped.class);
    this.attributes.clear();
    this.renderArgs.clear();
    this.template = null;
    this.app = null;
    this.template = null;
    this.listenerList.clear();
    this.destroyableList.clear();
    this.violations.clear();
    // note we can't destroy progress as it might still be used
    // by background thread
    //this.progress.destroy();
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
public Class<? extends Annotation> scope() {
    if (null == scope) {
        synchronized (this) {
            if (null == scope) {
                Class<?> c = getClass();
                if (c.isAnnotationPresent(RequestScoped.class)) {
                    scope = RequestScoped.class;
                } else if (c.isAnnotationPresent(SessionScoped.class)) {
                    scope = SessionScoped.class;
                } else if (c.isAnnotationPresent(ApplicationScoped.class)) {
                    scope = ApplicationScoped.class;
                } else {
                    scope = NormalScope.class;
                }
            }
        }
    }
    return scope;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@AroundInvoke
public Object startRequestScope(final InvocationContext ctx) throws Exception {
    Object result = null;
    ContextControl contextControl = null;
    if(!isRequestScopeActive()) {
        contextControl = CDI.current().select(ContextControl.class).get();
        contextControl.startContext(RequestScoped.class);
    }
    try {
        result = ctx.proceed();
    }
    finally {
        if(contextControl != null) {
            contextControl.stopContext(RequestScoped.class);
        }
    }
    return result;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Test(priority = 3)
public void testRequestScopedBeanPerformance() throws InterruptedException
{
    final SimpleRequestScopedBeanWithoutInterceptor underTest = getInstance(cdiContainer.getBeanManager(), SimpleRequestScopedBeanWithoutInterceptor.class);
    final ContextControl contextControl = cdiContainer.getContextControl();
    contextControl.startContext(RequestScoped.class);
    Assert.assertEquals(underTest.theMeaningOfLife(), 42);
    contextControl.stopContext(RequestScoped.class);

    executeInParallel("invocation on @RequestScoped bean", new Runnable()
    {

        @Override
        public void run()
        {
            contextControl.startContext(RequestScoped.class);
            for (int i = 0; i < NUM_ITERATION; i++)
            {
                // this line does the actual bean invocation.
                underTest.theMeaningOfLife();
            }
            contextControl.stopContext(RequestScoped.class);
        }
    });
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
/**
 * Provides an EntityManager for this Model.
 *
 * @return new EntityManager
 */
@Override
@RequestScoped
public EntityManager provide() {
  // hk2
  final EntityManager instance = getEntityManager();

  if (closeableService != null) {
    closeableService.add(new Closeable() {
      @Override
      public void close() throws IOException {
        dispose(instance);
      }
    });
  }
  return instance;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
/**
 * Checks if a custom resolver method injected parameter scope is {@link Dependent}
 * 
 * @param type
 *            The parameter type being checked
 * @return Returns true if the paraeter scope is {@link Dependent}
 */
private boolean checkDependentScope(Class<?> type) {
    for (Annotation annotation : type.getAnnotations()) {
        if (annotation.annotationType().equals(SessionScoped.class) || annotation.annotationType().equals(RequestScoped.class)
                || annotation.annotationType().equals(ApplicationScoped.class)) {
            return false;
        }
        Class<?> viewScopedClass = null;
        try {
            // Account for JEE 7 @ViewScoped scope
            viewScopedClass = Class.forName("javax.faces.view.ViewScoped");
        } catch (Exception e) {
            // JEE 6 environment
            if (logger.isDebugEnabled()) {
                logger.debug("Class javax.faces.view.ViewScoped was not found: Running in a Java EE 6 environment.");
            }
        }
        if (viewScopedClass != null) {
            if (annotation.annotationType().equals(viewScopedClass)) {
                return false;
            }
        }
    }
    return true;
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
public void beforeStopApplication(Object endObject)
{
    WebBeansContext webBeansContext = getWebBeansContext();
    ContextsService contextsService = webBeansContext.getContextsService();
    contextsService.endContext(Singleton.class, null);
    contextsService.endContext(ApplicationScoped.class, null);
    contextsService.endContext(RequestScoped.class, null);
    contextsService.endContext(SessionScoped.class, mockHttpSession);

    ELContextStore elStore = ELContextStore.getInstance(false);
    if (elStore == null)
    {
        return;
    }
    elStore.destroyELContextStore();
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
/**
 * {@inheritDoc}
 */
@Override
public void requestInitialized(final ServletRequestEvent event) {
    final Object oldContext = ThreadSingletonServiceImpl.enter(this.webBeansContext);
    if (event != null) {
        event.getServletRequest().setAttribute(contextKey, oldContext);
    }

    try {
        if (logger.isDebugEnabled()) {
            logger.debug("Starting a new request : [{0}]", event == null ? "null" : event.getServletRequest().getRemoteAddr());
        }

        if (webBeansContext instanceof WebappWebBeansContext) { // start before child
            ((WebappWebBeansContext) webBeansContext).getParent().getContextsService().startContext(RequestScoped.class, event);
        }
        contextsService.startContext(RequestScoped.class, event);

        // we don't initialise the Session here but do it lazily if it gets requested
        // the first time. See OWB-457

    } catch (final Exception e) {
        logger.error(OWBLogConst.ERROR_0019, event == null ? "null" : event.getServletRequest());
        WebBeansUtil.throwRuntimeExceptions(e);
    }
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Override
public void startContext(Class<? extends Annotation> scopeClass)
{
    if (scopeClass.isAssignableFrom(ApplicationScoped.class))
    {
        startApplicationScope();
    }
    else if (scopeClass.isAssignableFrom(SessionScoped.class))
    {
        startSessionScope();
    }
    else if (scopeClass.isAssignableFrom(RequestScoped.class))
    {
        startRequestScope();
    }
    else if (scopeClass.isAssignableFrom(ConversationScoped.class))
    {
        startConversationScope(null);
    }
}
 

import javax.enterprise.context.RequestScoped; //導入依賴的package包/類
@Override
public void contextEntered(final ThreadContext oldContext, final ThreadContext newContext) {

    final BeanContext beanContext = newContext.getBeanContext();

    final WebBeansContext webBeansContext = beanContext.getModuleContext().getAppContext().getWebBeansContext();
    if (webBeansContext == null) {
        return;
    }

    final ContextsService contextsService = webBeansContext.getContextsService();

    final Context requestContext = CdiAppContextsService.class.cast(contextsService).getRequestContext(false);

    if (requestContext == null) {
        contextsService.startContext(RequestScoped.class, CdiAppContextsService.EJB_REQUEST_EVENT);
        newContext.set(DestroyContext.class, new DestroyContext(contextsService, newContext));
    }
}