org.wicketstuff.javaee.injection.JavaEEProxyFieldValueFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of wicketstuff-javaee-inject Show documentation
There is a newer version: 10.3.0
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wicketstuff.javaee.injection;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.concurrent.ConcurrentHashMap;

import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.ejb.Stateful;
import javax.persistence.PersistenceUnit;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.wicket.injection.IFieldValueFactory;
import org.apache.wicket.proxy.IProxyTargetLocator;
import org.apache.wicket.proxy.LazyInitProxyFactory;
import org.apache.wicket.request.cycle.RequestCycle;
import org.wicketstuff.javaee.EntityManagerFactoryLocator;
import org.wicketstuff.javaee.JavaEEBeanLocator;
import org.wicketstuff.javaee.JndiObjectLocator;
import org.wicketstuff.javaee.naming.IJndiNamingStrategy;
import org.wicketstuff.javaee.naming.StandardJndiNamingStrategy;

/**
 * {@link IFieldValueFactory} that creates proxies of EJBs based on the {@link javax.ejb.EJB}
 * annotation applied to a field.
 * 
 * @author Filippo Diotalevi
 */
public class JavaEEProxyFieldValueFactory implements IFieldValueFactory
{

	private final ConcurrentHashMap cache = new ConcurrentHashMap();
	private final IJndiNamingStrategy namingStrategy;

	/**
	 * Constructor
	 */
	public JavaEEProxyFieldValueFactory()
	{
		this(new StandardJndiNamingStrategy());
	}

	/**
	 * Constructor
	 * 
	 * @param namingStrategy
	 *            - naming strategy
	 */
	public JavaEEProxyFieldValueFactory(IJndiNamingStrategy namingStrategy)
	{
		this.namingStrategy = namingStrategy;
	}

	/**
	 * @see org.apache.wicket.injection.IFieldValueFactory#getFieldValue(java.lang.reflect.Field,
	 *      java.lang.Object)
	 */
	@Override
	public Object getFieldValue(Field field, Object fieldOwner)
	{
		IProxyTargetLocator locator = getProxyTargetLocator(field);
		return getCachedProxy(field, locator);
	}

	/**
	 * @see org.apache.wicket.injection.IFieldValueFactory#supportsField(java.lang.reflect.Field)
	 */
	@Override
	public boolean supportsField(Field field)
	{
		return field.isAnnotationPresent(EJB.class) || field.isAnnotationPresent(Resource.class) ||
			field.isAnnotationPresent(PersistenceUnit.class);
	}

	/**
	 * Gets the corresponding object (or its proxy) for the field from the cache, or if it's not
	 * cached, then returns a newly created proxy or the object itself.
	 * 
	 * @param field
	 *            The field, in which we're trying to inject
	 * @param locator
	 *            The locator, which will locate the corresponding object for the field
	 * @return The injectable value
	 */
	private Object getCachedProxy(Field field, IProxyTargetLocator locator)
	{
		Class type = field.getType();
		if (locator == null)
		{
			return null;
		}

		// if the field contains the "stateful" description, or the field itself
		// is a no-interfaceview Stateful bean
		if ((field.isAnnotationPresent(EJB.class) &&
			field.getAnnotation(EJB.class).description().equals("stateful") || field.getType()
			.isAnnotationPresent(Stateful.class)))
		{
			// creates a session if there wasn't already

			HttpServletRequest httpServletRequest = (HttpServletRequest)RequestCycle.get()
				.getRequest()
				.getContainerRequest();

			HttpSession session = httpServletRequest.getSession();

			// check if it's already cached
			Object retValue = session.getAttribute(type.getName());
			if (retValue == null)
			{
				if (!Modifier.isFinal(type.getModifiers()))
				{
					retValue = LazyInitProxyFactory.createProxy(type, locator);
				}
				else
				{
					retValue = locator.locateProxyTarget();
				}
				session.setAttribute(type.getName(), retValue);
			}
			return retValue;
		}
		else
		{

			if (cache.containsKey(locator))
			{
				return cache.get(locator);
			}
			if (!Modifier.isFinal(type.getModifiers()))
			{
				Object proxy = LazyInitProxyFactory.createProxy(type, locator);
				cache.put(locator, proxy);
				return proxy;
			}
			else
			{
				Object value = locator.locateProxyTarget();
				cache.put(locator, value);
				return value;
			}
		}
	}

	private IProxyTargetLocator getProxyTargetLocator(Field field)
	{
		if (field.isAnnotationPresent(EJB.class))
		{
			return new JavaEEBeanLocator(field.getAnnotation(EJB.class).name(), field.getType(),
				namingStrategy);
		}

		if (field.isAnnotationPresent(PersistenceUnit.class))
		{
			return new EntityManagerFactoryLocator(field.getAnnotation(PersistenceUnit.class)
				.unitName());
		}

		if (field.isAnnotationPresent(Resource.class))
		{
			return new JndiObjectLocator(field.getAnnotation(Resource.class).name(),
				field.getType());
		}
		// else
		return null;
	}
}