Examples with SessionBeanMetaData org.jboss.metadata.ejb.spec.SessionBeanMetaData used on opensource projects

Example 6 with SessionBeanMetaData

use of org.jboss.metadata.ejb.spec.SessionBeanMetaData in project wildfly by wildfly.

the class DeploymentDescriptorMethodProcessor method handleSessionBean.

private void handleSessionBean(final EJBComponentDescription component, final Module module, final DeploymentReflectionIndex reflectionIndex) throws ClassNotFoundException, DeploymentUnitProcessingException {
    if (component.getDescriptorData() == null) {
        return;
    }
    final Class<?> componentClass = ClassLoadingUtils.loadClass(component.getComponentClassName(), module);
    final EnterpriseBeanMetaData metaData = component.getDescriptorData();
    AroundInvokesMetaData aroundInvokes = null;
    if (metaData instanceof SessionBeanMetaData) {
        aroundInvokes = ((SessionBeanMetaData) metaData).getAroundInvokes();
    } else if (metaData instanceof MessageDrivenBeanMetaData) {
        aroundInvokes = ((MessageDrivenBeanMetaData) metaData).getAroundInvokes();
    }
    if (aroundInvokes != null) {
        for (AroundInvokeMetaData aroundInvoke : aroundInvokes) {
            final InterceptorClassDescription.Builder builder = InterceptorClassDescription.builder();
            String methodName = aroundInvoke.getMethodName();
            MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifier(Object.class, methodName, InvocationContext.class);
            builder.setAroundInvoke(methodIdentifier);
            if (aroundInvoke.getClassName() == null || aroundInvoke.getClassName().isEmpty()) {
                final String className = ClassReflectionIndexUtil.findRequiredMethod(reflectionIndex, componentClass, methodIdentifier).getDeclaringClass().getName();
                component.addInterceptorMethodOverride(className, builder.build());
            } else {
                component.addInterceptorMethodOverride(aroundInvoke.getClassName(), builder.build());
            }
        }
    }
    // post-construct(s) of the interceptor configured (if any) in the deployment descriptor
    LifecycleCallbacksMetaData postConstructs = metaData.getPostConstructs();
    if (postConstructs != null) {
        for (LifecycleCallbackMetaData postConstruct : postConstructs) {
            final InterceptorClassDescription.Builder builder = InterceptorClassDescription.builder();
            String methodName = postConstruct.getMethodName();
            MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifier(void.class, methodName);
            builder.setPostConstruct(methodIdentifier);
            if (postConstruct.getClassName() == null || postConstruct.getClassName().isEmpty()) {
                final String className = ClassReflectionIndexUtil.findRequiredMethod(reflectionIndex, componentClass, methodIdentifier).getDeclaringClass().getName();
                component.addInterceptorMethodOverride(className, builder.build());
            } else {
                component.addInterceptorMethodOverride(postConstruct.getClassName(), builder.build());
            }
        }
    }
    // pre-destroy(s) of the interceptor configured (if any) in the deployment descriptor
    final LifecycleCallbacksMetaData preDestroys = metaData.getPreDestroys();
    if (preDestroys != null) {
        for (final LifecycleCallbackMetaData preDestroy : preDestroys) {
            final InterceptorClassDescription.Builder builder = InterceptorClassDescription.builder();
            final String methodName = preDestroy.getMethodName();
            final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifier(void.class, methodName);
            builder.setPreDestroy(methodIdentifier);
            if (preDestroy.getClassName() == null || preDestroy.getClassName().isEmpty()) {
                final String className = ClassReflectionIndexUtil.findRequiredMethod(reflectionIndex, componentClass, methodIdentifier).getDeclaringClass().getName();
                component.addInterceptorMethodOverride(className, builder.build());
            } else {
                component.addInterceptorMethodOverride(preDestroy.getClassName(), builder.build());
            }
        }
    }
    if (component.isStateful()) {
        final SessionBeanMetaData sessionBeanMetadata = (SessionBeanMetaData) metaData;
        // pre-passivate(s) of the interceptor configured (if any) in the deployment descriptor
        final LifecycleCallbacksMetaData prePassivates = sessionBeanMetadata.getPrePassivates();
        if (prePassivates != null) {
            for (final LifecycleCallbackMetaData prePassivate : prePassivates) {
                final InterceptorClassDescription.Builder builder = InterceptorClassDescription.builder();
                final String methodName = prePassivate.getMethodName();
                final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifier(void.class, methodName);
                builder.setPrePassivate(methodIdentifier);
                if (prePassivate.getClassName() == null || prePassivate.getClassName().isEmpty()) {
                    final String className = ClassReflectionIndexUtil.findRequiredMethod(reflectionIndex, componentClass, methodIdentifier).getDeclaringClass().getName();
                    component.addInterceptorMethodOverride(className, builder.build());
                } else {
                    component.addInterceptorMethodOverride(prePassivate.getClassName(), builder.build());
                }
            }
        }
        final LifecycleCallbacksMetaData postActivates = sessionBeanMetadata.getPostActivates();
        if (postActivates != null) {
            for (final LifecycleCallbackMetaData postActivate : postActivates) {
                final InterceptorClassDescription.Builder builder = InterceptorClassDescription.builder();
                final String methodName = postActivate.getMethodName();
                final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifier(void.class, methodName);
                builder.setPostActivate(methodIdentifier);
                if (postActivate.getClassName() == null || postActivate.getClassName().isEmpty()) {
                    final String className = ClassReflectionIndexUtil.findRequiredMethod(reflectionIndex, componentClass, methodIdentifier).getDeclaringClass().getName();
                    component.addInterceptorMethodOverride(className, builder.build());
                } else {
                    component.addInterceptorMethodOverride(postActivate.getClassName(), builder.build());
                }
            }
        }
    }
}

