How to use

getIdentifierForMethod

method

in

org.jboss.invocation.proxy.MethodIdentifier

public Set<MethodIdentifier> getTimerMethods() {
  final Set<MethodIdentifier> methods = new HashSet<MethodIdentifier>();
  if (timeoutMethod != null) {
    methods.add(MethodIdentifier.getIdentifierForMethod(timeoutMethod));
  }
  for (Method method : scheduleMethods.keySet()) {
    methods.add(MethodIdentifier.getIdentifierForMethod(method));
  }
  return methods;
}

public int getTransactionTimeout(final MethodIntf methodIntf, final Method method) {
  return getTransactionTimeout(methodIntf, MethodIdentifier.getIdentifierForMethod(method));
}

public TransactionAttributeType getTransactionAttributeType(final MethodIntf methodIntf, final Method method) {
  return getTransactionAttributeType(methodIntf, MethodIdentifier.getIdentifierForMethod(method));
}

protected void handleAnnotations(final DeploymentUnit deploymentUnit, final EEApplicationClasses applicationClasses, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final StatefulComponentDescription componentConfiguration) throws DeploymentUnitProcessingException {
  final RuntimeAnnotationInformation<Boolean> removeMethods = MethodAnnotationAggregator.runtimeAnnotationInformation(componentClass, applicationClasses, deploymentReflectionIndex, Remove.class);
  for (Map.Entry<Method, List<Boolean>> entry : removeMethods.getMethodAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      final Boolean retainIfException = entry.getValue().get(0);
      final MethodIdentifier removeMethodIdentifier = MethodIdentifier.getIdentifierForMethod(entry.getKey());
      componentConfiguration.addRemoveMethod(removeMethodIdentifier, retainIfException);
    }
  }
}

@Override
protected void handleAnnotations(final DeploymentUnit deploymentUnit, final EEApplicationClasses applicationClasses, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final SessionBeanComponentDescription description) throws DeploymentUnitProcessingException {
  final RuntimeAnnotationInformation<Boolean> data = MethodAnnotationAggregator.runtimeAnnotationInformation(componentClass, applicationClasses, deploymentReflectionIndex, Asynchronous.class);
  for (final Map.Entry<String, List<Boolean>> entry : data.getClassAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      description.addAsynchronousClass(entry.getKey());
    }
  }
  for (final Map.Entry<Method, List<Boolean>> entry : data.getMethodAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      description.addAsynchronousMethod(MethodIdentifier.getIdentifierForMethod(entry.getKey()));
    }
  }
}

protected void handleAnnotations(final DeploymentUnit deploymentUnit, final EEApplicationClasses applicationClasses, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final SessionBeanComponentDescription componentConfiguration) {
  //handle lock annotations
  final RuntimeAnnotationInformation<LockType> lockData = MethodAnnotationAggregator.runtimeAnnotationInformation(componentClass, applicationClasses, deploymentReflectionIndex, Lock.class);
  for (Map.Entry<String, List<LockType>> entry : lockData.getClassAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      componentConfiguration.setBeanLevelLockType(entry.getKey(), entry.getValue().get(0));
    }
  }
  for (Map.Entry<Method, List<LockType>> entry : lockData.getMethodAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      componentConfiguration.setLockType(entry.getValue().get(0), MethodIdentifier.getIdentifierForMethod(entry.getKey()));
    }
  }
  final RuntimeAnnotationInformation<AccessTimeoutDetails> accessTimeout = MethodAnnotationAggregator.runtimeAnnotationInformation(componentClass, applicationClasses, deploymentReflectionIndex, AccessTimeout.class);
  for (Map.Entry<String, List<AccessTimeoutDetails>> entry : accessTimeout.getClassAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      componentConfiguration.setBeanLevelAccessTimeout(entry.getKey(), entry.getValue().get(0));
    }
  }
  for (Map.Entry<Method, List<AccessTimeoutDetails>> entry : accessTimeout.getMethodAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      componentConfiguration.setAccessTimeout(entry.getValue().get(0), MethodIdentifier.getIdentifierForMethod(entry.getKey()));
    }
  }
}

