org.jboss.weld.el.AbstractWeldELResolver Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of weld-osgi-bundle Show documentation
Weld runtime packaged as an OSGi bundle
There is a newer version: 6.0.0.Beta4
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2008, Red Hat, Inc., and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * Licensed 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.jboss.weld.el;

import org.jboss.weld.bean.proxy.ClientProxyProvider;
import org.jboss.weld.manager.BeanManagerImpl;
import org.slf4j.cal10n.LocLogger;

import javax.el.ELContext;
import javax.el.ELResolver;
import javax.enterprise.context.Dependent;
import javax.enterprise.inject.spi.Bean;
import java.beans.FeatureDescriptor;
import java.lang.annotation.Annotation;
import java.util.Iterator;

import static org.jboss.weld.logging.Category.EL;
import static org.jboss.weld.logging.LoggerFactory.loggerFactory;
import static org.jboss.weld.logging.messages.ElMessage.PROPERTY_LOOKUP;
import static org.jboss.weld.logging.messages.ElMessage.PROPERTY_RESOLVED;

/**
 * An EL-resolver against the named beans
 *
 * @author Pete Muir
 */
public abstract class AbstractWeldELResolver extends ELResolver {
    private static final LocLogger log = loggerFactory().getLogger(EL);

    protected abstract BeanManagerImpl getManager(ELContext context);

    @Override
    public Class getCommonPropertyType(ELContext context, Object base) {
        return null;
    }

    @Override
    public Iterator getFeatureDescriptors(ELContext context, Object base) {
        return null;
    }

    @Override
    public Class getType(ELContext context, Object base, Object property) {
        return null;
    }

    @Override
    public Object getValue(final ELContext context, Object base, Object property) {
        BeanManagerImpl beanManager = getManager(context);
        if (property != null) {
            String propertyString = property.toString();
            log.trace(PROPERTY_LOOKUP, propertyString);
            Namespace namespace = null;
            if (base == null) {
                if (beanManager.getRootNamespace().contains(propertyString)) {
                    Object value = beanManager.getRootNamespace().get(propertyString);
                    context.setPropertyResolved(true);
                    log.trace(PROPERTY_RESOLVED, propertyString, value);
                    return value;
                }
            } else if (base instanceof Namespace) {
                namespace = (Namespace) base;
                // We're definitely the responsible party
                context.setPropertyResolved(true);
                if (namespace.contains(propertyString)) {
                    // There is a child namespace
                    Object value = namespace.get(propertyString);
                    log.trace(PROPERTY_RESOLVED, propertyString, value);
                    return value;
                }
            } else {
                // let the standard EL resolver chain handle the property
                return null;
            }
            final String name;
            if (namespace != null) {
                // Try looking in the manager for a bean
                name = namespace.qualifyName(propertyString);
            } else {
                name = propertyString;
            }
            Object value = lookup(beanManager, context, name);
            if (value != null) {
                context.setPropertyResolved(true);
                log.trace(PROPERTY_RESOLVED, propertyString, value);
                return value;
            }
        }
        return null;
    }

    private Object lookup(BeanManagerImpl beanManager, ELContext context, String name) {
        final Bean bean = beanManager.resolve(beanManager.getBeans(name));
        if (bean == null) {
            return null;
        }
        Class scope = bean.getScope();
        if (!scope.equals(Dependent.class)) {
            ClientProxyProvider cpp = beanManager.getClientProxyProvider();
            if (cpp != null) {
                Object value = cpp.getClientProxy(bean);
                if (value != null) {
                    return value;
                }
            }
            return beanManager.getReference(bean, beanManager.createCreationalContext(bean), false);
        } else {
            // Need to use a "special" creationalContext that can make sure that we do share dependent instances referenced by the EL Expression
            final ELCreationalContextStack stack = ELCreationalContextStack.getCreationalContextStore(context);
            boolean release = stack.isEmpty(); // indicates whether we should cleanup after lookup or not
            if (release) {
                stack.push(new CreationalContextCallable());
            }
            try {
                ELCreationalContext ctx = stack.peek().get();
                String beanName = bean.getName();
                Object value = ctx.getDependentInstanceForExpression(beanName);
                if (value == null) {
                    value = getManager(context).getReference(bean, ctx, false);
                    ctx.registerDependentInstanceForExpression(beanName, value);
                }
                return value;
            } finally {
                if (release) {
                    CreationalContextCallable callable = stack.pop();
                    if (callable.exists()) {
                        callable.get().release();
                    }
                }
            }

        }
    }

    @Override
    public boolean isReadOnly(ELContext context, Object base, Object property) {
        return false;
    }

    @Override
    public void setValue(ELContext context, Object base, Object property, Object value) {
    }
}