Example 7 with SessionBeanMetaData

use of org.jboss.metadata.ejb.spec.SessionBeanMetaData in project wildfly by wildfly.

the class AsynchronousMergingProcessor method handleDeploymentDescriptor.

@Override
protected void handleDeploymentDescriptor(final DeploymentUnit deploymentUnit, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final SessionBeanComponentDescription description) throws DeploymentUnitProcessingException {
    final SessionBeanMetaData data = description.getDescriptorData();
    final boolean isSecurityDomainKnown = description.isSecurityDomainKnown();
    if (data != null) {
        if (data instanceof SessionBean31MetaData) {
            final SessionBean31MetaData sessionBeanData = (SessionBean31MetaData) data;
            final AsyncMethodsMetaData async = sessionBeanData.getAsyncMethods();
            if (async != null) {
                for (AsyncMethodMetaData method : async) {
                    final Collection<Method> methods = MethodResolutionUtils.resolveMethods(method.getMethodName(), method.getMethodParams(), componentClass, deploymentReflectionIndex);
                    for (final Method m : methods) {
                        description.addAsynchronousMethod(MethodIdentifier.getIdentifierForMethod(m));
                    }
                }
            }
        }
    }
    if (!description.getAsynchronousClasses().isEmpty() || !description.getAsynchronousMethods().isEmpty()) {
        //setup a dependency on the executor service
        description.getConfigurators().add(new ComponentConfigurator() {

            @Override
            public void configure(final DeploymentPhaseContext context, final ComponentDescription description, final ComponentConfiguration configuration) throws DeploymentUnitProcessingException {
                configuration.getCreateDependencies().add(new DependencyConfigurator<SessionBeanComponentCreateService>() {

                    @Override
                    public void configureDependency(final ServiceBuilder<?> serviceBuilder, final SessionBeanComponentCreateService service) throws DeploymentUnitProcessingException {
                        serviceBuilder.addDependency(asynchronousThreadPoolService, ExecutorService.class, service.getAsyncExecutorService());
                    }
                });
            }
        });
        for (final ViewDescription view : description.getViews()) {
            final EJBViewDescription ejbView = (EJBViewDescription) view;
            ejbView.getConfigurators().add(new ViewConfigurator() {

                @Override
                public void configure(final DeploymentPhaseContext context, final ComponentConfiguration componentConfiguration, final ViewDescription description, final ViewConfiguration configuration) throws DeploymentUnitProcessingException {
                    final SessionBeanComponentDescription componentDescription = (SessionBeanComponentDescription) componentConfiguration.getComponentDescription();
                    for (final Method method : configuration.getProxyFactory().getCachedMethods()) {
                        //we need the component method to get the correct declaring class
                        final Method componentMethod = ClassReflectionIndexUtil.findMethod(deploymentReflectionIndex, componentClass, method);
                        if (componentMethod != null) {
                            if (componentDescription.getAsynchronousClasses().contains(componentMethod.getDeclaringClass().getName())) {
                                addAsyncInterceptor(configuration, method, isSecurityDomainKnown);
                                configuration.addAsyncMethod(method);
                            } else {
                                MethodIdentifier id = MethodIdentifier.getIdentifierForMethod(method);
                                if (componentDescription.getAsynchronousMethods().contains(id)) {
                                    addAsyncInterceptor(configuration, method, isSecurityDomainKnown);
                                    configuration.addAsyncMethod(method);
                                }
                            }
                        }
                    }
                }
            });
        }
    }
}

