Question

我在静态方法中使用常规类型时遇到了一些麻烦。

欢迎所有关于源代码的评论，特别是那些显着改进代码的评论。我目前还没有计划使用除JDBC之外的任何外部框架来保持简单，请不要过分强调它。

我不会使用外部框架的观点也得到以下事实的支持：我将在数据库中使用的操作非常少：

插入数据
更新数据
检索所有字段。（只需输入不同的SQL查询，您就可以选择要检索的字段

我不打算制作一个完整的框架，所以我知道它不会支持所有内容。检索所有字段的速度既不是真正的问题，因为这几乎只在服务器启动时完成，并且如果在任何其他时间使用它将在后台任务中完成，我完全不关心它什么时候完成

Entity.java：

abstract public class Entity<KeyType, DataType> {
    protected KeyType key;
    protected List<Object> data;

    public Entity() {
        data = new ArrayList<>();
    }

    //abstract public static Map<KeyType, DataType> getAll();

    protected List<Object> createData(final DataAction dataAction) {
        List<Object> list = new ArrayList<>();
        if (dataAction == DataAction.INSERT) {
            list.add(key);
        }

        list.addAll(data);

        if (dataAction == DataAction.UPDATE) {
            list.add(key);
        }
        return list;
    }

    abstract public void insert();

    abstract public void update();

