/** {@inheritDoc} */
 public Object processInvocation(final InterceptorContext context) throws Exception {
   Object target = targetReference.get().getInstance();
   if (target == null) {
     throw new IllegalStateException("No injection target found");
   }
   // if it's an optional injection and the injection source isn't available, then just proceed by
   // skipping the injection
   if (this.factory == null && this.optionalInjection) {
     return context.proceed();
   }
   ManagedReference reference = factory.getReference();
   boolean ok = false;
   try {
     valueReference.set(reference);
     method.invoke(target, reference.getInstance());
     Object result = context.proceed();
     ok = true;
     return result;
   } finally {
     if (!ok) {
       valueReference.set(null);
       reference.release();
     }
   }
 }
示例#2
0
    public ComponentViewInstance createInstance(Map<Object, Object> contextData) {
      final SimpleInterceptorFactoryContext factoryContext = new SimpleInterceptorFactoryContext();
      final Map<Method, InterceptorFactory> viewInterceptorFactories =
          ViewService.this.viewInterceptorFactories;
      final Map<Method, Interceptor> viewEntryPoints =
          new IdentityHashMap<Method, Interceptor>(viewInterceptorFactories.size());
      factoryContext.getContextData().put(Component.class, component);
      factoryContext.getContextData().putAll(contextData);
      // the post construct interceptors currently MUST be created first
      // and in some cases the instance is attached in this create process
      // TODO: this is probably not a good thing. {@see ManagedBeanCreateInterceptorFactory}
      final Interceptor postConstructInterceptor = viewPostConstruct.create(factoryContext);

      for (Method method : viewInterceptorFactories.keySet()) {
        viewEntryPoints.put(method, viewInterceptorFactories.get(method).create(factoryContext));
      }
      final Interceptor preDestroyInterceptor = viewPreDestroy.create(factoryContext);

      final ComponentViewInstance instance =
          new ViewInstance(viewEntryPoints, preDestroyInterceptor);
      try {
        InterceptorContext context = new InterceptorContext();
        context.putPrivateData(ComponentView.class, this);
        context.putPrivateData(Component.class, component);
        postConstructInterceptor.processInvocation(context);
      } catch (Exception e) {
        // TODO: What is the best exception type to throw here?
        throw new RuntimeException("Failed to instantiate component view", e);
      }
      return instance;
    }
  @Override
  public void callTimeout(final TimerImpl timer, final Method timeoutMethod) throws Exception {
    final Interceptor interceptor;
    synchronized (this) {
      if (!started) {
        // this can happen if an invocation has been triggered as the deployment is shutting down
        throw EjbLogger.ROOT_LOGGER.timerInvocationFailedDueToInvokerNotBeingStarted();
      }
      interceptor = timeoutInterceptors.get(timeoutMethod);
    }
    if (interceptor == null) {
      throw EjbLogger.ROOT_LOGGER.failToInvokeTimeout(timeoutMethod);
    }
    final InterceptorContext context = new InterceptorContext();
    context.setContextData(new HashMap<String, Object>());
    context.setMethod(timeoutMethod);
    if (timeoutMethod.getParameterTypes().length == 0) {
      context.setParameters(new Object[0]);
    } else {
      final Object[] params = new Object[1];
      params[0] = timer;
      context.setParameters(params);
    }
    context.setTimer(timer);

    if (timer.getPrimaryKey() != null) {
      context.putPrivateData(EntityBeanComponent.PRIMARY_KEY_CONTEXT_KEY, timer.getPrimaryKey());
    }
    context.putPrivateData(Component.class, ejbComponent.getValue());
    context.putPrivateData(MethodIntf.class, MethodIntf.TIMER);
    context.putPrivateData(InvocationType.class, InvocationType.TIMER);
    interceptor.processInvocation(context);
  }
 /**
  * Processes an incoming invocation and checks for the presence of a remote transaction associated
  * with the invocation context.
  *
  * @param context The invocation context
  * @return
  * @throws Exception
  */
 @Override
 public Object processInvocation(InterceptorContext context) throws Exception {
   final RemotingAttachments remotingAttachments =
       context.getPrivateData(RemotingAttachments.class);
   final TransactionManager transactionManager =
       this.ejbRemoteTransactionsRepository.getTransactionManager();
   Transaction originatingRemoteTx = null;
   if (remotingAttachments != null) {
     // get the transaction attachment
     final byte[] transactionIDBytes = remotingAttachments.getPayloadAttachment(0x0001);
     // A (remote) tx is associated with the invocation, so propogate it appropriately
     if (transactionIDBytes != null) {
       final TransactionID transactionID = TransactionID.createTransactionID(transactionIDBytes);
       // if it's UserTransaction then create or resume the UserTransaction corresponding to the ID
       if (transactionID instanceof UserTransactionID) {
         this.createOrResumeUserTransaction((UserTransactionID) transactionID);
       } else if (transactionID instanceof XidTransactionID) {
         this.createOrResumeXidTransaction((XidTransactionID) transactionID);
       }
       // the invocation was associated with a remote tx, so keep a flag so that we can
       // suspend (on this thread) the originating tx when returning from the invocation
       originatingRemoteTx = transactionManager.getTransaction();
     }
   }
   try {
     // we are done with any tx propogation setup, let's move on
     return context.proceed();
   } finally {
     // suspend the originating remote tx on this thread now that the invocation has been done
     if (originatingRemoteTx != null) {
       transactionManager.suspend();
     }
   }
 }
  @Override
  public Object processInvocation(InterceptorContext interceptorContext) throws Exception {
    try {

      return interceptorContext.proceed();
    } finally {
      StatefulSessionComponentInstance sfsb =
          (StatefulSessionComponentInstance)
              interceptorContext.getPrivateData(ComponentInstance.class);
      SFSBContextHandleImpl sfsbContextHandle = new SFSBContextHandleImpl(sfsb);
      List<EntityManager> readyToClose = SFSBXPCMap.getINSTANCE().remove(sfsbContextHandle);
      if (readyToClose != null && readyToClose.size() > 0) {
        for (EntityManager entityManager : readyToClose) {
          if (entityManager instanceof ExtendedEntityManager) {
            // TODO:  continue iterating through remaining entity managers and chain any exceptions
            ((ExtendedEntityManager) entityManager).containerClose();
          } else {
            throw new RuntimeException(
                "can only close SFSB XPC entity manager that are instances of ExtendedEntityManager"
                    + entityManager.getClass().getName());
          }
        }
      }
    }
  }
 @Override
 public Object processInvocation(final InterceptorContext context) throws Exception {
   final Object instance = context.getPrivateData(ComponentInstance.class).getInstance();
   try {
     return method.invoke(instance, context.getPrivateData(PARAMETERS_KEY));
   } catch (InvocationTargetException e) {
     throw Interceptors.rethrow(e.getCause());
   }
 }
  /** @return The primary key of the current EJB, or null if not applicable */
  private Object currentPrimaryKey() {

    final InterceptorContext context = CurrentInvocationContext.get();

    if (context == null) {
      return null;
    }
    return context.getPrivateData(EntityBeanComponent.PRIMARY_KEY_CONTEXT_KEY);
  }
 @Override
 public Object getInstance() {
   // get the current invocation context and the EJBComponent out of it
   final InterceptorContext currentInvocationContext = CurrentInvocationContext.get();
   final EJBComponent ejbComponent =
       (EJBComponent) currentInvocationContext.getPrivateData(Component.class);
   if (ejbComponent == null) {
     throw MESSAGES.failToGetEjbComponent(currentInvocationContext);
   }
   return ejbComponent.getTimerService();
 }
