根据子类创建父类泛型中的实体对象（模版方法和策略模式结合）

经常在模版方法中会遇见这种需求，

例如 父类

/**
 * 解析抽象类
 * @param <T>
 */
public abstract class AbstractStrategy<T extends Feature> {

// 方法骨架
    public final void handleXml(Element element) {
        // 创建基础对象
        T bean = createBean();
        // 赋值基础数据（包含处理子节点）
        setBasic(element, bean);
    }

    /**
     * 1 创建实体
     */
    public T createBean() {
        T t = null;
        try {
            Class<T> clz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
            t = clz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return t;
    }

   


     
    public abstract  void setBasic(Element element, T o) ;
       
}

具体子类

package com.atm.ep.aixm.server.strategy.airport;

import com.atm.ep.aixm.server.model.SurfaceCharacteristics;
import com.atm.ep.aixm.server.model.airport.AircraftStand;
import com.atm.ep.aixm.server.model.geometry.ElevatedPoint;
import com.atm.ep.aixm.server.strategy.AbstractStrategy;
import com.atm.ep.aixm.server.utils.BeanUtilPro;
import com.atm.ep.aixm.server.utils.UUIDUtil;

import org.dom4j.Element;


import java.util.Objects;

/**
 * 停机坪解析
 */


public class AircraftStandStrategy extends AbstractStrategy<AircraftStand> {

 void setBasic(element, bean){
// 具体业务逻辑
   }
       

}

在子类实现父类的时候 自动根据泛型去创建实体

静态工厂类

根据参数类型自动选择不同的实现类（策略模式）

**
 * 策略静态工厂类
 */
public class StrategyFactory {
    // key:实体名称 value:具体实现类
    private static final Map<String, AbstractStrategy<?>> CLASS_MAP = new HashMap<>();

    static {
        // AbstractStrategy下所有实现类
        List<Class<?>> classes = ClassUtil.getClasses(AbstractStrategy.class);
        try {
            assert classes != null;
            for (Class<?> aClass : classes) {
                // 子类中对应的实体
                Type genericSuperclass = aClass.getGenericSuperclass();
                String typeName = genericSuperclass.getTypeName();
                String[] split = typeName.split("\\.");
                if (Objects.equals(typeName, "java.lang.Object")) continue;

                int length = split.length;
                // 子类对应的实体名称
                String simpleName = split[length - 1].replace(">", "");
                CLASS_MAP.put(simpleName, (AbstractStrategy<?>) aClass.newInstance());
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取具体策略
     * @param type 实体类型
     * @return 具体策略实现子类
     */
    public static AbstractStrategy<?> getStrategy(String type){
        return CLASS_MAP.get(type);
    }
}

classUtil

public class ClassUtil {

    public static List<Class<?>> getClasses(Class<?> cls) {
        try {
            String pk = cls.getPackage().getName();
            String path = pk.replace('.', '/');
            ClassLoader classloader = Thread.currentThread().getContextClassLoader();
            URL url = classloader.getResource(path);
            try {
                return getClasses(new File(url.toURI().getPath()), pk);
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 迭代查找类
     *
     */
    private static List<Class<?>> getClasses(File dir, String pk) throws ClassNotFoundException {
        List<Class<?>> classes = new ArrayList<Class<?>>();
        if (!dir.exists()) {
            return classes;
        }
        for (File f : dir.listFiles()) {
            if (f.isDirectory()) {
                classes.addAll(getClasses(f, pk + "." + f.getName()));
            }
            String name = f.getName();
            if (name.endsWith(".class")) {
                Class<?> aClass = Class.forName(pk + "." + name.substring(0, name.length() - 6));
                classes.add(aClass);
            }
        }
        return classes;

    }
}

调用方伪代码

      for (Element cla : elements) {
                String claName = cla.getName();
                // 根据不同类型参数 获取不同的策略类
                AbstractStrategy<?> strategy = StrategyFactory.getStrategy(claName);
                if (strategy != null) {
                    strategy.handleXml(cla);
                }
            }