Example 8 with SessionBeanMetaData

use of org.jboss.metadata.ejb.spec.SessionBeanMetaData in project wildfly by wildfly.

the class RemoveMethodMergingProcessor method handleDeploymentDescriptor.

protected void handleDeploymentDescriptor(final DeploymentUnit deploymentUnit, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final StatefulComponentDescription componentConfiguration) throws DeploymentUnitProcessingException {
    SessionBeanMetaData beanMetaData = componentConfiguration.getDescriptorData();
    if (beanMetaData == null) {
        return;
    }
    if (beanMetaData.getRemoveMethods() == null || beanMetaData.getRemoveMethods().isEmpty()) {
        return;
    }
    final DeploymentReflectionIndex reflectionIndex = deploymentUnit.getAttachment(org.jboss.as.server.deployment.Attachments.REFLECTION_INDEX);
    final Set<MethodIdentifier> annotationRemoveMethods = new HashSet<MethodIdentifier>();
    for (final StatefulComponentDescription.StatefulRemoveMethod method : componentConfiguration.getRemoveMethods()) {
        annotationRemoveMethods.add(method.getMethodIdentifier());
    }
    //while the method that specifies the actual parameters override this
    for (final RemoveMethodMetaData removeMethod : beanMetaData.getRemoveMethods()) {
        if (removeMethod.getBeanMethod().getMethodParams() == null) {
            final NamedMethodMetaData methodData = removeMethod.getBeanMethod();
            final Collection<Method> methods = MethodResolutionUtils.resolveMethods(methodData, componentClass, reflectionIndex);
            for (final Method method : methods) {
                final Boolean retainIfException = removeMethod.getRetainIfException();
                final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
                if (retainIfException == null) {
                    //if this is null we have to allow annotation values of retainIfException to take precidence
                    if (!annotationRemoveMethods.contains(methodIdentifier)) {
                        componentConfiguration.addRemoveMethod(methodIdentifier, false);
                    }
                } else {
                    componentConfiguration.addRemoveMethod(methodIdentifier, retainIfException);
                }
            }
        }
    }
    for (final RemoveMethodMetaData removeMethod : beanMetaData.getRemoveMethods()) {
        if (removeMethod.getBeanMethod().getMethodParams() != null) {
            final NamedMethodMetaData methodData = removeMethod.getBeanMethod();
            final Collection<Method> methods = MethodResolutionUtils.resolveMethods(methodData, componentClass, reflectionIndex);
            for (final Method method : methods) {
                final Boolean retainIfException = removeMethod.getRetainIfException();
                final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
                if (retainIfException == null) {
                    //if this is null we have to allow annotation values of retainIfException to take precidence
                    if (!annotationRemoveMethods.contains(methodIdentifier)) {
                        componentConfiguration.addRemoveMethod(methodIdentifier, false);
                    }
                } else {
                    componentConfiguration.addRemoveMethod(methodIdentifier, retainIfException);
                }
            }
        }
    }
}

Example 9 with SessionBeanMetaData

use of org.jboss.metadata.ejb.spec.SessionBeanMetaData in project wildfly by wildfly.

the class SessionBeanComponentDescriptionFactory method processSessionBeans.