示例#9
0
 protected TransactionAttributeType getCurrentTransactionAttribute() {
   final InterceptorContext currentInvocationContext = CurrentInvocationContext.get();
   if (currentInvocationContext == null) {
     return null;
   }
   final Method invokedMethod = currentInvocationContext.getMethod();
   // if method is null, then it's a lifecycle invocation
   if (invokedMethod == null) {
     return null;
   }
   // get the tx attribute of the invoked method
   return this.getTransactionAttributeType(invokedMethod);
 }
示例#10
0
 public void destroy() {
   try {
     InterceptorContext interceptorContext = new InterceptorContext();
     interceptorContext.putPrivateData(ComponentView.class, View.this);
     interceptorContext.putPrivateData(ComponentViewInstance.class, this);
     interceptorContext.putPrivateData(Component.class, component);
     preDestroyInterceptor.processInvocation(interceptorContext);
   } catch (Exception e) {
     logger.warn(
         "Exception while invoking pre-destroy interceptor for component class: "
             + this.getComponent().getComponentClass(),
         e);
   }
 }
示例#11
0
 /**
  * Returns true if the {@link CurrentInvocationContext} represents a lifecycle callback
  * invocation. Else returns false.
  *
  * <p>This method internally relies on {@link CurrentInvocationContext#get()} to obtain the
  * current invocation context.
  *
  * <ul>
  *   <li>If the context is available then it looks for the method that was invoked. The absence of
  *       a method indicates a lifecycle callback.
  *   <li>If the context is <i>not</i> available, then this method returns false (i.e. it doesn't
  *       consider the current invocation as a lifecycle callback). This is for convenience, to
  *       allow the invocation of {@link javax.ejb.TimerService} methods in the absence of {@link
  *       CurrentInvocationContext}
  * </ul>
  *
  * <p>
  *
  * @return
  */
 protected boolean isLifecycleCallbackInvocation() {
   final InterceptorContext currentInvocationContext = CurrentInvocationContext.get();
   if (currentInvocationContext == null) {
     return false;
   }
   // If the method in current invocation context is null,
   // then it represents a lifecycle callback invocation
   Method invokedMethod = currentInvocationContext.getMethod();
   if (invokedMethod == null) {
     // it's a lifecycle callback
     return true;
   }
   // not a lifecycle callback
   return false;
 }
 public boolean wasCancelCalled() throws IllegalStateException {
   final CancellationFlag flag = context.getPrivateData(CancellationFlag.class);
   if (flag != null) {
     return flag.get();
   }
   return super.wasCancelCalled();
 }
