Example usage for org.springframework.beans.factory.support GenericBeanDefinition setLazyInit

List of usage examples for org.springframework.beans.factory.support GenericBeanDefinition setLazyInit

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. GenericBeanDefinition
  6. setLazyInit

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support GenericBeanDefinition setLazyInit.

Prototype

@Override
public void setLazyInit(boolean lazyInit)

Source Link

Document

Set whether this bean should be lazily initialized.

Usage

From source file:com.github.steveash.spring.WiringFactoryBeanFactoryPostProcessor.java

private void addPrototypeDef(ConfigurableListableBeanFactory beanFactory, String beanDefName,
        Class<?> protoBeanClass) {
    String beanName = getPrototypeBeanNameFromBeanClass(protoBeanClass);
    if (beanFactory.containsBeanDefinition(beanName)) {
        throw new BeanDefinitionValidationException("Trying to register a bean definition for a synthetic "
                + "prototype bean with name " + beanName + " due to the bean factory of name " + beanDefName
                + " but a bean with this name already exists!");
    }//from  w w w  .j a  va 2s. co m

    GenericBeanDefinition protoBean = new GenericBeanDefinition();
    protoBean.setLazyInit(true);
    protoBean.setBeanClass(protoBeanClass);
    protoBean.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    protoBean.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
    protoBean.setBeanClassName(protoBeanClass.getName());

    log.debug("Dynamically adding prototype bean {} from factory {}", beanName, beanDefName);
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    registry.registerBeanDefinition(beanName, protoBean);
}

From source file:com.techtrip.spring.beans.factory.ContextAwareBeanFactory.java

/**
 * Register bean.// ww  w .  j  av  a  2 s . c  o  m
 *
 * @param beanToRegister the bean to register
 * @param beanName the bean name
 * @param scope the scope
 * @param setLazyInit the set lazy init
 * @param setAutowireCandidate the set autowire candidate
 */
public void registerBean(Class<?> beanToRegister, String beanName, String scope /* "session" */,
        boolean setLazyInit, boolean setAutowireCandidate) {
    GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
    beanDefinition.setBeanClass(beanToRegister);
    beanDefinition.setLazyInit(setLazyInit);
    beanDefinition.setAbstract(false);
    beanDefinition.setAutowireCandidate(setAutowireCandidate);
    beanDefinition.setScope(scope);

    registry.registerBeanDefinition(beanName, beanDefinition);
}

From source file:guru.qas.martini.annotation.StepsAnnotationProcessorTest.java

@Test(expectedExceptions = FatalBeanException.class)
public void testNonSingletonSteps() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("emptyContext.xml");
    ConfigurableListableBeanFactory factory = context.getBeanFactory();

    GenericBeanDefinition definition = new GenericBeanDefinition();
    definition.setBeanClass(DuplicateGivenBeanA.class);
    definition.setLazyInit(false);
    definition.setScope("prototype");

    BeanDefinitionRegistry registry = BeanDefinitionRegistry.class.cast(factory);
    registry.registerBeanDefinition(DuplicateGivenBeanA.class.getName(), definition);
    process(context, new DuplicateGivenBeanA());
}

From source file:org.jfaster.mango.plugin.spring.MangoDaoScanner.java

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;
    for (Class<?> daoClass : findMangoDaoClasses()) {
        GenericBeanDefinition bf = new GenericBeanDefinition();
        bf.setBeanClassName(daoClass.getName());
        MutablePropertyValues pvs = bf.getPropertyValues();
        pvs.addPropertyValue("daoClass", daoClass);
        bf.setBeanClass(factoryBeanClass);
        bf.setPropertyValues(pvs);/*from   w w w  . j  ava 2 s.  co  m*/
        bf.setLazyInit(false);
        dlbf.registerBeanDefinition(daoClass.getName(), bf);
    }
}

From source file:com.fitbur.jestify.junit.spring.IntegrationTestReifier.java

@Override
public Object reifyCut(CutDescriptor cutDescriptor, Object[] arguments) {
    return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        try {// w ww. j a  v  a2 s . c om
            Cut cut = cutDescriptor.getCut();
            Field field = cutDescriptor.getField();
            Type fieldType = field.getGenericType();
            String fieldName = field.getName();

            field.setAccessible(true);

            Constructor<?> constructor = cutDescriptor.getConstructor();
            constructor.setAccessible(true);

            ResolvableType resolver = ResolvableType.forType(fieldType);

            Class rawType;

            if (resolver.hasGenerics()) {
                if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                    rawType = resolver.getRawClass();
                } else {
                    rawType = resolver.resolve();
                }
            } else {
                rawType = resolver.resolve();
            }

            Module module = testInstance.getClass().getDeclaredAnnotation(Module.class);

            GenericBeanDefinition bean = new GenericBeanDefinition();
            bean.setBeanClass(rawType);
            bean.setAutowireCandidate(false);
            bean.setScope(SCOPE_PROTOTYPE);
            bean.setPrimary(true);
            bean.setLazyInit(true);
            bean.setRole(RootBeanDefinition.ROLE_APPLICATION);
            bean.setAutowireMode(RootBeanDefinition.AUTOWIRE_NO);
            appContext.registerBeanDefinition(fieldName, bean);
            if (module != null) {
                appContext.register(module.value());
            }
            appContext.refresh();

            Object instance = appContext.getBean(fieldName, arguments);

            if (cut.value()) {
                instance = spy(instance);
            }

            field.set(testInstance, instance);

            return instance;
        } catch (SecurityException | IllegalAccessException | IllegalArgumentException e) {
            throw new RuntimeException(e);
        }
    });
}

