具有生成器模式的Java泛型类型DSL

我尝试使用泛型类型上的生成器模式创建一个DSLJavaAPI

我有以下课程：

public class Rule<T> {

  private Predicate<T> condition;

  public ConditionBuilder<T> when() {
    return new ConditionBuilder<>(this);
  }

  //setter and getter 

}

公共类规则{
私有谓词条件；
公共条件生成器when（）{
返回新的条件生成器（此）；
}
//接二连三
}

以及以下ConditionBuilder类：

public class ConditionBuilder<T> {

  private Rule<T> parent;

  public ConditionBuilder(Rule<T> parent) {
    this.parent = parent;
  }

  public ConditionBuilder<T> condition1() {
    parent.setCondition(l -> l == 0); // I would like an Integer
    return this;
  }

  public ConditionBuilder<T> condition2() {
    parent.setCondition(l -> l.length() > 3); // I would like a String
    return this;
  }

}

公共类条件生成器{
私治父母；
公共条件生成器（规则父级）{
this.parent=parent；
}
公共条件生成器条件1（）{
setCondition（l->l==0）；//我想要一个整数
归还这个；
}
公共条件生成器条件2（）{
parent.setCondition（l->l.length（）>3）；//我想要一个字符串
归还这个；
}
}

我试图找到一种解决方案，将condition1（resp.condition2）的泛型类型动态设置为整数（resp.String）

---

是否有任何模式或解决方案可以避免执行

instanceof

检查？

您不能使用

ConditionBuilder

上的成员方法执行此操作，因为在调用任何

conditionX

方法之前，您已经构建了

父对象。因此，不能“事后”约束实例

我这样做的方法是将
规则
作为静态方法的参数。然后，您可以使用以下内容：

static ConditionBuilder<Integer> condition1(ConditionBuilder<Integer> parent) {
  parent.setCondition(l -> l == 0);
  return parent;
}

static ConditionBuilder<String> condition2(ConditionBuilder<String> parent) {
  parent.setCondition(l -> l.length() > 3);
  return parent;
}

static ConditionBuilder condition1（ConditionBuilder父级）{
父.setCondition（l->l==0）；
返回父母；
}
静态ConditionBuilder condition2（ConditionBuilder父级）{
父.setCondition（l->l.length（）>3）；
返回父母；
}
我会使用工厂模式，因为生成器模式不适合这种情况。使用泛型意味着您将接受任何类型，所以使
条件
需要特定类型是对泛型的浪费

public class Rule<T> {
  private Predicate<T> condition;
  //setter and getter
}

class ConditionFactory {
  public static Rule<Integer> intCondition() {
    Rule<Integer> rule = new Rule<>();
    rule.setCondition(l -> l == 0);
    return rule;
  }

  public static Rule<String> strCondition() {
    Rule<Integer> rule = new Rule<>();
    rule.setCondition(l -> l.length() > 3);
    return rule;
  }
}

公共类规则{
私有谓词条件；
//接二连三
}
类条件工厂{
公共静态规则intCondition（）{
规则=新规则（）；
规则.setCondition（l->l==0）；
返回规则；
}
公共静态规则结构条件（）{
规则=新规则（）；
规则.setCondition（l->l.length（）>3）；
返回规则；
}
}
你能描述一下你想要完成的更广泛的任务吗？为什么需要
condition1
和
condition2
来执行此操作？为什么不使用
谓词作为参数？如果不想使用泛型类型，请不要使用泛型。（请注意，
Integer
是最终的，因此
t extends Integer
是多余的。最好直接使用
Integer
），这会破坏生成器模式。我仍然不知道这些方法会起到什么作用。我觉得如果OP要追求构建器模式，它们就不应该存在。@4castle它是否破坏了模式并不重要；没有其他（明显的）方法在编译时影响这样的约束。