    protected static <KeyType, DataType> Map<KeyType, DataType> getData(final Class<DataType> dataTypeClass, final String query) {
        Map<KeyType, DataType> map = new HashMap<>();
        try {
            PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(query);
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                KeyType key = (KeyType)resultSet.getObject(1);
                int index = 2;
                List<Object> dataList = new ArrayList<>();
                while (resultSet.getObject(index) != null) {
                    dataList.add(resultSet.getObject(index));
                    index++;
                }
                DataType dataObject = null;
                try {
                    dataObject = dataTypeClass.getConstructor(List.class).newInstance(dataList);
                } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException ex) {
                    Logger.getLogger(Entity.class.getName()).log(Level.SEVERE, null, ex);
                }
                map.put(key, dataObject);
            }
        } catch (SQLException ex) {
            Logger.getLogger(Entity.class.getName()).log(Level.SEVERE, null, ex);
        }        
        return map;
    }

    protected void executeQuery(final String query, final List<Object> data) {
        try {
            PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(query);
            int dataIndex = 0;
            for (Object dataObject : data) {
                preparedStatement.setObject(dataIndex, dataObject);
                dataIndex++;
            }
            preparedStatement.execute();
            preparedStatement.close();
        } catch (SQLException ex) {
            Logger.getLogger(Entity.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

具体实现，Account.java：

public class Account extends Entity<String, Account> {
    private final static String SELECT_ALL_QUERY = "SELECT * FROM accounts";
    private final static String INSERT_QUERY = "INSERT INTO accounts (username, password) VALUES(?, ?)";
    private final static String UPDATE_QUERY = "UPDATE accounts SET password=? WHERE username=?";

    private String username;
    private String password;

    public Account(final String username, final String password) {
        this.username = username;
        this.password = password;

        key = username;
        data.add(password);
    }

    public Account(final List<Object> data) {
        this((String)data.get(0), (String)data.get(1));
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(final String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(final String password) {
        this.password = password;
    }

    public static Map<String, Account> selectAll() {
        return getData(Account.class, SELECT_ALL_QUERY);
    }

    @Override
    public void insert() {
        executeQuery(INSERT_QUERY, createData(DataAction.INSERT));
    }

    @Override
    public void update() {
        executeQuery(UPDATE_QUERY, createData(DataAction.UPDATE));
    }
}

我对具体的实现感到高兴，似乎我已经设法将其降低到最低限度，除了public Account(final List<Object> data)似乎不太好，但我可以忍受它。

然而，正如猜测的那样，来自getData()的{{1}}肯定不是很好，我想尽可能改进它。

我想使用的是类似Entity的内容，但似乎无法实例化Generic Type Arguments。

那么有什么方法可以在我当前的视图中优化我当前的代码吗？是否有可能将具体类和抽象类分离得更多？

编辑：

添加了相关问题（我不认为我应该为这件事提出一个全新的问题，对吗？）：

有没有办法将静态字符串（SQL查询）和DataType dataObject = new DataType(dataList)和insert()移出Account类，进入实体类？

Answer 1

为了避免在getData方法中使用反射，您应该接受一个给定ResultSet创建特定类型实例的工厂。您的selectAll方法将类似于：

public static Map<String, Account> selectAll() 
{
  return getData(
    new EntityFactory<Account>()
    {
      public Account newInstance(ResultSet resultSet) throws SQLException
      {
        return new Account(resultSet.getString(0), resultSet.getString(1));
      }
    },
    SELECT_ALL_QUERY
  );
}

然后getData方法结束如下：

protected static <K, T extends Entity<K>> Map<K, T> getData(EntityFactory<T> entityFactory, String query) 
{
  Connection connection = null;
  PreparedStatement preparedStatement = null;      
  ResultSet resultSet = null;

  try 
  {
    connection = dataSource.getConnection();

    preparedStatement = connection.prepareStatement(query);

    resultSet = preparedStatement.executeQuery();

    Map<K, T> entities = new HashMap<>();

    while (resultSet.next()) 
    {
      Entity<K> entity = entityFactory.newInstance(resultSet);
      entities.put(entity.getKey(), entity);
    }

    return entities;
  }
  finally 
  {
    closeQuietly(resultSet);
    closeQuietly(prepareStatement);
    closeQuietly(connection);
  }
}

并假设Entity看起来像：

public interface Entity<K>
{
  public K getKey();
}

这允许您删除反射并将理解数据库结构的代码保存在一个位置。在进行插入和更新时，您还应该使用类似的模板模式从域对象映射到预准备语句。

现在您已经要求对代码提出意见。

首先，像这样的代码违反了Single Responsibility Principal和Seperation Of Concerns。域类应该是域类，不包含持久性逻辑。看看像Data Access Object这样的模式，看看应该如何做。

其次，虽然我只是为了保持简单，Hibernate很久以前就解决了这个问题并JPA对其进行了标准化 - 你需要一个很好的理由不使用这些中的一个或两个的API。

最后，您使用数据库资源 - 如果您要直接使用JDBC，则必须正确清理。数据库连接是昂贵的资源，应该这样处理，任何JDBC调用的基本模板应该是：

Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;

try 
{
  connection = //get connection from pool or single instance.

  preparedStatement = connection.prepareStatement("SELECT * FROM table WHERE column = ?");
  preparedStatement.setString(1, "some string");

  resultSet = preparedStatement.executeQuery();

  while (resultSet.next())
  {
    //logic goes here.
  }
}
catch (SQLException e)
{
  //Handle exceptions.
}
finally 
{
  closeQuietly(resultSet);
  closeQuietly(prepareStatement);
  closeQuietly(connection);
}

closeQuietly方法必须重载，但应采用一般形式：

try 
{
  if (resultSet != null)
  {
    resultSet.close();
  }
}
catch (SQLException e)
{  
  //Log exceptions but don't re-throw.
}

Answer 2

好吧，正如Darwind和Nick Holt告诉你的那样，在正常情况下，你应该使用JPA，这是对象关系映射的Java标准规范。您可以使用Hibernate，EclipseLink或其他任何框架。他们的设计可以管理连接，交易。此外，使用标准而不是异国情调的框架意味着您可以更轻松地为社区获得帮助。另一种选择是使用Spring JDBC，它非常简单并且可以促进很多事情。

无论如何，我想你是出于学习目的这样做的，所以让我们试着走得更远。

首先，我认为你应该分开负责的类或检索数据（称之为管理器或数据访问对象 - DAO - ）和表示数据本身的entites。

对我来说，使用类来获取所有数据本身并不是问题。问题是密钥的位置是硬编码的。这不应该直接确定为通用（我的意思是对所有实体实现都相同）。当第一个字段不是密钥时，这会使查询成为错误（您确定select * from...总是会在第一个位置返回密钥吗？）或使用复合密钥。我认为更好的解决方案是创建一个Mapper接口并为每个实体实现它。

public interface RecordMapper<KeyType, DataType extends Entity> {
    public void appendToMap(ResultSet resultSet, Map<KeyType, DataType>) throws SQLException;
}

mapper的实现应该负责实例化你的实体，从结果集中检索密钥，填充你的实体并将它放在你期望的地图中。

public class AccountMapper implement RecordMapper<String, Account>{
    public void appendToMap(ResultSet resultSet, Map<String, Account> accounts) throws SQLException {
        String user= resultSet.getString("userName");
        String pwd= resultSet.getString("passWord");
        Account account = new Account(user, pwd);
        accounts.put(user, account);
    }
}

正如我所说，你应该在DAO中移动你的数据访问方法：公共课DAO {

    public <KeyType, DataType> Map<KeyType, DataType> getData(final RecordMapper<KeyType, DataType> mapper, final String query) {
        Map<KeyType, DataType> map = new HashMap<>();
        try {
            PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(query);
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                mapper.appendToMap(resultSet, map);
            }
        } catch (SQLException ex) {
            Logger.getLogger(Entity.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            if(resultSet != null){
                try{resultSet.close();} catch (Exception e){}
            }
            if(preparedStatement!= null){
                try{preparedStatement.close();} catch (Exception e){}
            }
        }
        return map;
    }


    public void executeQuery(final String query, final List<Object> data) {
        try {
            PreparedStatement preparedStatement = DatabaseConnection.getConnection().prepareStatement(query);
            int dataIndex = 0;
            for (Object dataObject : data) {
                preparedStatement.setObject(dataIndex, dataObject);
                dataIndex++;
            }
            preparedStatement.execute();
        } catch (SQLException ex) {
            Logger.getLogger(Entity.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            if(resultSet != null){
                try{resultSet.close();} catch (Exception e){}
            }
            if(preparedStatement!= null){
                try{preparedStatement.close();} catch (Exception e){}
            }
        }
    }
}

为了回答你的第二次谴责，我认为将你的请求字符串放在抽象的父级而不是当然不是一个好主意。每次创建新实体时，都必须在父实体中创建新查询。奇怪......除非我没有正确理解你的问题。

Personnaly我认为应该动态构建查询，你应该使用reflection和annotations，但答案应该有点长。再一次，您可以查看JPA，了解创建实体应该是什么样子。顺便说一下，如果实体不必扩展父实体类，那应该更好。

Java Data-Entity模型：构造一般类型

2 个答案: