Java范型类的一种使用

---

一. 背景和使用

• 今天在看项目代码的时候，发现一个范型类的使用方式，稍稍研究了一下，写了一个Demo。这种范型类的使用场景：多种产品(Adto,Bdto)具有相似的工作流(AbstractWorkflow)，但这些工作流(AWorkflow,BWorkflow)的处理方式有些区别，如设置产品，保存产品等，它们处理都是以产品为中心的，因此有这类需求的可以使用类似用法。

二. 实例

1. 产品实体DTO

// 1. PersonDTO
public class PersonDTO {
    private String name;
    private Integer age;

    public PersonDTO(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

   // getter and setter
}

// 2. CustomDTO：抽象产品DTO
public class CustomDTO<T> {
    private PersonDTO personDTO; // 产品共有属性
    private List<T> t; // 具体产品

    public CustomDTO(PersonDTO personDTO) {
        this.personDTO = personDTO;
    }
	// getter and setter
   
}

// 3. A产品，即T的一类
public class Adto {
    private String name;
    private String nameAndAge;

    public Adto(String name, String nameAndAge) {
        this.name = name;
        this.nameAndAge = nameAndAge;
    }
	// gettter and setter 
}

// 4. B产品，即T的一类
public class Bdto {
    private String name;

    public Bdto(String name) {
        this.name = name;
    }
    //getter and setter
    
}

2. 工作流

/**
 * @Description 1. 抽象工作流
 *    AbstractWorkflow：表示抽象工作流(如扫码页工作流)，其实现类包括药扫码页的工作流，非药扫码页的工作流
 *    T：表示一种产品，如药扫码页信息，非药扫码页信息
 *    ICustomSavePipline：表示每个产品都具有的抽象操作（如解析配置、插入、删除等），实现类表示各产品的具体操作
 */
public abstract class AbstractWorkflow<T> implements ICustomSavePipline<T>{
    @Autowired
    private ICustomSavePipline iCustomSavePipline;

    public void printTest(PersonDTO personDTO){
        // 封装CustomDTO配置
        CustomDTO<T> customDTO = new CustomDTO<>(personDTO);
        this.handle(customDTO,personDTO.getName(),(custom,name)->iCustomSavePipline.assembleDTO(custom,name));

        // 执行产品的具体操作
        iCustomSavePipline.saveTest(customDTO);
    }

    private void handle(CustomDTO<T> customDTO, String name, BiFunction<CustomDTO,String, List> biFunction){
        List<T> list = biFunction.apply(customDTO,name);
        customDTO.setT(list);
    }
}

// 2. A产品的工作流
@Component
public class AWorkflow extends AbstractWorkflow<Adto> {
    private Logger logger = LoggerFactory.getLogger(getClass());
	
	// A产品的saveTest操作
    @Override
    public int saveTest(CustomDTO<Adto> customDTO) {
        logger.info("AWorkflow:{}",JSON.toJSON(customDTO));
        return 0;
    }

	// 封装产品A
    @Override
    public List<Adto> assembleDTO(CustomDTO<Adto> customDTO, String name) {
        List<Adto> adtos = Lists.newArrayList();
        adtos.add(new Adto(name,customDTO.getPersonDTO().getAge()+name));
        return adtos;
    }
}

// 3. B产品的工作流
@Component
public class BWorkflow extends AbstractWorkflow<Bdto> {
    private Logger logger = LoggerFactory.getLogger(getClass());
	
	// B产品的saveTest操作
    @Override
    public int saveTest(CustomDTO<Bdto> customDTO) {
        logger.info("BWorkflow:{}",JSON.toJSON(customDTO));
        return 0;
    }

	// 封装产品B
    @Override
    public List<Bdto> assembleDTO(CustomDTO<Bdto> customDTO, String name) {
        List<Bdto> bdtos = Lists.newArrayList();
        bdtos.add(new Bdto(name));
        return bdtos;
    }
}

3. 抽象操作

public interface ICustomSavePipline<T> {
	// 抽象产品T的saveTest操作，具体实现在T对应产品的工作流中
    int saveTest(CustomDTO<T> customDTO);
	// 抽象产品T的封装产品操作，具体实现在T对应产品的工作流中
    List<T> assembleDTO(CustomDTO<T> customDTO, String name);
}

4. Manager.java

@Component
public class TestManager {
    @Autowired
    private AWorkflow aWorkflow;
    @Autowired
    private BWorkflow bWorkflow;

    public void test(){
        PersonDTO aPersonDTO = new PersonDTO("Aname",12);
        aWorkflow.printTest(aPersonDTO);

        PersonDTO bPersonDTO = new PersonDTO("bname",16);
        bWorkflow.printTest(bPersonDTO);
    }
}

5. 运行结果

AWorkflow:{"personDTO":{"name":"bname","age":16},"t":[{"name":"bname","nameAndAge":"16bname"}]}
BWorkflow:{"personDTO":{"name":"Aname","age":12},"t":[{"name":"Aname"}]}