Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2011, Red Hat, Inc., and individual contributors
   * as indicated by the @author tags. See the copyright.txt file in the
   * distribution for a full listing of individual contributors.
   *
   * 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.jboss.as.webservices.webserviceref;
 
 import java.util.List;
 import java.util.Map;
 
 
 import static org.jboss.as.ee.utils.InjectionUtils.getInjectionTarget;
 import static org.jboss.as.webservices.WSMessages.MESSAGES;
 import static org.jboss.as.webservices.util.ASHelper.getAnnotations;
 import static org.jboss.as.webservices.util.DotNames.WEB_SERVICE_REFS_ANNOTATION;
 import static org.jboss.as.webservices.util.DotNames.WEB_SERVICE_REF_ANNOTATION;

Author(s):
Richard Opalka
WebServiceRef:
annotation processor.
 
 public class WSRefAnnotationProcessor implements DeploymentUnitProcessor {
 
     public void deploy(final DeploymentPhaseContext phaseContextthrows DeploymentUnitProcessingException {
         final DeploymentUnit unit = phaseContext.getDeploymentUnit();
 
         // Process @WebServiceRef annotations
         final List<AnnotationInstancewebServiceRefAnnotations = getAnnotations(unit);
         for (final AnnotationInstance annotation : webServiceRefAnnotations) {
             final AnnotationTarget annotationTarget = annotation.target();
             final WSRefAnnotationWrapper annotationWrapper = new WSRefAnnotationWrapper(annotation);
 
             if (annotationTarget instanceof FieldInfo) {
                 processFieldRef(unitannotationWrapper, (FieldInfoannotationTarget);
             } else if (annotationTarget instanceof MethodInfo) {
                 processMethodRef(unitannotationWrapper, (MethodInfoannotationTarget);
             } else if (annotationTarget instanceof ClassInfo) {
                 processClassRef(unitannotationWrapper, (ClassInfoannotationTarget);
             }
         }
 
         // Process @WebServiceRefs annotations
         final List<AnnotationInstancewebServiceRefsAnnotations = getAnnotations(unit);
         for (final AnnotationInstance outerAnnotation : webServiceRefsAnnotations) {
             final AnnotationTarget annotationTarget = outerAnnotation.target();
             if (annotationTarget instanceof ClassInfo) {
                 final AnnotationInstance[] values = outerAnnotation.value("value").asNestedArray();
                 for (final AnnotationInstance annotation : values) {
                     final WSRefAnnotationWrapper annotationWrapper = new WSRefAnnotationWrapper(annotation);
                     processClassRef(unitannotationWrapper, (ClassInfoannotationTarget);
                 }
             }
         }
    }
    public void undeploy(final DeploymentUnit unit) {
        // NOOP
    }
    private static void processFieldRef(final DeploymentUnit unitfinal WSRefAnnotationWrapper annotationfinal FieldInfo fieldInfothrows DeploymentUnitProcessingException {
        final String fieldName = fieldInfo.name();
        final String injectionType = isEmpty(annotation.type()) || annotation.type().equals(Object.class.getName()) ? fieldInfo.type().name().toString() : annotation.type();
        final InjectionTarget injectionTarget = new FieldInjectionTarget(fieldInfo.declaringClass().name().toString(), fieldNameinjectionType);
        final String bindingName = isEmpty(annotation.name()) ? fieldInfo.declaringClass().name().toString() + "/" + fieldInfo.name() : annotation.name();
        processRef(unitinjectionTypeannotationfieldInfo.declaringClass(), injectionTargetbindingName);
    }
    private static void processMethodRef(final DeploymentUnit unitfinal WSRefAnnotationWrapper annotationfinal MethodInfo methodInfothrows DeploymentUnitProcessingException {
        final String methodName = methodInfo.name();
        if (!methodName.startsWith("set") || methodInfo.args().length != 1) {
            throw .invalidServiceRefSetterMethodName(methodInfo);
        }
        final String injectionType = isEmpty(annotation.type()) || annotation.type().equals(Object.class.getName()) ? methodInfo.args()[0].name().toString() : annotation.type();
        final InjectionTarget injectionTarget = new MethodInjectionTarget(methodInfo.declaringClass().name().toString(), methodNameinjectionType);
        final String bindingName = isEmpty(annotation.name()) ? methodInfo.declaringClass().name().toString() + "/" + methodName.substring(3, 4).toLowerCase(.) + methodName.substring(4) : annotation.name();
        processRef(unitinjectionTypeannotationmethodInfo.declaringClass(), injectionTargetbindingName);
    }
    private static void processClassRef(final DeploymentUnit unitfinal WSRefAnnotationWrapper annotationfinal ClassInfo classInfothrows DeploymentUnitProcessingException {
        if (isEmpty(annotation.name())) {
            throw .requiredServiceRefName();
        }
        if (isEmpty(annotation.type())) {
            throw .requiredServiceRefType();
        }
        processRef(unitannotation.type(), annotationclassInfonullannotation.name());
    }
    private static void processRef(final DeploymentUnit unitfinal String typefinal WSRefAnnotationWrapper annotationfinal ClassInfo classInfofinal InjectionTarget injectionTargetfinal String bindingNamethrows DeploymentUnitProcessingException {
        final EEModuleDescription moduleDescription = unit.getAttachment(.);
        final AnnotatedElement target = createAnnotatedElement(unitclassInfoinjectionTarget);
        final String componentClassName = classInfo.name().toString();
        final Map<StringStringbindingMap = new HashMap<StringString>();
        boolean isEJB = false;
        for (final ComponentDescription componentDescription : moduleDescription.getComponentsByClassName(componentClassName)) {
            if (componentDescription instanceof SessionBeanComponentDescription) {
                isEJB = true;
                bindingMap.put(componentDescription.getComponentName() + "/" + bindingNamebindingName);
            }
        }
        if (!isEJB) {
            bindingMap.put(bindingNamebindingName);
        }
        for (String refKey : bindingMap.keySet()) {
            String refName = bindingMap.get(refKey);
            ManagedReferenceFactory factory = WebServiceReferences.createWebServiceFactory(unittypeannotationtargetrefNamerefKey);
            final EEModuleClassDescription classDescription = moduleDescription.addOrGetLocalClassDescription(classInfo.name().toString());
            // Create the binding from whence our injection comes.
            final InjectionSource serviceRefSource = new FixedInjectionSource(factoryfactory);
            final BindingConfiguration bindingConfiguration = new BindingConfiguration(refNameserviceRefSource);
            classDescription.getBindingConfigurations().add(bindingConfiguration);
            // our injection comes from the local lookup, no matter what.
            final ResourceInjectionConfiguration injectionConfiguration = injectionTarget != null ?
                    new ResourceInjectionConfiguration(injectionTargetnew LookupInjectionSource(refName)) : null;
            if (injectionConfiguration != null) {
                classDescription.addResourceInjection(injectionConfiguration);
            }
        }
    }
    private static AnnotatedElement createAnnotatedElement(final DeploymentUnit unitfinal ClassInfo classInfofinal InjectionTarget injectionTargetthrows DeploymentUnitProcessingException {
        if (injectionTarget == null) {
            return elementForInjectionTarget(unitclassInfo);
        } else {
            return elementForInjectionTarget(unitinjectionTarget);
        }
    }
    private static AnnotatedElement elementForInjectionTarget(final DeploymentUnit unitfinal ClassInfo classInfothrows DeploymentUnitProcessingException {
        final Class<?> target = getClass(classIndexclassInfo.name().toString());
        return target;
    }
    private static AnnotatedElement elementForInjectionTarget(final DeploymentUnit unitfinal InjectionTarget injectionTargetthrows DeploymentUnitProcessingException {
        final Module module = unit.getAttachment(......);
        final DeploymentReflectionIndex deploymentReflectionIndex = unit.getAttachment(......);
        final String injectionTargetClassName = injectionTarget.getClassName();
        final String injectionTargetName = getInjectionTargetName(injectionTarget);
        final AccessibleObject fieldOrMethod = getInjectionTarget(injectionTargetClassNameinjectionTargetNamemodule.getClassLoader(), deploymentReflectionIndex);
        return fieldOrMethod;
    }
    private static String getInjectionTargetName(final InjectionTarget injectionTarget) {
        final String name = injectionTarget.getName();
        if (injectionTarget instanceof FieldInjectionTarget) {
            return name;
        } else if (injectionTarget instanceof MethodInjectionTarget) {
            return name.substring(3, 4).toUpperCase(.) + name.substring(4);
        }
        throw new UnsupportedOperationException();
    }
    private static Class<?> getClass(final DeploymentClassIndex classIndexfinal String classNamethrows DeploymentUnitProcessingException { // TODO: refactor to common code
        if (!isEmpty(className)) {
            try {
                return classIndex.classIndex(className).getModuleClass();
            } catch (ClassNotFoundException e) {
                throw new DeploymentUnitProcessingException(e);
            }
        }
        return null;
    }
    private static boolean isEmpty(final String string) { // TODO: some common class - StringUtils ?
        return string == null || string.isEmpty();
    }
New to GrepCode? Check out our FAQ X