Java构建用于排序的特定自定义比较器

Question

I am working on an ORM system (Object relational mapping, basically a wrapper in java classes such that I don't need to use SQL code directly)

This question goes about searching in a table, by specyfing constraints:

public final List<B> search(final AbstractConstraint... c) throws SearchException {
    if (c.length == 0) {
        throw new IllegalArgumentException("orm.Manager.search: c.length == 0");
    }
    try {
        List<B> beans = new ArrayList<>();

        for (AbstractConstraint constraint : c) {
            try (PreparedStatement ps = new QueryBuilder(connection, tableName(), getPaths(), searchQuery()).add(constraint).build();
                    ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    beans.add(createBean(rs));
                }
            }
        }

        if (c.length > 1) {
            boolean sorting = true;
            Field field = c[0].getField();
            Order order = c[0].getOrder();
            for (int i = 1; i < c.length; i++) {
                Field currentField = c[i].getField();
                Order currentOrder = c[i].getOrder();
                if (!field.equals(currentField) || !order.equals(currentOrder)) {
                    sorting = false;
                    break;
                }
            }
            if (sorting) {
                //sort on field with comparator of supertype
            }
        }

        return beans;
    } catch (SQLException ex) {
        Logger.getLogger(Manager.class.getName()).log(Level.SEVERE, null, ex);
        throw new SearchException(ex);
    }
}

Normally the AbstractConstraint itself takes care of the order. But there is a special case if you are using multiple AbstractConstraints (essentially my counterpart to the SQL OR ). If two of those individual AbstractConstraints (which are already ordered), share the same ordering, then the resulting List<B> should be in total also ordered, and not contain two ordered lists stacked on top of eachother.

How would I go about doing that? This is what I know:

• The Field object, specyfing on which field should be searched, this is a direct reference to a column in a table in an SQL database.
• The Order object

So I am thinking that (in my current implementation), columns (thus fields) can have the following values:

• String (in SQL varchar)
• Integer (in SQL int)
• Date (in SQL datetime)
• BigInteger (in SQL decimal)

And the orderings would be ascending or descending.

How would I need to extend my Field class to capture the type of the column? This is all what Field is currently:

public interface Field {
    public String getFieldName();
}

And how would I write the Comparator ? Actually, do I even have to write the Comparator or should I let Field implement Comparable in some way?

I hope the question is understandable and looking forward to any responses.

EDIT: Adding example of concrete implementation of Field :

public enum InvoiceFields implements Field {
    invoiceId("invoices.invoiceId"),
    businessPartnerId("invoices.businessPartnerId"),
    invoiceNumber("invoices.invoiceNumber"),
    invoiceDate("invoices.invoiceDate"),
    priceExclVAT("invoices.priceExclVAT"),
    VAT("invoices.VAT"),
    priceInclVAT("invoices.priceInclVAT"),
    paymentDiscount("invoices.paymentDiscount"),
    status("invoices.status");

    private final String enumName;

    private InvoiceFields(final String enumName) {
        this.enumName = enumName;
    }

    @Override
    public String getFieldName() {
        return enumName;
    }
}

Answer 1

I think you want an abstract class. ie then create subclasses for each of your different type of fields.

public abstract class Field implements Comparable<Field> {

public abstract String getFieldName();

public int compareTo(Field field) {
return 0;
}
}