[规格模式] #设计模式#

AndExpression.java

@RequiredArgsConstructor
public class AndExpression extends CompositeExpression {
    private final Expression left;
    private final Expression right;

    @Override
    public boolean compute(Map<String, Double> data) {
        return left.compute(data) && right.compute(data);
    }
}

CompositeExpression.java

public abstract class CompositeExpression implements Expression {

    @Override
    public Expression and(Expression a) {
        return new AndExpression(this, a);
    }

    @Override
    public Expression or(Expression a) {
        return new OrExpression(this, a);
    }

    @Override
    public Expression not(Expression a) {
        return new NotExpression(a);
    }
}

EqualExpression.java

@RequiredArgsConstructor
public class EqualExpression extends CompositeExpression {
    private final String indicatorName;
    private final double presetValue;

    @Override
    public boolean compute(Map<String, Double> data) {
        Double value = data.get(indicatorName);
        if (value == null)
            return true;
        return this.presetValue == value;
    }
}

Expression.java

public interface Expression {
    boolean compute(Map<String, Double> value);

    Expression and(Expression a);

    Expression or(Expression a);

    Expression not(Expression a);
}

NotExpression.java

@RequiredArgsConstructor
public class NotExpression extends CompositeExpression {
    private final Expression expression;

    @Override
    public boolean compute(Map<String, Double> data) {
        return !expression.compute(data);
    }
}

OrExpression.java

@RequiredArgsConstructor
public class OrExpression extends CompositeExpression {
    private final Expression left;
    private final Expression right;


    @Override
    public boolean compute(Map<String, Double> data) {
        return left.compute(data) || right.compute(data);
    }
}