public CommonAnnotationBeanPostProcessor() 
{
	                   	 
		setOrder(Ordered.LOWEST_PRECEDENCE - 3);
		setInitAnnotationType(PostConstruct.class);
		setDestroyAnnotationType(PreDestroy.class);
		ignoreResourceType("javax.xml.ws.WebServiceContext");
}

Create a new CommonAnnotationBeanPostProcessor, with the init and destroy annotation types set to javax.annotation.PostConstruct and javax.annotation.PreDestroy , respectively.

 protected Object autowireResource(BeanFactory factory,
    CommonAnnotationBeanPostProcessor.LookupElement element,
    String requestingBeanName) throws BeansException 
{
		Object resource = null;
		Set< String > autowiredBeanNames = null;
		String name = element.name;
		if (this.fallbackToDefaultTypeMatch && element.isDefaultName &&
				factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) {
			autowiredBeanNames = new LinkedHashSet< String >();
			resource = ((AutowireCapableBeanFactory) factory).resolveDependency(
					element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null);
		}
		else {
			resource = factory.getBean(name, element.lookupType);
			autowiredBeanNames = Collections.singleton(name);
		}
		if (factory instanceof ConfigurableBeanFactory) {
			ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
			for (String autowiredBeanName : autowiredBeanNames) {
				beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
			}
		}
		return resource;
}

Obtain a resource object for the given name and type through autowiring based on the given factory.

 protected Object getResource(CommonAnnotationBeanPostProcessor.LookupElement element,
    String requestingBeanName) throws BeansException 
{
		if (StringUtils.hasLength(element.mappedName)) {
			return this.jndiFactory.getBean(element.mappedName, element.lookupType);
		}
		if (this.alwaysUseJndiLookup) {
			return this.jndiFactory.getBean(element.name, element.lookupType);
		}
		if (this.resourceFactory == null) {
			throw new NoSuchBeanDefinitionException(element.lookupType,
					"No resource factory configured - specify the 'resourceFactory' property");
		}
		return autowireResource(this.resourceFactory, element, requestingBeanName);
}

Obtain the resource object for the given name and type.

 public  void ignoreResourceType(String resourceType) 
{
		Assert.notNull(resourceType, "Ignored resource type must not be null");
		this.ignoredResourceTypes.add(resourceType);
}

Ignore the given resource type when resolving @Resource annotations.

By default, the javax.xml.ws.WebServiceContext interface will be ignored, since it will be resolved by the JAX-WS runtime.

 public boolean postProcessAfterInstantiation(Object bean,
    String beanName) throws BeansException 
{
		InjectionMetadata metadata = findResourceMetadata(bean.getClass());
		try {
			metadata.injectFields(bean, beanName);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of resource fields failed", ex);
		}
		return true;
}

 public Object postProcessBeforeInstantiation(Class beanClass,
    String beanName) throws BeansException 
{
		return null;
}

 public  void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
    Class beanType,
    String beanName) 
{
		super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
		if (beanType != null) {
			InjectionMetadata metadata = findResourceMetadata(beanType);
			metadata.checkConfigMembers(beanDefinition);
		}
}

 public PropertyValues postProcessPropertyValues(PropertyValues pvs,
    PropertyDescriptor[] pds,
    Object bean,
    String beanName) throws BeansException 
{
		InjectionMetadata metadata = findResourceMetadata(bean.getClass());
		try {
			metadata.injectMethods(bean, beanName, pvs);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of resource methods failed", ex);
		}
		return pvs;
}

 public  void setAlwaysUseJndiLookup(boolean alwaysUseJndiLookup) 
{
		this.alwaysUseJndiLookup = alwaysUseJndiLookup;
}

Set whether to always use JNDI lookups equivalent to standard Java EE 5 resource injection, even for name attributes and default names.

Default is "false": Resource names are used for Spring bean lookups in the containing BeanFactory; only mappedName attributes point directly into JNDI. Switch this flag to "true" for enforcing Java EE style JNDI lookups in any case, even for name attributes and default names.

 public  void setBeanFactory(BeanFactory beanFactory) throws BeansException 
{
		Assert.notNull(beanFactory, "BeanFactory must not be null");
		this.beanFactory = beanFactory;
		if (this.resourceFactory == null) {
			this.resourceFactory = beanFactory;
		}
}

 public  void setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch) 
{
		this.fallbackToDefaultTypeMatch = fallbackToDefaultTypeMatch;
}

Set whether to allow a fallback to a type match if no explicit name has been specified. The default name (i.e. the field name or bean property name) will still be checked first; if a bean of that name exists, it will be taken. However, if no bean of that name exists, a by-type resolution of the dependency will be attempted if this flag is "true".

Default is "true". Switch this flag to "false" in order to enforce a by-name lookup in all cases, throwing an exception in case of no name match.

 public  void setJndiFactory(BeanFactory jndiFactory) 
{
		Assert.notNull(jndiFactory, "BeanFactory must not be null");
		this.jndiFactory = jndiFactory;
}

Specify the factory for objects to be injected into @Resource / @WebServiceRef / @EJB annotated fields and setter methods, for mappedName attributes that point directly into JNDI. This factory will also be used if "alwaysUseJndiLookup" is set to "true" in order to enforce JNDI lookups even for name attributes and default names.

The default is a org.springframework.jndi.support.SimpleJndiBeanFactory for JNDI lookup behavior equivalent to standard Java EE 5 resource injection.

 public  void setResourceFactory(BeanFactory resourceFactory) 
{
		Assert.notNull(resourceFactory, "BeanFactory must not be null");
		this.resourceFactory = resourceFactory;
}

Specify the factory for objects to be injected into @Resource / @WebServiceRef / @EJB annotated fields and setter methods, for name attributes and default names.

The default is the BeanFactory that this post-processor is defined in, if any, looking up resource names as Spring bean names. Specify the resource factory explicitly for programmatic usage of this post-processor.

Specifying Spring's org.springframework.jndi.support.SimpleJndiBeanFactory leads to JNDI lookup behavior equivalent to standard Java EE 5 resource injection, even for name attributes and default names. This is the same behavior that the "alwaysUseJndiLookup" flag enables.