Example usage for org.springframework.beans.factory BeanNameAware interface-usage

List of usage examples for org.springframework.beans.factory BeanNameAware interface-usage

  1. HOME
  2. Java
  3. org.springframework.beans.factory.*
  4. BeanNameAware
  5. Example usage for org.springframework.beans.factory BeanNameAware interface-usage

Introduction

In this page you can find the example usage for org.springframework.beans.factory BeanNameAware interface-usage.

Usage

From source file org.springframework.jca.endpoint.AbstractMessageEndpointFactory.java

/**
 * Abstract base implementation of the JCA 1.7
 * {@link javax.resource.spi.endpoint.MessageEndpointFactory} interface,
 * providing transaction management capabilities as well as ClassLoader
 * exposure for endpoint invocations.
 *

From source file com.azaptree.services.executor.ThreadPoolExecutor.java

@Component
@ManagedResource
public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor
        implements PausableThreadPoolExecutor, BeanNameAware, ThreadPoolExecutorJmxApi {
    private String name;

From source file com.devbury.desktoplib.spring.LogFilterPropertyPlaceholderConfigurer.java

public class LogFilterPropertyPlaceholderConfigurer implements BeanFactoryPostProcessor, BeanNameAware {

    protected List<String> filters = new LinkedList<String>();
    protected String requiredPrefix = "${";
    protected String optionalPrefix = "${opt:";
    protected String defaultPrefix = "${default:";

From source file org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.java

/**
 * JavaBean that allows for configuring a JDK 1.5 {@link java.util.concurrent.ThreadPoolExecutor}
 * in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
 * properties), exposing it as a Spring {@link org.springframework.core.task.TaskExecutor}.
 * This is an alternative to configuring a ThreadPoolExecutor instance directly using
 * constructor injection, with a separate {@link ConcurrentTaskExecutor} adapter wrapping it.

From source file org.springframework.scheduling.backportconcurrent.ScheduledExecutorFactoryBean.java

/**
 * {@link org.springframework.beans.factory.FactoryBean} that sets up
 * a JSR-166 backport
 * {@link edu.emory.mathcs.backport.java.util.concurrent.ScheduledExecutorService}
 * (by default:
 * {@link edu.emory.mathcs.backport.java.util.concurrent.ScheduledThreadPoolExecutor}

From source file org.dkpro.lab.engine.impl.DefaultTaskContextFactory.java

public class DefaultTaskContextFactory implements BeanNameAware, TaskContextFactory {
    private final Log log = LogFactory.getLog(getClass());

    private final Map<String, TaskContext> contexts;
    private StorageService storageService;
    private LoggingService loggingService;

From source file org.tradex.tx.GenericJCAConnector.java

/**
 * <p>Title: GenericJCAConnector</p>
 * <p>Description: </p> 
 * <p>Company: Helios Development Group LLC</p>
 * @author Whitehead (nwhitehead AT heliosdev DOT org)
 * <p><code>org.tradex.tx.GenericJCAConnector</code></p>

From source file org.springmodules.workflow.jbpm30.LocalJbpmSessionFactoryBean.java

/**
 * FactoryBean that creates a local jBPM SessionFactory instance. Behaves like a SessionFactory instance when used as bean reference, 
 * e.g. for JbpmTemplate's "sessionFactory" property. Note that switching to JndiObjectFactoryBean is just a matter of configuration!
 * <p/>
 * Due to the nature of jbpm 3.0.x architecture and the lack of interfaces for core components, this factoryBean will create subclasses of jbpmSessionFactory
 * and jbpmSession in order to allow Spring transaction and session management.

From source file org.appverse.web.framework.backend.ecm.cmis.CmisSessionFactoryBean.java

/**
 * Factory bean that allows to setup an Open CMIS session as a Spring bean.
 * Take into account that this factory will only be useful for static sessions creation
 * meaning you know the user and password to connect to the repository, for instance.
 * Take into account that Open CMIS sessions are per repository and per user as they use caches.
 * The recommendation is to create a session per different user and then to reuse them always as possible.

From source file com.icfcc.cache.ehcache.EhCacheFactoryBean.java

/**
 * {@link FactoryBean} that creates a named EHCache {@link net.sf.ehcache.Cache} instance
 * (or a decorator that implements the {@link net.sf.ehcache.Ehcache} interface),
 * representing a cache region within an EHCache {@link net.sf.ehcache.CacheManager}.
 *
 * <p>If the specified named cache is not configured in the cache configuration descriptor,