com.byteslounge.cdi.resolver.bean.PropertyResolverBean Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cdi-properties Show documentation
A CDI extension that enables resource bundle injection and resolution in Java EE applications.
There is a newer version: 1.1.1
/*
 * Copyright 2014 byteslounge.com (Gonçalo Marques).
 *
 * 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 com.byteslounge.cdi.resolver.bean;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.enterprise.inject.spi.InjectionPoint;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.byteslounge.cdi.annotation.PropertyBundle;
import com.byteslounge.cdi.annotation.PropertyLocale;
import com.byteslounge.cdi.resolver.PropertyResolverParameter;
import com.byteslounge.cdi.resolver.locale.LocaleResolverFactory;
import com.byteslounge.cdi.resolver.verifier.ParameterIndexVerifier;
import com.byteslounge.cdi.resolver.verifier.ResolverMethodParametersVerifier;
import com.byteslounge.cdi.utils.ValidationUtils;

/**
 * The bean which holds the reference to the property resolver instance and the
 * respective property resolver method, along with all the required metadata for
 * the resolver method invocation.
 * 
 * @author Gonçalo Marques
 * @since 1.0.0
 */
public class PropertyResolverBean {

    private final AnnotatedMethod propertyResolverMethod;
    private final BeanManager beanManager;
    private Object propertyResolverInstance;
    private List propertyResolverParameters;
    private final int resolverLocaleParameterIndex;
    private final int resolverBundlenameParameterIndex;
    private static final Logger logger = LoggerFactory.getLogger(PropertyResolverBean.class);

    public PropertyResolverBean(AnnotatedMethod propertyResolverMethod, BeanManager beanManager) {
        this.propertyResolverMethod = propertyResolverMethod;
        this.beanManager = beanManager;
        this.resolverLocaleParameterIndex = checkResolverParameter(PropertyLocale.class);
        this.resolverBundlenameParameterIndex = checkResolverParameter(PropertyBundle.class);
        ValidationUtils.validateResolverMethod(Arrays.asList(new ParameterIndexVerifier(resolverLocaleParameterIndex, resolverBundlenameParameterIndex),
                new ResolverMethodParametersVerifier(propertyResolverMethod, resolverLocaleParameterIndex, resolverBundlenameParameterIndex)));
    }

    /**
     * Initializes the property resolver bean instance and resolver method,
     * along with all method parameters which are eligible for CDI injection.
     */
    public void initializePropertyResolverBean() {
        Class resolverMethodClass = propertyResolverMethod.getJavaMember().getDeclaringClass();
        Set> beans = beanManager.getBeans(resolverMethodClass);
        Bean propertyResolverBean = beanManager.resolve(beans);
        CreationalContext creationalContext = beanManager.createCreationalContext(propertyResolverBean);
        propertyResolverInstance = beanManager.getReference(propertyResolverBean, resolverMethodClass, creationalContext);

        propertyResolverParameters = new ArrayList<>();

        int startIndex = 1;
        if (resolverLocaleParameterIndex > -1) {
            if (logger.isDebugEnabled()) {
                logger.debug("Resolver method expects Locale parameter at index " + resolverLocaleParameterIndex);
            }
            startIndex++;
        }
        if (resolverBundlenameParameterIndex > -1) {
            if (logger.isDebugEnabled()) {
                logger.debug("Resolver method expects Bundle Name parameter at index " + resolverBundlenameParameterIndex);
            }
            startIndex++;
        }

        int currentIndex = 0;
        for (final AnnotatedParameter parameter : propertyResolverMethod.getParameters()) {
            if (currentIndex++ < startIndex) {
                continue;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Resolver method expects parameter of type " + ((Class) parameter.getBaseType()).getSimpleName() + " at index " + currentIndex);
            }
            propertyResolverParameters.add(new PropertyResolverParameter(parameter, beanManager, propertyResolverBean));
        }
    }

    /**
     * Resolves a property to be injected into a CDI managed bean field.
     * 
     * @param key
     *            The property key to be resolved
     * @param bundleName
     *            The resource bundle name to which the property being resolved
     *            belongs to
     * @param ctx
     *            The CDI creational context
     * @return The resolved property
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     */
    public String resolveProperty(String key, String bundleName, CreationalContext ctx) throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        List