我正试图在我的minecraft服务器中开发一个统计/成就系统。
我做了一些研究，但仍然不能很好地做出决定，所以决定在堆栈溢出中发布我的第一个问题。
有多种类型的成就，如断块、收割作物、杀死动物。。等等。表初始值设定项看起来是这样的。(我有意将这些值设置为双倍(
public static void init() {
String query = "CREATE TABLE IF NOT EXISTS statistic ("
+ " uuid VARCHAR(255) PRIMARY KEY,"
+ " block_break double, crop_break double, ore_break double,"
+ " wood_break double, animal_kill double, monster_kill double, boss_kill double,"
+ " fish_natural double, fish_auto double "
+ ")";
try {
Connection conn = HikariPoolManager.getInstance().getConnection();
PreparedStatement ps = conn.prepareStatement(query);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
我用这个把它存回来
public static void save(String uuidString, StatisticsType stat, double val) {
String query= "INSERT INTO statistics (uuid, {stat}) "
+" VALUE (?,?) ON DUPLICATE KEY UPDATE "
+" uuid=VALUES( uuid ), {stat}=VALUES( {stat} )"
.replace("{stat}", stat.name());
try (Connection conn = HikariPoolManager.getInstance().getConnection();
PreparedStatement ps = conn.prepareStatement(query)
){
ps.setString(1, uuidString);
ps.setDouble(2, val);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
PlayerCache.java
public class PlayerCache {
@Getter
private static final Map<UUID, PlayerCache> cacheMap = new HashMap<>();
private final UUID uuid;
@Getter
private HashMap<StatisticsType, Double> statistics;
@Getter
private HashSet<StatisticsType> changed;
public PlayerCache(UUID uuid) {
this.uuid= uuid;
}
public void init(HashMap<StatisticsType,Double> achievements) {
this.statistics = new HashMap<>();
this.changed = new HashSet<>();
this.statistics.putAll(achievements);
}
public void addValue(StatisticsType type, double addition) {
statistics.put(type, statistics.get(type) + addition);
changed.add(type);
}
public double getStatistic(StatisticsType type) {
return statistics.getOrDefault(type, 0.0D);
}
public void save() {
for (StatisticsType statisticsType : changed) {
StatisticDAO.save(uuid.toString(),statisticsType, getStatistic(statisticsType));
}
changed.clear();
}
public static PlayerCache get(final UUID uuid) {
PlayerCache playerCache = cacheMap.get(uuid);
if (playerCache == null) {
playerCache = new PlayerCache(uuid);
cacheMap.put(uuid, playerCache);
}
return playerCache;
}
}
我对编程的一般设计有疑问，而不是修复代码本身。
目前，事情就是这样发展的。为了简单起见，让我选择两个统计动作——打碎石头和杀死怪物。
玩家加入游戏，读取数据，制作玩家缓存，并将统计信息放入缓存。
玩家打碎石头，它会增加玩家缓存中的统计数据。
如果玩家打碎了石头，它会切换一个布尔标志来显示他已经打碎了石头。因此，这些信息需要在某个时候刷新到数据库中。
服务器循环所有玩家，并检查玩家是否做了任何事情。若玩家做了一些事情，它会调用sql保存方法，并将布尔标志切换回。
然而，这次我遇到的问题很少。
玩家可以在写入数据库的过程中打碎石头，杀死怪物。或者甚至更多不同的动作。这将导致玩家调用多个保存函数。有更好的方法来处理这个问题吗？
我读写数据的一般方法正确吗？我几乎用同样的方法对其他功能做数据库的事情，但不确定这是否是一个好方法。
在极少数情况下，这是一种正确的做事方式；但你确实提到了一个数据访问对象。DAO遵循一种模式，但这种模式是通用的。根据您的需要，实际对象可能包含更多(或更少(数据，或者被结构化为回到一个(或多个表(。
DAO模式是一个对数据库执行所有直接操作的类。它至少包括add(Object)、remove(Object)、get(id)，可能还有getAll()，但也可以包括getOldest()、remove(id)等等
它通常不应该直接公开底层的表结构。因此，从某种意义上说，您的方法(通过公开UUID和要独立更新的stat(并没有遵循模式。
public class PlayerStats {
// contains a UUID field, as well as other stat fields
}
public class PlayerStatsDAO {
public PlayerStatsDAO(DatabaseConnection connection) {
// store the connection and check the connection
}
public void update(PlayerStats value) {
}
public void add(PlayerStats value) {
}
public void addOrUpdate(PlayerStats value) {
}
public PlayerStats newEmptyStats() {
}
public void remove(PlayerStats value) {
}
// as well as searching methods
public PlayerStats statsForUUID(UUID uuid) {
}
public PlayerStats statsForPlayerName(String name) {
}
public PlayerStats mostBockBreaks() {
}
... etc ...
}
DAO的优点是，如果您稍后决定更改底层表(或一组联接表(，则有一个位置可以绑定现有的"；数据对象"；到新的表结构。
That will result multiple save functions to be called from a player. Is there better way to deal with this?
我认为您正在加剧为一个玩家运行多个SQL插入语句的严重性。在Minecraft服务器上，数据库上根本不会有太多负载，而且您使用Hikari的事实确保了这些额外的查询对性能的影响可以忽略不计。
然而，如果非常确信您所处的环境对性能非常敏感(对于Minecraft插件来说，这可能不是(，那么可以考虑运行批处理SQL语句，或者将同一玩家的更新手动组合为一条语句，并将其发送到SQL数据库。
对我来说，你应该使用一个对象来保存所有信息，并只在你需要的时候保存它们。例如：StatsPlayer。
您有一个静态映射：HashMap<UUID, StatsPlayer>，其中包含所有玩家实例。
每个实例都包含这样的所有信息：
private HashMap<StatisticsType, Double> stats;
或者：
private double blockBreak;
创建新实例时，不要忘记从DB获取信息，例如：
public StatsPlayer(Player p) {
try {
Connection conn = HikariPoolManager.getInstance().getConnection();
PreparedStatement ps = conn.prepareStatement("SELECT * FROM statistics WHERE uuid = ?");
ps.setString(1, p.getUniqueId().toString());
ResultSet rs = ps.executeQuery();
if(rs.next()) {
// get informations from ResultSet instance
} else {
// Insert line into database
}
} catch(Exception e) {
e.printStackTrace();
}
}
现在，你必须做一个像这样的静态getter：
public static StatsPlayer getPlayer(Player p) {
synchronized(PLAYERS) {
return PLAYERS.computeIfAbsent(p, StatsPlayer::new);
}
}
在StatsPlayer对象中，应该添加一个方法来更新值，并添加一个保存所有内容的方法：
public void save() {
try {
Connection conn = HikariPoolManager.getInstance().getConnection();
PreparedStatement ps = conn.prepareStatement("UPDATE statistics SET block_break = ? WHERE uuid = ?");
ps.setDouble(1, getBlockBreak());
ps.setString(2, p.getUniqueId().toString());
ps.executeUpdate(); // make the update
} catch(Exception e) {
e.printStackTrace();
}
}
最后，有时您应该保存对象，例如，只有当他们离开服务器或服务器停止时