## org.springframework.transaction.interceptor
Class MethodMapTransactionAttributeSource

    java.lang.Object
      org.springframework.transaction.interceptor.MethodMapTransactionAttributeSource

All Implemented Interfaces:
  BeanClassLoaderAware, InitializingBean, TransactionAttributeSource

    public class MethodMapTransactionAttributeSource

extends Object
implements TransactionAttributeSource, BeanClassLoaderAware, InitializingBean

Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.

Since:
  24.04.2003
Author:
  Rod Johnson, Juergen Hoeller
See Also:
  `isMatch(java.lang.String, java.lang.String)`, `NameMatchTransactionAttributeSource`

Field Summary
`protected Log` `logger` Logger available to subclasses

Constructor Summary
`MethodMapTransactionAttributeSource()`

Method Summary
`void` `addTransactionalMethod(Class<?> clazz, String mappedName, TransactionAttribute attr)` Add an attribute for a transactional method.
`void` `addTransactionalMethod(Method method, TransactionAttribute attr)` Add an attribute for a transactional method.
`void` `addTransactionalMethod(String name, TransactionAttribute attr)` Add an attribute for a transactional method.
`void` `afterPropertiesSet()` Eagerly initializes the specified `"methodMap"`, if any.
`boolean` `equals(Object other)`
`TransactionAttribute` `getTransactionAttribute(Method method, Class<?> targetClass)` Return the transaction attribute for this method.
`int` `hashCode()`
`protected void` `initMethodMap(Map<String,TransactionAttribute> methodMap)` Initialize the specified `"methodMap"`, if any.
`protected boolean` `isMatch(String methodName, String mappedName)` Return if the given method name matches the mapped name.
`void` `setBeanClassLoader(ClassLoader beanClassLoader)` Callback that supplies the bean `class loader` to a bean instance.
`void` `setMethodMap(Map<String,TransactionAttribute> methodMap)` Set a name/attribute map, consisting of "FQCN.method" method names (e.g.
`String` `toString()`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### logger

    protected final Log logger

  Logger available to subclasses

Constructor Detail

### MethodMapTransactionAttributeSource

    public MethodMapTransactionAttributeSource()

Method Detail

### setMethodMap

    public void setMethodMap(Map<String,TransactionAttribute> methodMap)

  Set a name/attribute map, consisting of "FQCN.method" method names (e.g. "com.mycompany.mycode.MyClass.myMethod") and `TransactionAttribute` instances (or Strings to be converted to `TransactionAttribute` instances).

  Intended for configuration via setter injection, typically within a Spring bean factory. Relies on `afterPropertiesSet()` being called afterwards.

  Parameters:
    `methodMap` - said `Map` from method name to attribute value
  See Also:
    `TransactionAttribute`, `TransactionAttributeEditor`

### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader beanClassLoader)

  Description copied from interface: `BeanClassLoaderAware`
  Callback that supplies the bean `class loader` to a bean instance.

  Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean's` `InitializingBean.afterPropertiesSet()` method or a custom init-method.

  Specified by:
    `setBeanClassLoader` in interface `BeanClassLoaderAware`
  Parameters:
    `beanClassLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

### afterPropertiesSet

    public void afterPropertiesSet()

  Eagerly initializes the specified `"methodMap"`, if any.

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`
  See Also:
    `initMethodMap(java.util.Map)`

### initMethodMap

    protected void initMethodMap(Map<String,TransactionAttribute> methodMap)

  Initialize the specified `"methodMap"`, if any.

  Parameters:
    `methodMap` - Map from method names to `TransactionAttribute` instances
  See Also:
    `setMethodMap(java.util.Map<java.lang.String, org.springframework.transaction.interceptor.TransactionAttribute>)`

### addTransactionalMethod

    public void addTransactionalMethod(String name,
                                       TransactionAttribute attr)

  Add an attribute for a transactional method.

  Method names can end or start with "*" for matching multiple methods.

  Parameters:
    `name` - class and method name, separated by a dot
    `attr` - attribute associated with the method
  Throws:
    `IllegalArgumentException` - in case of an invalid name

### addTransactionalMethod

    public void addTransactionalMethod(Class<?> clazz,
                                       String mappedName,
                                       TransactionAttribute attr)

  Add an attribute for a transactional method. Method names can end or start with "*" for matching multiple methods.

  Parameters:
    `clazz` - target interface or class
    `mappedName` - mapped method name
    `attr` - attribute associated with the method

### addTransactionalMethod

    public void addTransactionalMethod(Method method,
                                       TransactionAttribute attr)

  Add an attribute for a transactional method.

  Parameters:
    `method` - the method
    `attr` - attribute associated with the method

### isMatch

    protected boolean isMatch(String methodName,
                              String mappedName)

  Return if the given method name matches the mapped name.

  The default implementation checks for "xxx*", "*xxx" and "*xxx*" matches, as well as direct equality.

  Parameters:
    `methodName` - the method name of the class
    `mappedName` - the name in the descriptor
  Returns:
    if the names match
  See Also:
    `PatternMatchUtils.simpleMatch(String, String)`

### getTransactionAttribute

    public TransactionAttribute getTransactionAttribute(Method method,
                                                        Class<?> targetClass)

  Description copied from interface: `TransactionAttributeSource`
  Return the transaction attribute for this method. Return null if the method is non-transactional.

  Specified by:
    `getTransactionAttribute` in interface `TransactionAttributeSource`
  Parameters:
    `method` - method
    `targetClass` - target class. May be `null`, in which case the declaring class of the method must be used.
  Returns:
    TransactionAttribute the matching transaction attribute, or `null` if none found

### equals

    public boolean equals(Object other)

  Overrides:
    `equals` in class `Object`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `Object`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`