带有通用类的Java枚举

Question

I am switching gears from the interpreted world and I am trying to replicate a pattern I have used in the passed with great success but in Java.

The short of it is I am making a custom DAO (not using Hibernate or anything like that...ultimately it will be generic to handle different database engines (SQL and NoSQL). For breaking into I am just using a MySQL/ Prepared Statements.

I want to basically define a DataMapper object that is responsible for mapping the field of a record to the fields in a database. I am trying to encapsulate any redundant logic for implementation details of transforming a type to the format the database expects. In the DataMapper I am trying to utilize an enum to list the fields:

public abstract class AbstractDataMapper<X> {

public static abstract class Field<Y> {
    protected String name;
    public Field(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public abstract void setValue(PreparedStatement stmt, int parameterIndex, Y value) 
        throws SQLException;
    public abstract Y getValue(ResultSet rset)
        throws SQLException;
}

public static class IntegerField extends AbstractDataMapper.Field<Integer> {

    public IntegerField(String name) {
        super(name);
    }

    @Override
    public void setValue(PreparedStatement stmt, int parameterIndex,
            Integer value) throws SQLException {
        stmt.setInt(parameterIndex, value.intValue());
    }

    @Override
    public Integer getValue(ResultSet rset) throws SQLException {
        return new Integer(rset.getInt(this.name));
    }
}
}


public class UserDataMapper extends AbstractDataMapper<UserDataRecord>{
    public static enum Field {
    entryId(new AbstractDataMapper.IntegerField("entryid"));

    AbstractDataMapper.Field<?> field = null;

    Field(AbstractDataMapper.Field<?> field) {
        this.field = field;
    }

    public AbstractDataMapper.Field<?> getField() {
        return this.field;
    }

    public String getName() {
        return this.field.getName();
    }
}

Obviously I tried to truncate the example to the meaningful parts. The client code for exercising this

    public int insert(UserDataRecord user) {
    ...
        final String query = 
            "INSERT INTO users SET "
            + UserDataMapper.Field.entryId.getName() + " = ? ";

        stmt = conn.prepareStatement(query);
        UserDataMapper.Field.entryId.getField()
            .setValue(stmt, 1, user.getEntryId());

       }

The issue I am encountering is with the last line. I am trying to use the generic object associated with the entryId enum to use it's special setValue function which handles getting the Integer into the proper format. My IDE is giving me the following error: The method setValue(PreparedStatement, int, capture#13-of ?) in the type AbstractDataMapper.Field is not applicable for the arguments (PreparedStatement, int, Integer).

I am sure I could get into a series of crazy typecasts...but at that point it would probably just be easier to expose the translation details.

Any ideas on getting this to work or a modification to this pattern that is better?

Answer 1

enum can't be generic, so there's a problem for your case.

a simpler way of casting would be

public static enum Field {

public <T> AbstractDataMapper.Field<T> getField() {
    return (AbstractDataMapper.Field<T>)this.field;
}

// usage
UserDataMapper.Field.entryId.<Integer>getField()

The bigger question is, what's the point of using enum here? It would be much simpler to use some static public final fields.

public class UserDataMapper extends AbstractDataMapper<UserDataRecord>{

    public interface Fields {
        IntegerField entryId = new IntegerField("entryid"));

----

    final String query = 
        "INSERT INTO users SET "
        + UserDataMapper.Field.entryId.getName() + " = ? ";

    stmt = conn.prepareStatement(query);
    UserDataMapper.Field.entryId
        .setValue(stmt, 1, user.getEntryId());

Answer 2

This happens because the field in the enum is an AbstractDataMapper.Field<?> and not an AbstractDataMapper.Field<Integer> . When you call setValue on it, it expects some type that the compiler identifies as "capture#13-of ?", and not an Integer (or int which is autoboxed to an Integer ).

If you are going to put fields with different, unrelated data types in the Field enum, then there's really no other way than to declare the field member variable as AbstractDataMapper.Field<?> (with the question mark), and you're not going to avoid to cast it when you need to use it. You could add a @SuppressWarnings annotation to suppress the compiler warning:

@SuppressWarnings("unchecked")
AbstractDataMapper.Field<Integer> field =
    (AbstractDataMapper.Field<Integer>)UserDataMapper.Field.entryId.getField();

field.setValue(stmt, 1, user.getEntryId());