4

我发现自己需要重写一个静态方法，仅仅是因为它最有意义，但我也知道这是不可能的。

超类Entity.java：

abstract public class Entity<T> {
    public Entity() {
        //set up database connection
    }

    abstract public static Map<Object, T> getAll();

    abstract public void insert();

    abstract public void update();

    protected void getData(final String query) {
        //get data via database
    }

    protected void executeQuery(final String query) {
        //execute sql query on database
    }
}

许多具体实现之一，Account.java：

public class Account extends Entity<Account> {
    private final static String 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;
    }

    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;
    }

    @Override
    public static Map<Object, Account> getAll() {
        //return a map using the ALL_QUERY string, calls getData(string);
    }

    @Override
    public void insert() {
        //insert this using INSERT_QUERY, calls executeQuery(string);
    }

    @Override
    public void update() {
        //update this using UPDATE_QUERY, calls executeQuery(string);
    }
}

我没有深入解释代码，但任何一般性的反馈也将不胜感激，我希望评论能解释清楚。

所以基本上我认为我们都同意 usingAccount.getAll()更有意义new Account().getAll()（如果我会为它引入一个虚拟语法）。但是我确实想让它扩展Entity类，目前它只是为了方便，但稍后我可能不得不使用集合/列表/多集合并对所有这些Entity执行update()操作，例如，如果我要构建一些队列表演每分钟更新一次。

那么，有没有办法getAll()正确构建？

问候。

4

2 回答 2

1

您可以为所有元素的操作设置单独的类：

abstract public class Collection<T extends Entity<T>> {
    abstract public static List<T> getAll();
    public void printAll() {
        // Print all entries of List obtained from getAll()
    }
}

您可以将其用作：

public class Accounts extends Collection<Account> {
    @Override
    public List<Account> getAll() {
        //return a list using the ALL_QUERY string, calls getData(string);
    }
}
于 2013-05-13T20:01:47.640 回答
1

在我看来，这并不是真的“仅仅因为它最有意义”。

将持久性绑定在您的实体上并不是一个好主意。已经有很多模式可以针对这个问题进行适当的设计。

例如，在领域驱动设计中，“持久性无知”是人们试图实现的目标。考虑为您的每个实体创建一个存储库：

interface Repository<T> {
    List<T> findAll();
    void insert(T);
    void update(T);
}

所以你可以用任何你想要的方式覆盖它：

interface UserRepository extends Repository<User> {
    // some other methods which is meaningful for User
    User findByLoginName(String loginName);
}


class UserRepositoryImpl implements UserRepository {
    List<User> findAll() {
         // call whatever query
    }
    void insert(T){...}
    void update(T){...}
    User findByLoginName(String loginName) {...}
}

通过适当的设计和处理实体检索/存储的组件，您可以拥有一个较少持久性耦合的实体，以及可以执行适当“覆盖”的存储库。

于 2013-05-14T01:55:06.270 回答