{@link DefaultRolloutApprovalStrategy} bean.

@return a new {@link RolloutApprovalStrategy}
432550
@Bean
    @ConditionalOnMissingBean
    RolloutApprovalStrategy rolloutApprovalStrategy(final UserDetailsService userDetailsService,
            final TenantConfigurationManagement tenantConfigurationManagement,
            final SystemSecurityContext systemSecurityContext) {
        return new DefaultRolloutApprovalStrategy(userDetailsService, tenantConfigurationManagement,
                systemSecurityContext);
    }
1114932
public function getDefaultSessionStrategy()
	{
		if ( !$this->defaultSessionStrategy ) {
			$this->defaultSessionStrategy = $this->_sessionStrategyFactory->createStrategy(
				ISessionStrategyFactory::TYPE_ISOLATED
			);
		}

		return $this->defaultSessionStrategy;
	}
5018
public BeanType<ConstraintMappingsType<T>> getOrCreateBean()
   {
      List<Node> nodeList = childNode.get("bean");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new BeanTypeImpl<ConstraintMappingsType<T>>(this, "bean", childNode, nodeList.get(0));
      }
      return createBean();
   }
1358430
protected ContractBean createContractInternal(String organizationId, String clientId,
            String version, NewContractBean bean) throws StorageException, Exception {
        ContractBean contract;
        ClientVersionBean cvb;
        cvb = storage.getClientVersion(organizationId, clientId, version);
        if (cvb == null) {
            throw ExceptionFactory.clientVersionNotFoundException(clientId, version);
        }
        if (cvb.getStatus() == ClientStatus.Retired) {
            throw ExceptionFactory.invalidClientStatusException();
        }
        ApiVersionBean avb = storage.getApiVersion(bean.getApiOrgId(), bean.getApiId(), bean.getApiVersion());
        if (avb == null) {
            throw ExceptionFactory.apiNotFoundException(bean.getApiId());
        }
        if (avb.getStatus() != ApiStatus.Published) {
            throw ExceptionFactory.invalidApiStatusException();
        }
        Set<ApiPlanBean> plans = avb.getPlans();
        String planVersion = null;
        if (plans != null) {
            for (ApiPlanBean apiPlanBean : plans) {
                if (apiPlanBean.getPlanId().equals(bean.getPlanId())) {
                    planVersion = apiPlanBean.getVersion();
                }
            }
        }
        if (planVersion == null) {
            throw ExceptionFactory.planNotFoundException(bean.getPlanId());
        }
        PlanVersionBean pvb = storage.getPlanVersion(bean.getApiOrgId(), bean.getPlanId(), planVersion);
        if (pvb == null) {
            throw ExceptionFactory.planNotFoundException(bean.getPlanId());
        }
        if (pvb.getStatus() != PlanStatus.Locked) {
            throw ExceptionFactory.invalidPlanStatusException();
        }

        contract = new ContractBean();
        contract.setClient(cvb);
        contract.setApi(avb);
        contract.setPlan(pvb);
        contract.setCreatedBy(securityContext.getCurrentUser());
        contract.setCreatedOn(new Date());

        // Move the client to the "Ready" state if necessary.
        if (cvb.getStatus() == ClientStatus.Created && clientValidator.isReady(cvb, true)) {
            cvb.setStatus(ClientStatus.Ready);
        }

        storage.createContract(contract);
        storage.createAuditEntry(AuditUtils.contractCreatedFromClient(contract, securityContext));
        storage.createAuditEntry(AuditUtils.contractCreatedToApi(contract, securityContext));

        // Update the version with new meta-data (e.g. modified-by)
        cvb.setModifiedBy(securityContext.getCurrentUser());
        cvb.setModifiedOn(new Date());
        storage.updateClientVersion(cvb);

        return contract;
    }
985834
public FeatureManager build() {
        Validate.notBlank(name, "No name specified");
        Validate.notNull(featureProvider, "No feature provider specified");
        Validate.notNull(stateRepository, "No state repository specified");
        Validate.notNull(userProvider, "No user provider specified");
        Validate.notNull(strategyProvider, "No activation strategy provider specified");
        return new DefaultFeatureManager(name, featureProvider, stateRepository, userProvider, strategyProvider);
    }
671329
@Override
	public <T extends Endpoint> Strategy<T> create() {
		return new SecureRandomStrategy<T>(broker, preferLocal);
	}
267221
@Override
    public ManagedObject<T> createManagedObject(T existingInstance, ManagedObjectInvocationContext<T> invocationContext) {
        if (existingInstance == null) {
            throw new IllegalArgumentException("Existing instance must not be null");
        }
        return new ManagedObjectImpl<T>(existingInstance);
    }
760100
private static DefaultListableBeanFactory buildListableBeanFactory(Map<String, ?> extraBeans) {
        //new empty context
        final DefaultListableBeanFactory parentBeanFactory = new DefaultListableBeanFactory();  
        
        //Injection of the new beans in the context
        for (String key : extraBeans.keySet()) {
            parentBeanFactory.registerSingleton(key, extraBeans.get(key));
        }
        return parentBeanFactory;
    }