From source file:com.fitbur.testify.di.spring.SpringServiceLocator.java

@Override
public void addService(ServiceDescriptor descriptor) {
    checkState(!context.containsBeanDefinition(descriptor.getName()),
            "Service with the name '%s' already exists.", descriptor.getName());

    GenericBeanDefinition bean = new GenericBeanDefinition();
    bean.setBeanClass(descriptor.getType());
    bean.setAutowireCandidate(descriptor.getDiscoverable());
    bean.setPrimary(descriptor.getPrimary());
    bean.setLazyInit(descriptor.getLazy());
    bean.setRole(ROLE_APPLICATION);/*from  w w w  . j  av  a 2  s.  co m*/

    if (descriptor.getInjectable()) {
        bean.setAutowireMode(AUTOWIRE_CONSTRUCTOR);
    } else {
        bean.setAutowireMode(AUTOWIRE_NO);
        ConstructorArgumentValues values = new ConstructorArgumentValues();

        Object[] arguments = descriptor.getArguments();
        for (int i = 0; i < arguments.length; i++) {
            Object arg = arguments[i];

            if (arg == null) {
                //TODO: warn user that the argument was not specified and there
                //for the real instance will be injected.
                continue;
            }

            values.addIndexedArgumentValue(i, arg);
        }

        bean.setConstructorArgumentValues(values);
    }

    ServiceScope scope = descriptor.getScope();
    switch (scope) {
    case PROTOTYPE:
        bean.setScope("prototype");
        break;
    case SINGLETON:
        bean.setScope("singleton");
        break;
    case REQUEST:
        bean.setScope("request");
        break;
    case SESSION:
        bean.setScope("session");
        break;
    case APPLICATION:
        bean.setScope("application");
        break;
    default:
        checkState(false, "Scope '{}' is not supported by Spring IoC.", scope.name());

    }
    DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getBeanFactory();
    beanFactory.registerBeanDefinition(descriptor.getName(), bean);
}

From source file:com.dianping.avatar.cache.spring.CacheBeanDefinitionParser.java

/**
 * Register {@link XMLCacheClientFactory} definition
 *//*from  ww  w .  j av  a  2 s  .com*/
private void registerDefaultCacheClientFactory(BeanDefinitionRegistry beanDefinitionRegistry) {
    GenericBeanDefinition definition = new GenericBeanDefinition();
    definition.setBeanClass(RemoteCacheClientFactory.class);
    definition.setLazyInit(true);
    MutablePropertyValues propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("configurationWebService",
            new RuntimeBeanReference(CACHE_CONFIGURATION_WEB_SERVICE_ID));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, DEFAULT_CACHE_CLIENT_FACTORY_ID), beanDefinitionRegistry);
}

From source file:com.dianping.avatar.cache.spring.CacheBeanDefinitionParser.java

/**
 * @param parserContext/*from  ww w .j ava2  s  .  co  m*/
 * @param serviceName TODO
 * @param serviceInterface TODO
 */
private void registerCacheWebService(BeanDefinitionRegistry beanDefinitionRegistry, String beanName,
        String serviceName, String serviceInterface, boolean isOneWay) {
    GenericBeanDefinition definition = new GenericBeanDefinition();
    definition.setBeanClassName("com.dianping.dpsf.spring.ProxyBeanFactory");
    definition.setLazyInit(true);
    definition.setInitMethodName("init");
    MutablePropertyValues propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("serviceName", serviceName);
    propertyValues.addPropertyValue("iface", serviceInterface);
    propertyValues.addPropertyValue("serialize", "hessian");
    propertyValues.addPropertyValue("callMethod", isOneWay ? "oneway" : "sync");
    propertyValues.addPropertyValue("timeout", "10000");
    propertyValues.addPropertyValue("hosts", getRemoteService());
    BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(definition, beanName),
            beanDefinitionRegistry);
}

From source file:com.dianping.avatar.cache.spring.CacheBeanDefinitionParser.java

/**
 * @param parserContext//from   w  w  w  .j a v a  2  s  .  co  m
 * 
 */