示例#13
0
      public Object createProxy() {
        final SimpleInterceptorFactoryContext factoryContext =
            new SimpleInterceptorFactoryContext();
        factoryContext.getContextData().put(Component.class, component);
        factoryContext.getContextData().put(ComponentView.class, View.this);
        factoryContext.getContextData().put(ComponentViewInstance.class, this);

        final Map<Method, InterceptorFactory> clientInterceptorFactories =
            ViewService.this.clientInterceptorFactories;
        final Map<Method, Interceptor> clientEntryPoints =
            new IdentityHashMap<Method, Interceptor>(clientInterceptorFactories.size());
        for (Method method : clientInterceptorFactories.keySet()) {
          clientEntryPoints.put(
              method, clientInterceptorFactories.get(method).create(factoryContext));
        }
        final Interceptor postConstructInterceptor = clientPostConstruct.create(factoryContext);
        try {
          Object object =
              proxyFactory.newInstance(
                  new ProxyInvocationHandler(clientEntryPoints, component, View.this, this));
          InterceptorContext interceptorContext = new InterceptorContext();
          interceptorContext.putPrivateData(ComponentView.class, View.this);
          interceptorContext.putPrivateData(ComponentViewInstance.class, this);
          interceptorContext.putPrivateData(Component.class, component);
          try {
            postConstructInterceptor.processInvocation(interceptorContext);
          } catch (Exception e) {
            InstantiationException exception =
                new InstantiationException("Post-construct lifecycle failed");
            exception.initCause(e);
            throw exception;
          }
          return object;
        } catch (InstantiationException e) {
          InstantiationError error = new InstantiationError(e.getMessage());
          Throwable cause = e.getCause();
          if (cause != null) error.initCause(cause);
          throw error;
        } catch (IllegalAccessException e) {
          IllegalAccessError error = new IllegalAccessError(e.getMessage());
          Throwable cause = e.getCause();
          if (cause != null) error.initCause(cause);
          throw error;
        }
      }
  @Override
  public Object processInvocation(InterceptorContext context) throws Exception {
    final Component component = context.getPrivateData(Component.class);

    // if a session bean is participating in a transaction, it
    // is an error for a client to invoke the remove method
    // on the session object's home or component interface.
    final ComponentView view = context.getPrivateData(ComponentView.class);
    if (view != null) {
      Ejb2xViewType viewType = view.getPrivateData(Ejb2xViewType.class);
      if (viewType != null) {
        // this means it is an EJB 2.x view
        // which is not allowed to remove while enrolled in a TX
        final StatefulTransactionMarker marker =
            context.getPrivateData(StatefulTransactionMarker.class);
        if (marker != null && !marker.isFirstInvocation()) {
          throw EjbLogger.ROOT_LOGGER.cannotRemoveWhileParticipatingInTransaction();
        }
      }
    }
    // just log a WARN and throw back the original exception
    if (component instanceof StatefulSessionComponent == false) {
      throw EjbLogger.ROOT_LOGGER.unexpectedComponent(component, StatefulSessionComponent.class);
    }
    final StatefulSessionComponent statefulComponent = (StatefulSessionComponent) component;
    Object invocationResult = null;
    try {
      // proceed
      invocationResult = context.proceed();
    } catch (Exception e) {
      // Exception caught during call to @Remove method. Handle it appropriately

      // If it's an application exception and if the @Remove method has set "retainIfException" to
      // true
      // then just throw back the exception and don't remove the session instance.
      if (this.isApplicationException(statefulComponent, e.getClass(), context.getMethod())
          && this.retainIfException) {
        throw e;
      }
      // otherwise, just remove it and throw back the original exception
      final StatefulSessionComponentInstance statefulComponentInstance =
          (StatefulSessionComponentInstance) context.getPrivateData(ComponentInstance.class);
      final SessionID sessionId = statefulComponentInstance.getId();
      statefulComponent.removeSession(sessionId);
      throw e;
    }
    final StatefulSessionComponentInstance statefulComponentInstance =
        (StatefulSessionComponentInstance) context.getPrivateData(ComponentInstance.class);
    final SessionID sessionId = statefulComponentInstance.getId();
    // just remove the session because of a call to @Remove method
    statefulComponent.removeSession(sessionId);
    // return the invocation result
    return invocationResult;
  }