678019
public BackupConfigurationBuilder strategy(BackupConfiguration.BackupStrategy strategy) {
      attributes.attribute(STRATEGY).set(strategy);
      return this;
   }
107654
public final MngSoftware lazyGetMngSoftware() throws Exception {
    String beanName = getMngSoftwareName();
    MngSoftware mngSoftware = (MngSoftware) this.beansMap.get(beanName);
    if (mngSoftware == null) {
      mngSoftware = new MngSoftware();
      mngSoftware.setLogger(lazyGetLogger());
      this.beansMap.put(beanName, mngSoftware);
      lazyGetLogger().info(null, AFactoryAppBeans.class, beanName
        + " has been created.");
    }
    return mngSoftware;
  }
779886
@Override
	public <T extends Endpoint> Strategy<T> create() {
		return new NanoSecRandomStrategy<T>(broker, preferLocal);
	}
979127
@Bean
    @ConditionalOnMissingBean
    DistributionSetTagManagement distributionSetTagManagement(
            final DistributionSetTagRepository distributionSetTagRepository,
            final DistributionSetRepository distributionSetRepository,
            final VirtualPropertyReplacer virtualPropertyReplacer, final NoCountPagingRepository criteriaNoCountDao,
            final JpaProperties properties) {
        return new JpaDistributionSetTagManagement(distributionSetTagRepository, distributionSetRepository,
                virtualPropertyReplacer, criteriaNoCountDao, properties.getDatabase());
    }
993885
@Override
    protected <T> T instantiateClass(Class<T> clazz) throws Throwable {
        // Get the current BeanManager for this module. If one doesn't exist it is because 
        // the module isn't CDI enabled and we fall back to the original behavior.

        ManagedObject<T> mo = null;
        if (releasableFactory != null) {
            mo = releasableFactory.createValidationReleasable(clazz);
        }

        if (mo != null) {
            if (releasables == null) {
                releasables = new LinkedList<ValidationReleasable<?>>();
            }

            // Save off the context under which the class was created as a CDI managed
            // bean so it can be cleaned up upon stopping the module.
            //releasables.add(mo);

            return mo.getObject();
        } else {
            return super.instantiateClass(clazz);
        }
    }
827627
@Override
    protected Map createInstance() {
        if (applicationContext.containsBean(UrlMappingFactoryBean.URL_MAP_BEAN)) {
            Object o = applicationContext.getBean(UrlMappingFactoryBean.URL_MAP_BEAN);
            if (o instanceof Map) {
                mappings.putAll((Map)o);
            }
        }
        if (LOG.isDebugEnabled()) {
            LOG.debug("[UrlMappingFactoryBean] Creating URL mappings as...");
            for (Object key : mappings.keySet()) {
                LOG.debug("[UrlMappingFactoryBean] " + key + "=" + mappings.get(key));
            }
        }
        return mappings;
    }
1169496
public <T, R> FlatMapFunction<T, R> flatMapFunction(Class<? extends FlatMapFunction<T, R>> springBeanClass) {
        return new SpringFlatMapFunction<>(springConfigurationClass, springBeanClass);
    }
1077893
private static DefaultListableBeanFactory createBeanFactory() {
        return new DefaultListableBeanFactory() {
            {
                final InstantiationStrategy is = getInstantiationStrategy();
                setInstantiationStrategy(new InstantiationStrategy() {
                    @Override
                    public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) throws BeansException {
                        return is.instantiate(beanDefinition, beanName, owner);
                    }

                    @Override
                    public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Constructor<?> ctor, Object[] args) throws BeansException {
                        final Object bean = is.instantiate(beanDefinition, beanName, owner, ctor, args);
                        addDependencies(bean, args);
                        return bean;
                    }

                    @Override
                    public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object[] args) throws BeansException {
                        final Object bean = is.instantiate(beanDefinition, beanName, owner, factoryBean, factoryMethod, args);
                        addDependencies(bean, args);
                        return bean;
                    }
                });
            }

            private void addDependencies(Object bean, Object[] args) {
                if (bean instanceof Service) {
                    for (Object arg : args) {
                        if (arg instanceof Service) {
                            ((Service) arg).addDependedBy((Service) bean);
                            ((Service) bean).addDependsOn((Service) arg);
                        }
                    }
                }
            }
        };
    }
1247130
public void createFailure(BeanO beanO)
    {
        //-----------------------------------------------------------
        // If beanO is null then it was never added to the container
        // so we don't need to do anything.
        //-----------------------------------------------------------

        if (beanO != null) {
            EJSContainer.getThreadData().popCallbackBeanO();

            beanO.destroy();
            try {
                container.removeBean(beanO);
            } catch (CSITransactionRolledbackException ex) {
                //---------------------------------------------------
                // If transaction rolled back beanO has already been
                // successfully removed from container.
                //---------------------------------------------------
                FFDCFilter.processException(ex, CLASS_NAME + ".createFailure",
                                            "1732", this);
            }
        }
    }