Java动态获取实现类的方式详解

/**
 * 根据接口和注解@SupportCodes的值，获取接口实现类
 *
 * @param interfaceClass 接口
 * @param sopportCode 接口实现类的注解@SupportCodes的值
 * @return 接口实现类
 */
public static <T> T getServiceImpl(Class<T> interfaceClass, String sopportCode)
{
  // 如果没有初始化，则初始化
  if (null == serviceImplFactoryMap.get(interfaceClass)) {
    // 初始化
    init(interfaceClass);
    if (null == serviceImplFactoryMap) {
      return null;
    }
  }
  // 如果初始化后，还是没有，则返回null
  if (null == serviceImplFactoryMap.get(interfaceClass)) {
    return null;
  }
  // 返回接口实现类
  return (T)((Map)serviceImplFactoryMap.get(interfaceClass)).get(sopportCode);
}

/**
 * 初始化
 *
 * @param interfaceClass 接口
 * @author javaself
 */
protected static <T> void init(Class<T> interfaceClass) {
  log.info("begin to init " + interfaceClass);
  synchronized (FactoryUtil.class) {
    try {
      // 如果已经初始化，则返回
      if (null != serviceImplFactoryMap.get(interfaceClass)) {
        return;
      }
      
      Map<String, Object> serviceMap = new HashMap();
      // 获取所有实现类
      Map<String, T> beans = appContext.getBeansOfType(interfaceClass); //实现类名字作为key，实现类实例作为value
      Set<Entry<String, T>> entrySet = beans.entrySet();
      Iterator<Entry<String, T>> iterator = entrySet.iterator();
      // 遍历所有实现类，获取注解@SupportCodes的值，作为key，实现类实例作为value
      while (iterator.hasNext()) {
        Object interfaceServiceImpl = ((Entry)iterator.next()).getValue();
        SupportCodes annotationValue = (SupportCodes)interfaceServiceImpl.getClass().getAnnotation(SupportCodes.class);
        if (null != annotationValue) {
          for (String flag : annotationValue.value()) { //可能有多个注解值，所以遍历
            //写到map： key=注解值，value=实现类实例
            serviceMap.put(flag, interfaceServiceImpl); 
            log.info(flag + "=>" + interfaceServiceImpl.getClass());
          }
        }
      }
      
      //写到map： key=接口，value=上面的map
      serviceImplFactoryMap.put(interfaceClass, serviceMap);
    } catch (Exception e) {
      log.error("init failed", e);
      throw new RuntimeException(e);
    }
  }
  log.info(interfaceClass + "inited");
}

IGetPayInstructionService payService = FactoryUtil.getServiceImpl(IGetPayInstructionService.class, channelCode);

package com.xxx.commons.factory;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.stereotype.Component;

/**
 * 工厂工具类：用于获取接口实现类
 *
 * ---
 * 应用场景：当一个接口有多个实现类时，通过该工具类获取对应的实现类。
 * 不同实现类，通过注解@SupportCodes来区分。获取的时候，也是通过@SupportCodes的值来获取。
 *
 * ---
 * 举例说明
 *
 * 不同渠道的支付接口，都实现了IPayService接口，如下：微信支付、支付宝支付
 *
 * @author javaself
 */
@Component
public class FactoryUtil
  implements ApplicationContextAware
{
  private static Log log = LogFactory.getLog(FactoryUtil.class);
  private static Map<Class<?>, Map<String, Object>> serviceImplFactoryMap = new HashMap();
  private static AbstractApplicationContext appContext;

  /**
   * 根据接口和注解@SupportCodes的值，获取接口实现类
   *
   * @param interfaceClass 接口
   * @param sopportCode 接口实现类的注解@SupportCodes的值
   * @return 接口实现类
   */
  public static <T> T getServiceImpl(Class<T> interfaceClass, String sopportCode)
  {
    // 如果没有初始化，则初始化
    if (null == serviceImplFactoryMap.get(interfaceClass)) {
      // 初始化
      init(interfaceClass);
      if (null == serviceImplFactoryMap) {
        return null;
      }
    }
    // 如果初始化后，还是没有，则返回null
    if (null == serviceImplFactoryMap.get(interfaceClass)) {
      return null;
    }
    // 返回接口实现类
    return (T)((Map)serviceImplFactoryMap.get(interfaceClass)).get(sopportCode);
  }

  /**
   * 初始化
   *
   * @param interfaceClass 接口
   * @author javaself
   */
  protected static <T> void init(Class<T> interfaceClass) {
    log.info("begin to init " + interfaceClass);
    synchronized (FactoryUtil.class) {
      try {
        // 如果已经初始化，则返回
        if (null != serviceImplFactoryMap.get(interfaceClass)) {
          return;
        }

        Map<String, Object> serviceMap = new HashMap();
        // 获取所有实现类
        Map<String, T> beans = appContext.getBeansOfType(interfaceClass); //实现类名字作为key，实现类实例作为value
        Set<Entry<String, T>> entrySet = beans.entrySet();
        Iterator<Entry<String, T>> iterator = entrySet.iterator();
        // 遍历所有实现类，获取注解@SupportCodes的值，作为key，实现类实例作为value
        while (iterator.hasNext()) {
          Object interfaceServiceImpl = ((Entry)iterator.next()).getValue();
          SupportCodes annotationValue = (SupportCodes)interfaceServiceImpl.getClass().getAnnotation(SupportCodes.class);
          if (null != annotationValue) {
            for (String flag : annotationValue.value()) { //可能有多个注解值，所以遍历
              //写到map： key=注解值，value=实现类实例
              serviceMap.put(flag, interfaceServiceImpl);
              log.info(flag + "=>" + interfaceServiceImpl.getClass());
            }
          }
        }

        //写到map： key=接口，value=上面的map
        serviceImplFactoryMap.put(interfaceClass, serviceMap);
      } catch (Exception e) {
        log.error("init failed", e);
        throw new RuntimeException(e);
      }
    }
    log.info(interfaceClass + "inited");
  }
  
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
  {
    appContext = (AbstractApplicationContext)applicationContext;
  }
}

package com.xxx.commons.factory;

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SupportCodes
{
  String[] value();
}

/**
 * 微信公众号支付
 * 
 */
@SupportCodes("WeChatPay")
@Service
public class WeChatPayService implements IGetPayInstructionService {