org.jboss.invocation.proxy.MethodIdentifier.getIdentifierForMethod java code examples

Common ways to obtain MethodIdentifier

private void myMethod () {
 MethodIdentifier m =Method method;MethodIdentifier.getIdentifierForMethod(method)
String name;MethodIdentifier.getIdentifier(void.class, name)
InterceptorClassDescription interceptorClassDescription;interceptorClassDescription.getAroundTimeout()
Smart code suggestions by Tabnine
}

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

Javadoc

Get an identifier for the given reflection method.

Popular methods of MethodIdentifier

getIdentifier
Construct a new instance using string names for the return and parameter types.
getName
Get the method name.
getParameterTypes
Get the parameter type names, as strings.
equals
Determine whether this object is equal to another.
getReturnType
Get the method return type name, as a string.
hashCode
Get the hash code for this method identifier. The hash code is equal to: n * 7 + (r * 7 + a) whe
<init>
calculateHash
namesOf
typesOf

Popular in Java

Reading from database using SQL prepared statement
runOnUiThread (Activity)
scheduleAtFixedRate (Timer)
getExternalFilesDir (Context)
RandomAccessFile (java.io)
Allows reading from and writing to a file in a random-access manner. This is different from the uni-
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
JTextField (javax.swing)
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid
21 Best Atom Packages for 2021

How to use getIdentifierForMethodmethodin org.jboss.invocation.proxy.MethodIdentifier

Best Java code snippets using org.jboss.invocation.proxy.MethodIdentifier.getIdentifierForMethod (Showing top 20 results out of 315)

How to use
getIdentifierForMethod
method
in
org.jboss.invocation.proxy.MethodIdentifier