methodIdentifiers.add(MethodIdentifier.getIdentifierForMethod(method));

description.excludeDefaultInterceptors(MethodIdentifier.getIdentifierForMethod(entry.getKey()));
description.excludeClassInterceptors(MethodIdentifier.getIdentifierForMethod(entry.getKey()));
final MethodIdentifier method = MethodIdentifier.getIdentifierForMethod(entry.getKey());
for (final String interceptor : entry.getValue().get(0)) {
  description.addMethodInterceptor(method, new InterceptorDescription(interceptor));

  @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);
          }
        }
      }
    }
  }
});

protected void processTxAttr(final EJBComponentDescription ejbComponentDescription, final MethodIntf methodIntf, final Method method) {
  if (this.getTransactionManagementType().equals(TransactionManagementType.BEAN)) {
    // it's a BMT bean
    return;
  }
  MethodIntf defaultMethodIntf = (ejbComponentDescription instanceof MessageDrivenComponentDescription) ? MethodIntf.MESSAGE_ENDPOINT : MethodIntf.BEAN;
  TransactionAttributeType txAttr = ejbComponentDescription.getTransactionAttributes().getAttribute(methodIntf, method, defaultMethodIntf);
  MethodTransactionAttributeKey key = new MethodTransactionAttributeKey(methodIntf, MethodIdentifier.getIdentifierForMethod(method));
  if(txAttr != null) {
    txAttrs.put(key, txAttr);
    txExplicitAttrs.put(key, ejbComponentDescription.getTransactionAttributes().isMethodLevel(methodIntf, method, defaultMethodIntf));
  }
  Integer txTimeout = ejbComponentDescription.getTransactionTimeouts().getAttribute(methodIntf, method, defaultMethodIntf);
  if (txTimeout != null) {
    txTimeouts.put(key, txTimeout);
  }
}

final Method componentMethod = ClassReflectionIndexUtil.findMethod(index, componentConfiguration.getComponentClass(), MethodIdentifier.getIdentifierForMethod(method));

  @Override
  public void configure(DeploymentPhaseContext context, ComponentConfiguration componentConfiguration, ViewDescription description, ViewConfiguration configuration) throws DeploymentUnitProcessingException {
    final StatefulComponentDescription statefulComponentDescription = (StatefulComponentDescription) componentConfiguration.getComponentDescription();
    final Collection<StatefulRemoveMethod> removeMethods = statefulComponentDescription.getRemoveMethods();
    if (removeMethods.isEmpty()) {
      return;
    }
    for (final Method viewMethod : configuration.getProxyFactory().getCachedMethods()) {
      final MethodIdentifier viewMethodIdentifier = MethodIdentifier.getIdentifierForMethod(viewMethod);
      for (final StatefulRemoveMethod removeMethod : removeMethods) {
        if (removeMethod.methodIdentifier.equals(viewMethodIdentifier)) {
          //we do not want to add this if it is the Ejb(Local)Object.remove() method, as that is handed elsewhere
          final boolean object = EJBObject.class.isAssignableFrom(configuration.getViewClass()) || EJBLocalObject.class.isAssignableFrom(configuration.getViewClass());
          if (!object || !viewMethodIdentifier.getName().equals("remove") || viewMethodIdentifier.getParameterTypes().length != 0) {
            configuration.addViewInterceptor(viewMethod, new ImmediateInterceptorFactory(new StatefulRemoveInterceptor(removeMethod.retainIfException)), InterceptorOrder.View.SESSION_REMOVE_INTERCEPTOR);
          }
          break;
        }
      }
    }
  }
});