示例#15
0
 public void invokeTimeoutMethod(final Method method, final Timer timer) {
   final Interceptor interceptor = timeoutInterceptors.get(method);
   if (interceptor == null) {
     throw MESSAGES.failToCallTimeOutMethod(method);
   }
   try {
     InterceptorContext context = prepareInterceptorContext();
     context.setMethod(method);
     context.setTimer(timer);
     context.setTarget(getInstance());
     final Object[] params;
     if (method.getParameterTypes().length == 1) {
       params = new Object[1];
       params[0] = timer;
     } else {
       params = EMPTY_OBJECT_ARRAY;
     }
     context.setParameters(params);
     interceptor.processInvocation(context);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
示例#16
0
 private void prepareInterceptorContext(
     final SkeletonStrategy op, final Object[] params, final InterceptorContext interceptorContext)
     throws IOException, ClassNotFoundException {
   if (!home) {
     if (componentView.getComponent() instanceof StatefulSessionComponent) {
       final SessionID sessionID = (SessionID) unmarshalIdentifier();
       interceptorContext.putPrivateData(SessionID.class, sessionID);
     } else if (componentView.getComponent() instanceof EntityBeanComponent) {
       final Object pk = unmarshalIdentifier();
       interceptorContext.putPrivateData(EntityBeanComponent.PRIMARY_KEY_CONTEXT_KEY, pk);
     }
   }
   interceptorContext.setContextData(new HashMap<String, Object>());
   interceptorContext.setParameters(params);
   interceptorContext.setMethod(op.getMethod());
   interceptorContext.putPrivateData(ComponentView.class, componentView);
   interceptorContext.putPrivateData(Component.class, componentView.getComponent());
 }
  /**
   * Invokes WS endpoint.
   *
   * @param endpoint WS endpoint
   * @param wsInvocation web service invocation
   * @throws Exception if any error occurs
   */
  public void invoke(final Endpoint endpoint, final Invocation wsInvocation) throws Exception {
    try {
      // prepare for invocation
      onBeforeInvocation(wsInvocation);
      // prepare invocation data
      final ComponentView componentView = getComponentView();
      Component component = componentView.getComponent();
      // for spring integration and @FactoryType is annotated we don't need to go into ee's
      // interceptors
      if (wsInvocation.getInvocationContext().getTargetBean() != null
              && (endpoint.getProperty("SpringBus") != null)
          || wsInvocation.getInvocationContext().getProperty("forceTargetBean") != null) {
        this.reference =
            new ManagedReference() {
              public void release() {}

              public Object getInstance() {
                return wsInvocation.getInvocationContext().getTargetBean();
              }
            };
        if (component instanceof WSComponent) {
          ((WSComponent) component).setReference(reference);
        }
      }
      final Method method =
          getComponentViewMethod(wsInvocation.getJavaMethod(), componentView.getViewMethods());
      final InterceptorContext context = new InterceptorContext();
      prepareForInvocation(context, wsInvocation);
      context.setMethod(method);
      context.setParameters(wsInvocation.getArgs());
      context.putPrivateData(Component.class, component);
      context.putPrivateData(ComponentView.class, componentView);
      if (wsInvocation.getInvocationContext().getProperty("forceTargetBean") != null) {
        context.putPrivateData(ManagedReference.class, reference);
      }
      // invoke method
      final Object retObj = componentView.invoke(context);
      // set return value
      wsInvocation.setReturnValue(retObj);
    } catch (Throwable t) {
      handleInvocationException(t);
    } finally {
      onAfterInvocation(wsInvocation);
    }
  }
 @Override
 public Object processInvocation(InterceptorContext context) throws Exception {
   final Method invokedMethod = context.getMethod();
   final ComponentViewInstance componentViewInstance =
       context.getPrivateData(ComponentViewInstance.class);
   // For a lifecycle interception, the ComponentViewInstance (and the invoked business interface)
   // will be null.
   // On a normal method invocation, the invoked business interface will be obtained from the
   // ComponentViewInstance
   final Class<?> invokedBusinessInterface =
       componentViewInstance == null ? null : componentViewInstance.getViewClass();
   Object[] parameters = context.getParameters();
   SessionInvocationContext sessionInvocationContext =
       new CustomSessionInvocationContext(
           lifecycleCallback, context, invokedBusinessInterface, invokedMethod, parameters);
   context.putPrivateData(InvocationContext.class, sessionInvocationContext);
   CurrentInvocationContext.push(sessionInvocationContext);
   try {
     return context.proceed();
   } finally {
     CurrentInvocationContext.pop();
     context.putPrivateData(InvocationContext.class, null);
   }
 }
示例#19
0
  /**
   * Receives IIOP requests to this servant's <code>EJBObject</code>s and forwards them to the bean
   * container, through the JBoss <code>MBean</code> server.
   */
  public OutputStream _invoke(
      final String opName, final InputStream in, final ResponseHandler handler) {

    if (logger.isTraceEnabled()) {
      logger.trace("EJBObject invocation: " + opName);
    }

    SkeletonStrategy op = methodInvokerMap.get(opName);
    if (op == null) {
      logger.debugf(
          "Unable to find opname '%s' valid operations:%s", opName, methodInvokerMap.keySet());
      throw new BAD_OPERATION(opName);
    }
    final NamespaceContextSelector selector =
        componentView.getComponent().getNamespaceContextSelector();
    final ClassLoader oldCl = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged();
    NamespaceContextSelector.pushCurrentSelector(selector);
    try {
      WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(classLoader);
      SecurityContext sc = null;
      org.omg.CORBA_2_3.portable.OutputStream out;
      try {
        Object retVal;

        if (!home && opName.equals("_get_handle")) {
          retVal = new HandleImplIIOP(orb.object_to_string(_this_object()));
        } else if (home && opName.equals("_get_homeHandle")) {
          retVal = homeHandle;
        } else if (home && opName.equals("_get_EJBMetaData")) {
          retVal = ejbMetaData;
        } else {
          Transaction tx = null;
          if (inboundTxCurrent != null) tx = inboundTxCurrent.getCurrentTransaction();
          if (tx != null) {
            transactionManager.resume(tx);
          }
          try {
            SimplePrincipal principal = null;
            Object credential = null;

            if (sasCurrent != null) {
              final byte[] incomingName = sasCurrent.get_incoming_principal_name();

              if (incomingName != null && incomingName.length > 0) {
                // we have an identity token, which is a trust based mechanism
                if (incomingName.length > 0) {
                  String name = new String(incomingName, StandardCharsets.UTF_8);
                  int domainIndex = name.indexOf('@');
                  if (domainIndex > 0) name = name.substring(0, domainIndex);
                  principal = new SimplePrincipal(name);
                  // we don't have any real way to establish trust here
                  // we just use the SASCurrent as a credential, and a custom login
                  // module can make a decision for us.
                  credential = sasCurrent;
                }
              } else {
                // the client has just sent a username and password
                final byte[] username = sasCurrent.get_incoming_username();
                final byte[] incomingPassword = sasCurrent.get_incoming_password();
                if (username.length > 0) {
                  String name = new String(username, StandardCharsets.UTF_8);
                  int domainIndex = name.indexOf('@');
                  if (domainIndex > 0) {
                    name = name.substring(0, domainIndex);
                  }
                  principal = new SimplePrincipal(name);
                  credential = new String(incomingPassword, StandardCharsets.UTF_8).toCharArray();
                }
              }

              if (securityDomain != null) {
                sc = SecurityContextFactory.createSecurityContext(securityDomain);
                sc.getUtil().createSubjectInfo(principal, credential, null);
              }
            }
            final Object[] params = op.readParams((org.omg.CORBA_2_3.portable.InputStream) in);

            if (!home && opName.equals("isIdentical") && params.length == 1) {
              // handle isIdentical specially
              Object val = params[0];
              if (val instanceof org.omg.CORBA.Object) {
                retVal = handleIsIdentical((org.omg.CORBA.Object) val);
              } else {
                retVal = false;
              }
            } else {

              if (sc != null) {
                setSecurityContextOnAssociation(sc);
              }
              try {
                final InterceptorContext interceptorContext = new InterceptorContext();

                if (sc != null) {
                  interceptorContext.putPrivateData(SecurityContext.class, sc);
                }
                prepareInterceptorContext(op, params, interceptorContext);
                retVal = componentView.invoke(interceptorContext);
              } finally {
                if (sc != null) {
                  clearSecurityContextOnAssociation();
                }
              }
            }
          } finally {
            if (tx != null) {
              if (transactionManager.getStatus() != Status.STATUS_NO_TRANSACTION) {
                transactionManager.suspend();
              }
            }
          }
        }
        out = (org.omg.CORBA_2_3.portable.OutputStream) handler.createReply();
        if (op.isNonVoid()) {
          op.writeRetval(out, retVal);
        }
      } catch (Exception e) {
        if (logger.isTraceEnabled()) {
          logger.trace("Exception in EJBObject invocation", e);
        }
        if (e instanceof MBeanException) {
          e = ((MBeanException) e).getTargetException();
        }
        RmiIdlUtil.rethrowIfCorbaSystemException(e);
        out = (org.omg.CORBA_2_3.portable.OutputStream) handler.createExceptionReply();
        op.writeException(out, e);
      }
      return out;
    } finally {
      NamespaceContextSelector.popCurrentSelector();
      WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(oldCl);
    }
  }
 @Override
 public SessionBeanComponent getComponent() {
   // return (SessionBeanComponent) super.getComponent();
   // this is faster
   return (SessionBeanComponent) context.getPrivateData(Component.class);
 }
示例#21
0
 public Object processInvocation(final InterceptorContext context) throws Exception {
   ComponentView view = context.getPrivateData(ComponentView.class);
   return view.invoke(context);
 }
 @Override
 public Map<String, Object> getContextData() {
   return context.getContextData();
 }
 @Override
 public SessionContext getEJBContext() {
   return ((SessionBeanComponentInstance) context.getPrivateData(ComponentInstance.class))
       .getSessionContext();
 }
 @Override
 public Object proceed() throws Exception {
   return context.proceed();
 }
示例#25
0
  protected TransactionAttributeType getCurrentTransactionAttribute() {

    final InterceptorContext invocation = CurrentInvocationContext.get();
    final MethodIntf methodIntf = MethodIntfHelper.of(invocation);
    return getTransactionAttributeType(methodIntf, invocation.getMethod());
  }
 @Override
 public void setParameters(Object[] params)
     throws IllegalArgumentException, IllegalStateException {
   context.setParameters(params);
 }
 protected SessionID getSessionIdOf(final InterceptorContext ctx) {
   final StatefulSessionComponentInstance instance =
       (StatefulSessionComponentInstance) ctx.getPrivateData(ComponentInstance.class);
   return instance.getId();
 }
示例#28
0
 public Object processInvocation(final InterceptorContext context) throws Exception {
   context.getPrivateData(ComponentViewInstance.class).destroy();
   return null;
 }
 @Override
 public Object processInvocation(InterceptorContext context) throws Exception {
   return super.invoke(
       (TransactionalInvocationContext) context.getPrivateData(InvocationContext.class));
 }