/*
* Copyright (C) 2013 eXo Platform SAS.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.exoplatform.container.spring;
import org.exoplatform.commons.utils.SecurityHelper;
import org.exoplatform.container.AbstractComponentAdapter;
import org.exoplatform.container.AbstractInterceptor;
import org.exoplatform.container.configuration.ConfigurationManager;
import org.exoplatform.container.spi.ComponentAdapter;
import org.exoplatform.container.spi.ContainerException;
import org.exoplatform.container.spi.Interceptor;
import org.exoplatform.container.xml.Component;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.AutowireCandidateQualifier;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import java.lang.annotation.Annotation;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.inject.Named;
/**
* The implementation of an {@link Interceptor} allowing eXo Kernel to interact with a spring container
*
* @author <a href="mailto:nfilotto@exoplatform.com">Nicolas Filotto</a>
* @version $Id$
*
*/
public class SpringContainer extends AbstractInterceptor
{
/**
* The serial version UID
*/
private static final long serialVersionUID = -4841328894117928913L;
/**
* The logger
*/
private static final Log LOG = ExoLogger
.getLogger("exo.kernel.container.ext.provider.impl.spring.v3.SpringContainer");
/**
* The Spring {@link ApplicationContext}
*/
private ApplicationContext ctx;
/**
* {@inheritDoc}
*/
@Override
public <T> T getComponentInstance(Object componentKey, Class<T> bindType, boolean autoRegistration)
{
T result = super.getComponentInstance(componentKey, bindType, autoRegistration);
if (ctx != null && result == null)
{
if (componentKey instanceof Class<?> && !((Class<?>)componentKey).isAnnotation())
{
return bindType.cast(getInstanceOfType((Class<?>)componentKey));
}
else if (!(componentKey instanceof String) && !(componentKey instanceof Class<?>))
{
return null;
}
String beanName = keyToBeanName(componentKey);
if (ctx.containsBean(beanName) && bindType.isAssignableFrom(ctx.getType(beanName)))
{
return bindType.cast(ctx.getBean(beanName));
}
String[] names = ctx.getBeanNamesForType(bindType);
if (names != null && names.length > 0)
{
for (int i = 0, length = names.length; i < length; i++)
{
String name = names[i];
if (componentKey instanceof String)
{
Named n = ctx.findAnnotationOnBean(name, Named.class);
if (n != null && componentKey.equals(n.value()))
{
return bindType.cast(ctx.getBean(name));
}
}
else
{
@SuppressWarnings("unchecked")
Annotation a = ctx.findAnnotationOnBean(name, (Class<? extends Annotation>)componentKey);
if (a != null)
{
return bindType.cast(ctx.getBean(name));
}
}
}
}
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
public <T> T getComponentInstanceOfType(final Class<T> componentType, boolean autoRegistration)
{
T result = super.getComponentInstanceOfType(componentType, autoRegistration);
if (ctx != null && result == null)
{
result = getInstanceOfType(componentType);
}
return result;
}
private <T> T getInstanceOfType(final Class<T> componentType)
{
T result;
PrivilegedAction<T> action = new PrivilegedAction<T>()
{
public T run()
{
String name = classToBeanName(componentType);
if (ctx.containsBean(name) && componentType.isAssignableFrom(ctx.getType(name)))
{
return componentType.cast(ctx.getBean(name));
}
String[] names = ctx.getBeanNamesForType(componentType);
if (names != null && names.length > 0)
{
return componentType.cast(ctx.getBean(names[0]));
}
return null;
}
};
result = SecurityHelper.doPrivilegedAction(action);
return result;
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
@Override
public <T> ComponentAdapter<T> getComponentAdapter(Object componentKey, Class<T> bindType, boolean autoRegistration)
{
ComponentAdapter<?> result = super.getComponentAdapter(componentKey, bindType, autoRegistration);
if (ctx != null && result == null)
{
if (componentKey instanceof Class<?> && !((Class<?>)componentKey).isAnnotation())
{
return getAdapterOfType(bindType);
}
else if (!(componentKey instanceof String) && !(componentKey instanceof Class<?>))
{
return null;
}
String beanName = keyToBeanName(componentKey);
if (ctx.containsBean(beanName) && bindType.isAssignableFrom(ctx.getType(beanName)))
{
return createComponentAdapter(bindType, beanName);
}
String[] names = ctx.getBeanNamesForType(bindType);
if (names != null && names.length > 0)
{
for (int i = 0, length = names.length; i < length; i++)
{
String name = names[i];
if (componentKey instanceof String)
{
Named n = ctx.findAnnotationOnBean(name, Named.class);
if (n != null && componentKey.equals(n.value()))
{
return createComponentAdapter(bindType, name);
}
}
else
{
Annotation a = ctx.findAnnotationOnBean(name, (Class<? extends Annotation>)componentKey);
if (a != null)
{
return createComponentAdapter(bindType, name);
}
}
}
}
}
return (ComponentAdapter<T>)result;
}
/**
* {@inheritDoc}
*/
@Override
public <T> ComponentAdapter<T> getComponentAdapterOfType(Class<T> componentType, boolean autoRegistration)
{
ComponentAdapter<T> result = super.getComponentAdapterOfType(componentType, autoRegistration);
if (ctx != null && result == null)
{
result = getAdapterOfType(componentType);
}
return result;
}
private <T> ComponentAdapter<T> getAdapterOfType(Class<T> componentType)
{
String name = classToBeanName(componentType);
if (ctx.containsBean(name) && componentType.isAssignableFrom(ctx.getType(name)))
{
return createComponentAdapter(componentType, name);
}
String[] names = ctx.getBeanNamesForType(componentType);
if (names != null && names.length > 0)
{
return createComponentAdapter(componentType, names[0]);
}
return null;
}
private <T> ComponentAdapter<T> createComponentAdapter(final Class<T> type, final String name)
{
return new AbstractComponentAdapter<T>(type, type)
{
/**
* The serial UID
*/
private static final long serialVersionUID = -4625398501079851570L;
public T getComponentInstance() throws ContainerException
{
return type.cast(ctx.getBean(name));
}
public boolean isSingleton()
{
return ctx.isSingleton(name);
}
};
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
@Override
public <T> List<ComponentAdapter<T>> getComponentAdaptersOfType(Class<T> componentType)
{
List<ComponentAdapter<T>> result = super.getComponentAdaptersOfType(componentType);
if (ctx != null)
{
result = new ArrayList<ComponentAdapter<T>>(result);
String[] names = ctx.getBeanNamesForType(componentType);
if (names != null)
{
for (int i = 0, length = names.length; i < length; i++)
{
String name = names[i];
result.add((ComponentAdapter<T>)createComponentAdapter(ctx.getType(name), name));
}
}
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
public <T> List<T> getComponentInstancesOfType(Class<T> componentType) throws ContainerException
{
List<T> result = super.getComponentInstancesOfType(componentType);
if (ctx != null)
{
result = new ArrayList<T>(result);
result.addAll(ctx.getBeansOfType(componentType).values());
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
@SuppressWarnings({"rawtypes", "unchecked"})
public void start()
{
ConfigurationManager cm = super.getComponentInstanceOfType(ConfigurationManager.class, false);
// We check if the component has been defined in the configuration of the current container
// The goal is to enable the SpringContainer only if it is needed
Component component = cm.getComponent(ApplicationContextProvider.class);
if (component == null)
{
if (LOG.isDebugEnabled())
{
LOG.debug("No ApplicationContextProvider has been defined, thus the SpringContainer will be disabled."
+ " To enable the Spring Integration please define an ApplicationContextProvider");
}
}
else
{
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
Collection<ComponentAdapter<?>> adapters = delegate.getComponentAdapters();
for (ComponentAdapter<?> adapter : adapters)
{
Object key = adapter.getComponentKey();
String name = keyToBeanName(key);
String factoryName = name + "#factory";
RootBeanDefinition def =
new RootBeanDefinition(adapter.getComponentImplementation(), AbstractBeanDefinition.AUTOWIRE_NO, false);
def.setScope(BeanDefinition.SCOPE_PROTOTYPE);
def.setFactoryBeanName(factoryName);
def.setFactoryMethodName("getInstance");
def.setLazyInit(true);
def.setTargetType(adapter.getComponentImplementation());
if (key instanceof String)
{
def.addQualifier(new AutowireCandidateQualifier(Named.class, key));
}
else if (key instanceof Class<?> && ((Class<?>)key).isAnnotation())
{
def.addQualifier(new AutowireCandidateQualifier((Class<?>)key));
}
else
{
def.setPrimary(true);
}
bf.registerBeanDefinition(name, def);
bf.registerSingleton(factoryName, new ComponentAdapterFactoryBean(adapter));
}
GenericApplicationContext parentContext = new GenericApplicationContext(bf);
parentContext.refresh();
ApplicationContextProvider provider =
super.getComponentInstanceOfType(ApplicationContextProvider.class, false);
ctx = provider.getApplicationContext(parentContext);
LOG.info("A SpringContainer has been enabled using the ApplicationContextProvider " + provider.getClass());
}
super.start();
}
/**
* {@inheritDoc}
*/
@Override
public void stop()
{
super.stop();
if (ctx instanceof DisposableBean)
{
try
{
((DisposableBean)ctx).destroy();
}
catch (Exception e)
{
LOG.warn("Could not destroy the container: " + e.getMessage());
}
finally
{
ctx = null;
}
}
}
private static String classToBeanName(Class<?> type)
{
return type.getName();
}
private static String keyToBeanName(Object key)
{
if (key instanceof Class<?>)
{
return classToBeanName((Class<?>)key);
}
else
{
if (key instanceof String)
{
return (String)key;
}
else
{
return classToBeanName(key.getClass());
}
}
}
/**
* {@inheritDoc}
*/
public String getId()
{
return "SpringIntegration";
}
static class ComponentAdapterFactoryBean<T>
{
private final ComponentAdapter<T> adapter;
private ComponentAdapterFactoryBean(ComponentAdapter<T> adapter)
{
this.adapter = adapter;
}
public T getInstance() throws Exception
{
return adapter.getComponentInstance();
}
}
}