Пример #1
0
  private void copyConcurrentMethods(
      final SessionBean bean, final EjbJarInfo ejbJarInfo, final Map ejbds) {
    for (final ConcurrentMethod method : bean.getConcurrentMethod()) {
      final MethodConcurrencyInfo info = new MethodConcurrencyInfo();

      if (method.getLock() != null) {
        info.concurrencyAttribute = method.getLock().toString();
      }
      info.accessTimeout = toInfo(method.getAccessTimeout());

      final Method m = new Method(bean.getEjbName(), null, method.getMethod().getMethodName());
      m.setMethodParams(method.getMethod().getMethodParams());
      info.methods.add(getMethodInfo(m, ejbds));
      ejbJarInfo.methodConcurrency.add(info);
    }
  }
Пример #2
0
  private EnterpriseBeanInfo initSessionBean(
      final SessionBean s, final EjbJarInfo ejbJar, final Map m) throws OpenEJBException {
    EnterpriseBeanInfo bean = null;

    if (s.getSessionType() == SessionType.STATEFUL) {
      bean = new StatefulBeanInfo();
      bean.passivable = s.getPassivationCapable();
      final StatefulBeanInfo stateful = (StatefulBeanInfo) bean;

      copyCallbacks(s.getPostActivate(), stateful.postActivate);
      copyCallbacks(s.getPrePassivate(), stateful.prePassivate);

      copyCallbacks(s.getAfterBegin(), stateful.afterBegin);
      copyCallbacks(s.getBeforeCompletion(), stateful.beforeCompletion);
      copyCallbacks(s.getAfterCompletion(), stateful.afterCompletion);

      for (final InitMethod initMethod : s.getInitMethod()) {
        final InitMethodInfo init = new InitMethodInfo();
        init.beanMethod = toInfo(initMethod.getBeanMethod());
        init.createMethod = toInfo(initMethod.getCreateMethod());
        stateful.initMethods.add(init);
      }

      for (final RemoveMethod removeMethod : s.getRemoveMethod()) {
        final RemoveMethodInfo remove = new RemoveMethodInfo();
        remove.beanMethod = toInfo(removeMethod.getBeanMethod());
        remove.retainIfException = removeMethod.getRetainIfException();
        stateful.removeMethods.add(remove);
      }

      copyConcurrentMethods(s, ejbJar, m);

    } else if (s.getSessionType() == SessionType.MANAGED) {
      bean = new ManagedBeanInfo();
      final ManagedBeanInfo managed = (ManagedBeanInfo) bean;
      if (s
          instanceof
          ManagedBean) { // this way we support managed beans in ejb-jar.xml (not in the spec but
        // can be useful)
        managed.hidden = ((ManagedBean) s).isHidden();
      } else {
        managed.hidden = true;
      }

      copyCallbacks(s.getPostActivate(), managed.postActivate);
      copyCallbacks(s.getPrePassivate(), managed.prePassivate);

      for (final RemoveMethod removeMethod : s.getRemoveMethod()) {
        final RemoveMethodInfo remove = new RemoveMethodInfo();
        remove.beanMethod = toInfo(removeMethod.getBeanMethod());
        remove.retainIfException = removeMethod.getRetainIfException();
        managed.removeMethods.add(remove);
      }

    } else if (s.getSessionType() == SessionType.SINGLETON) {
      bean = new SingletonBeanInfo();
      final ConcurrencyManagementType type = s.getConcurrencyManagementType();
      bean.concurrencyType =
          type != null ? type.toString() : ConcurrencyManagementType.CONTAINER.toString();
      bean.loadOnStartup = s.getInitOnStartup();

      copyCallbacks(s.getAroundTimeout(), bean.aroundTimeout);
      copySchedules(s.getTimer(), bean.methodScheduleInfos);
      // See JndiEncInfoBuilder.buildDependsOnRefs for processing of DependsOn
      // bean.dependsOn.addAll(s.getDependsOn());

      copyConcurrentMethods(s, ejbJar, m);
    } else {
      bean = new StatelessBeanInfo();
      copySchedules(s.getTimer(), bean.methodScheduleInfos);
    }

    if (s.getSessionType() != SessionType.STATEFUL) {
      copyCallbacks(s.getAroundTimeout(), bean.aroundTimeout);
    }

    bean.localbean = s.getLocalBean() != null;

    bean.timeoutMethod = toInfo(s.getTimeoutMethod());

    copyCallbacks(s.getAroundInvoke(), bean.aroundInvoke);
    copyCallbacks(s.getPostConstruct(), bean.postConstruct);
    copyCallbacks(s.getPreDestroy(), bean.preDestroy);

    copyAsynchronous(s.getAsyncMethod(), bean.asynchronous);
    bean.asynchronousClasses.addAll(s.getAsynchronousClasses());

    final EjbDeployment d = (EjbDeployment) m.get(s.getEjbName());
    if (d == null) {
      throw new OpenEJBException(
          "No deployment information in openejb-jar.xml for bean "
              + s.getEjbName()
              + ". Please redeploy the jar");
    }
    bean.ejbDeploymentId = d.getDeploymentId();
    bean.containerId = d.getContainerId();

    final Icon icon = s.getIcon();
    bean.largeIcon = icon == null ? null : icon.getLargeIcon();
    bean.smallIcon = icon == null ? null : icon.getSmallIcon();
    bean.description = s.getDescription();
    bean.displayName = s.getDisplayName();
    bean.ejbClass = s.getEjbClass();
    bean.ejbName = s.getEjbName();
    bean.home = s.getHome();
    bean.remote = s.getRemote();
    bean.localHome = s.getLocalHome();
    bean.local = s.getLocal();
    bean.proxy = s.getProxy();
    bean.parents.addAll(s.getParents());
    bean.businessLocal.addAll(s.getBusinessLocal());
    bean.businessRemote.addAll(s.getBusinessRemote());
    final TransactionType txType = s.getTransactionType();
    bean.transactionType =
        txType != null ? txType.toString() : TransactionType.CONTAINER.toString();
    bean.serviceEndpoint = s.getServiceEndpoint();
    bean.properties.putAll(d.getProperties());

    bean.statefulTimeout = toInfo(s.getStatefulTimeout());

    bean.restService = s.isRestService() && !(s instanceof StatefulBean);

    return bean;
  }
  public void validate(EjbModule module) {
    Set<String> applicationExceptions = new HashSet<String>();
    for (ApplicationException applicationException :
        module.getEjbJar().getAssemblyDescriptor().getApplicationException()) {
      applicationExceptions.add(applicationException.getExceptionClass());
    }
    for (EnterpriseBean bean : module.getEjbJar().getEnterpriseBeans()) {
      Class<?> ejbClass = null;
      try {
        ejbClass = loadClass(bean.getEjbClass());
      } catch (OpenEJBException e) {
        continue;
      }
      if (bean instanceof SessionBean) {
        SessionBean session = (SessionBean) bean;
        for (AsyncMethod asyncMethod : session.getAsyncMethod()) {
          Method method = getMethod(ejbClass, asyncMethod);
          if (method == null) {
            fail(
                bean,
                "asynchronous.missing",
                asyncMethod.getMethodName(),
                ejbClass.getName(),
                getParameters(asyncMethod.getMethodParams()));
          } else {
            checkAsynchronousMethod(session, ejbClass, method, applicationExceptions);
          }
        }

        for (String className : session.getAsynchronousClasses()) {
          try {
            Class<?> cls = loadClass(className);
            for (Method method : cls.getDeclaredMethods()) {
              if (Modifier.isPublic(method.getModifiers()) && !method.isSynthetic()) {
                checkAsynchronousMethod(session, ejbClass, method, applicationExceptions);
              } else {
                // warn(session, "asynchronous.methodignored", ejbClass.getName(),
                // method.getName());
              }
            }
          } catch (OpenEJBException e) {
            // ignore ?
          }
        }
      } else {
        ClassFinder classFinder = new ClassFinder(ejbClass);
        for (Method method : classFinder.findAnnotatedMethods(Asynchronous.class)) {
          ignoredMethodAnnotation(
              "Asynchronous",
              bean,
              bean.getEjbClass(),
              method.getName(),
              bean.getClass().getSimpleName());
        }
        if (ejbClass.getAnnotation(Asynchronous.class) != null) {
          ignoredClassAnnotation(
              "Asynchronous", bean, bean.getEjbClass(), bean.getClass().getSimpleName());
        }
      }
    }
  }