private void registerDefaultCacheItemConfigManager(BeanDefinitionRegistry beanDefinitionRegistry) {
    GenericBeanDefinition definition = new GenericBeanDefinition();
    definition.setBeanClass(RemoteCacheItemConfigManager.class);
    // lazy init because default CacheItemConfigManager is not required
    definition.setLazyInit(true);
    MutablePropertyValues propertyValues = definition.getPropertyValues();
    propertyValues.addPropertyValue("configurationWebService",
            new RuntimeBeanReference(CACHE_CONFIGURATION_WEB_SERVICE_ID));
    BeanDefinitionReaderUtils.registerBeanDefinition(
            new BeanDefinitionHolder(definition, DEFAULT_ITEM_CONFIG_MANAGER_ID), beanDefinitionRegistry);
}

From source file:org.eclipse.gemini.blueprint.extender.internal.blueprint.activator.BlueprintContainerProcessor.java

public void preProcessRefresh(final ConfigurableOsgiBundleApplicationContext context) {
    final BundleContext bundleContext = context.getBundleContext();
    // create the ModuleContext adapter
    final BlueprintContainer blueprintContainer = createBlueprintContainer(context);

    // 1. add event listeners
    // add service publisher
    context.addApplicationListener(new BlueprintContainerServicePublisher(blueprintContainer, bundleContext));
    // add waiting event broadcaster
    context.addApplicationListener(new BlueprintWaitingEventDispatcher(context.getBundleContext()));

    // 2. add environmental managers
    context.addBeanFactoryPostProcessor(new BeanFactoryPostProcessor() {

        private static final String BLUEPRINT_BUNDLE = "blueprintBundle";
        private static final String BLUEPRINT_BUNDLE_CONTEXT = "blueprintBundleContext";
        private static final String BLUEPRINT_CONTAINER = "blueprintContainer";
        private static final String BLUEPRINT_EXTENDER = "blueprintExtenderBundle";
        private static final String BLUEPRINT_CONVERTER = "blueprintConverter";

        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            // lazy logger evaluation
            Log logger = LogFactory.getLog(context.getClass());

            if (!(beanFactory instanceof BeanDefinitionRegistry)) {
                logger.warn("Environmental beans will be registered as singletons instead "
                        + "of usual bean definitions since beanFactory " + beanFactory
                        + " is not a BeanDefinitionRegistry");
            }// www  .jav  a2 s.c  o m

            // add blueprint container bean
            addPredefinedBlueprintBean(beanFactory, BLUEPRINT_BUNDLE, bundleContext.getBundle(), logger);
            addPredefinedBlueprintBean(beanFactory, BLUEPRINT_BUNDLE_CONTEXT, bundleContext, logger);
            addPredefinedBlueprintBean(beanFactory, BLUEPRINT_CONTAINER, blueprintContainer, logger);
            // addPredefinedBlueprintBean(beanFactory, BLUEPRINT_EXTENDER, extenderBundle, logger);
            addPredefinedBlueprintBean(beanFactory, BLUEPRINT_CONVERTER,
                    new SpringBlueprintConverter(beanFactory), logger);

            // add Blueprint conversion service
            // String[] beans = beanFactory.getBeanNamesForType(BlueprintConverterConfigurer.class, false, false);
            // if (ObjectUtils.isEmpty(beans)) {
            // beanFactory.addPropertyEditorRegistrar(new BlueprintEditorRegistrar());
            // }
            beanFactory.setConversionService(
                    new SpringBlueprintConverterService(beanFactory.getConversionService(), beanFactory));
        }

        private void addPredefinedBlueprintBean(ConfigurableListableBeanFactory beanFactory, String beanName,
                Object value, Log logger) {
            if (!beanFactory.containsLocalBean(beanName)) {
                logger.debug("Registering pre-defined bean named " + beanName);
                if (beanFactory instanceof BeanDefinitionRegistry) {
                    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

                    GenericBeanDefinition def = new GenericBeanDefinition();
                    def.setBeanClass(ENV_FB_CLASS);
                    ConstructorArgumentValues cav = new ConstructorArgumentValues();
                    cav.addIndexedArgumentValue(0, value);
                    def.setConstructorArgumentValues(cav);
                    def.setLazyInit(false);
                    def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                    registry.registerBeanDefinition(beanName, def);

                } else {
                    beanFactory.registerSingleton(beanName, value);
                }

            } else {
                logger.warn("A bean named " + beanName
                        + " already exists; aborting registration of the predefined value...");
            }
        }
    });

    // 3. add cycle breaker
    context.addBeanFactoryPostProcessor(cycleBreaker);

    BlueprintEvent creatingEvent = new BlueprintEvent(BlueprintEvent.CREATING, context.getBundle(),
            extenderBundle);
    listenerManager.blueprintEvent(creatingEvent);
    dispatcher.beforeRefresh(creatingEvent);
}