private void processSessionBeans(final DeploymentUnit deploymentUnit, final List<AnnotationInstance> sessionBeanAnnotations, final SessionBeanComponentDescription.SessionBeanType annotatedSessionBeanType) {
    final EjbJarDescription ejbJarDescription = getEjbJarDescription(deploymentUnit);
    final ServiceName deploymentUnitServiceName = deploymentUnit.getServiceName();
    PropertyReplacer propertyReplacer = EJBAnnotationPropertyReplacement.propertyReplacer(deploymentUnit);
    // process these session bean annotations and create component descriptions out of it
    for (final AnnotationInstance sessionBeanAnnotation : sessionBeanAnnotations) {
        final AnnotationTarget target = sessionBeanAnnotation.target();
        if (!(target instanceof ClassInfo)) {
            // Let's just WARN and move on. No need to throw an error
            EjbLogger.DEPLOYMENT_LOGGER.warn(EjbLogger.ROOT_LOGGER.annotationOnlyAllowedOnClass(sessionBeanAnnotation.name().toString(), target).getMessage());
            continue;
        }
        final ClassInfo sessionBeanClassInfo = (ClassInfo) target;
        // skip if it's not a valid class for session bean
        if (!assertSessionBeanClassValidity(sessionBeanClassInfo)) {
            continue;
        }
        final String ejbName = sessionBeanClassInfo.name().local();
        final AnnotationValue nameValue = sessionBeanAnnotation.value("name");
        final String beanName = (nameValue == null || nameValue.asString().isEmpty()) ? ejbName : propertyReplacer.replaceProperties(nameValue.asString());
        final SessionBeanMetaData beanMetaData = getEnterpriseBeanMetaData(deploymentUnit, beanName, SessionBeanMetaData.class);
        final SessionBeanComponentDescription.SessionBeanType sessionBeanType;
        final String beanClassName;
        if (beanMetaData != null) {
            beanClassName = override(sessionBeanClassInfo.name().toString(), beanMetaData.getEjbClass());
            sessionBeanType = override(annotatedSessionBeanType, descriptionOf(((SessionBeanMetaData) beanMetaData).getSessionType()));
        } else {
            beanClassName = sessionBeanClassInfo.name().toString();
            sessionBeanType = annotatedSessionBeanType;
        }
        final SessionBeanComponentDescription sessionBeanDescription;
        switch(sessionBeanType) {
            case STATELESS:
                sessionBeanDescription = new StatelessComponentDescription(beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName, beanMetaData);
                break;
            case STATEFUL:
                sessionBeanDescription = new StatefulComponentDescription(beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName, beanMetaData);
                // If passivation is disabled for the SFSB, either via annotation or via DD, then setup the component
                // description appropriately
                final boolean passivationCapableAnnotationValue = sessionBeanAnnotation.value("passivationCapable") == null ? true : sessionBeanAnnotation.value("passivationCapable").asBoolean();
                final Boolean passivationCapableDeploymentDescriptorValue;
                if ((beanMetaData instanceof SessionBean32MetaData)) {
                    passivationCapableDeploymentDescriptorValue = ((SessionBean32MetaData) beanMetaData).isPassivationCapable();
                } else {
                    passivationCapableDeploymentDescriptorValue = null;
                }
                final boolean passivationApplicable = override(passivationCapableDeploymentDescriptorValue, passivationCapableAnnotationValue);
                ((StatefulComponentDescription) sessionBeanDescription).setPassivationApplicable(passivationApplicable);
                break;
            case SINGLETON:
                sessionBeanDescription = new SingletonComponentDescription(beanName, beanClassName, ejbJarDescription, deploymentUnitServiceName, beanMetaData);
                break;
            default:
                throw EjbLogger.ROOT_LOGGER.unknownSessionBeanType(sessionBeanType.name());
        }
        addComponent(deploymentUnit, sessionBeanDescription);
    }
    EjbDeploymentMarker.mark(deploymentUnit);
}

Example 10 with SessionBeanMetaData

use of org.jboss.metadata.ejb.spec.SessionBeanMetaData in project wildfly by wildfly.

the class EjbConcurrencyMergingProcessor method handleDeploymentDescriptor.

protected void handleDeploymentDescriptor(final DeploymentUnit deploymentUnit, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final SessionBeanComponentDescription componentConfiguration) throws DeploymentUnitProcessingException {
    if (componentConfiguration.getDescriptorData() == null) {
        return;
    }
    SessionBeanMetaData sessionBeanMetaData = componentConfiguration.getDescriptorData();
    if (sessionBeanMetaData instanceof SessionBean31MetaData) {
        SessionBean31MetaData descriptor = (SessionBean31MetaData) sessionBeanMetaData;
        //handle lock
        if (descriptor.getLockType() != null) {
            componentConfiguration.setBeanLevelLockType(componentConfiguration.getEJBClassName(), descriptor.getLockType());
        }
        //handle access timeout
        if (descriptor.getAccessTimeout() != null) {
            componentConfiguration.setBeanLevelAccessTimeout(componentConfiguration.getEJBClassName(), new AccessTimeoutDetails(descriptor.getAccessTimeout().getTimeout(), descriptor.getAccessTimeout().getUnit()));
        }
        final ConcurrentMethodsMetaData methods = descriptor.getConcurrentMethods();
        if (methods != null) {
            for (final ConcurrentMethodMetaData method : methods) {
                final Method realMethod = resolveMethod(deploymentReflectionIndex, componentClass, componentClass, method.getMethod());
                final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(realMethod);
                if (method.getLockType() != null) {
                    componentConfiguration.setLockType(method.getLockType(), methodIdentifier);
                }
                if (method.getAccessTimeout() != null) {
                    componentConfiguration.setAccessTimeout(new AccessTimeoutDetails(method.getAccessTimeout().getTimeout(), method.getAccessTimeout().getUnit()), methodIdentifier);
                }
            }
        }
    }
}