public void configure(final DeploymentPhaseContext context, final ComponentConfiguration componentConfiguration, final ViewDescription description, final ViewConfiguration configuration) throws DeploymentUnitProcessingException {
  // Create method indexes
  final DeploymentReflectionIndex reflectionIndex = context.getDeploymentUnit().getAttachment(REFLECTION_INDEX);
  final List<Method> methods = configuration.getProxyFactory().getCachedMethods();
  for (final Method method : methods) {
    MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
    Method componentMethod = ClassReflectionIndexUtil.findMethod(reflectionIndex, componentConfiguration.getComponentClass(), methodIdentifier);
    if (componentMethod == null && method.getDeclaringClass().isInterface() && (method.getModifiers() & (ABSTRACT | PUBLIC | STATIC)) == PUBLIC) {
      // no component method and the interface method is defaulted, so we really do want to invoke on the interface method
      componentMethod = method;
    }
    if (componentMethod != null) {
      if ((BRIDGE & componentMethod.getModifiers()) != 0) {
        Method other = findRealMethodForBridgeMethod(componentMethod, componentConfiguration, reflectionIndex, methodIdentifier);
        //try and find the non-bridge method to delegate to
        if(other != null) {
            componentMethod = other;
        }
      }
      configuration.addViewInterceptor(method, new ImmediateInterceptorFactory(new ComponentDispatcherInterceptor(componentMethod)), InterceptorOrder.View.COMPONENT_DISPATCHER);
      configuration.addClientInterceptor(method, CLIENT_DISPATCHER_INTERCEPTOR_FACTORY, InterceptorOrder.Client.CLIENT_DISPATCHER);
      configuration.getViewToComponentMethodMap().put(method, componentMethod);
    }
  }
  configuration.addClientPostConstructInterceptor(Interceptors.getTerminalInterceptorFactory(), InterceptorOrder.ClientPostConstruct.TERMINAL_INTERCEPTOR);
  configuration.addClientPreDestroyInterceptor(Interceptors.getTerminalInterceptorFactory(), InterceptorOrder.ClientPreDestroy.TERMINAL_INTERCEPTOR);
}

final Collection<Method> methods = MethodResolutionUtils.resolveMethods(method.getMethodName(), method.getMethodParams(), componentClass, deploymentReflectionIndex);
for(final Method m : methods ) {
  description.addAsynchronousMethod(MethodIdentifier.getIdentifierForMethod(m));

final List<InterceptorBindingMetaData> methodBindings = entry.getValue();
boolean totalOrder = methodLevelAbsoluteOrder.containsKey(method);
final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);

final List<InterceptorBindingMetaData> methodBindings = entry.getValue();
boolean totalOrder = methodLevelAbsoluteOrder.containsKey(method);
final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);

for(final Method method : methods) {
  final Boolean retainIfException = removeMethod.getRetainIfException();
  final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
  if(retainIfException == null) {
for(final Method method : methods) {
  final Boolean retainIfException = removeMethod.getRetainIfException();
  final MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
  if(retainIfException == null) {

protected boolean createPermissions(final EjbJaccConfig ejbJaccConfig, final EJBComponentDescription description, final EJBViewConfiguration ejbViewConfiguration,
                 final Method viewMethod, final DeploymentReflectionIndex index, final ApplicableMethodInformation<EJBMethodSecurityAttribute> permissions) {
  MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(viewMethod);
  EJBMethodSecurityAttribute ejbMethodSecurityMetaData = permissions.getViewAttribute(ejbViewConfiguration.getMethodIntf(), viewMethod);
  if (ejbMethodSecurityMetaData == null) {
    if (classMethod != null) {
      methodIdentifier = MethodIdentifier.getIdentifierForMethod(classMethod);

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);
        }
      }
    }
  }
}

protected void handleAnnotations(final DeploymentUnit deploymentUnit, final EEApplicationClasses applicationClasses, final DeploymentReflectionIndex deploymentReflectionIndex, final Class<?> componentClass, final StatefulComponentDescription componentConfiguration) throws DeploymentUnitProcessingException {
  final RuntimeAnnotationInformation<Boolean> removeMethods = MethodAnnotationAggregator.runtimeAnnotationInformation(componentClass, applicationClasses, deploymentReflectionIndex, Remove.class);
  for (Map.Entry<Method, List<Boolean>> entry : removeMethods.getMethodAnnotations().entrySet()) {
    if (!entry.getValue().isEmpty()) {
      final Boolean retainIfException = entry.getValue().get(0);
      final MethodIdentifier removeMethodIdentifier = MethodIdentifier.getIdentifierForMethod(entry.getKey());
      componentConfiguration.addRemoveMethod(removeMethodIdentifier, retainIfException);
    }
  }
}