More modernization for the database

server/src/main/java/dev/plex/Plex.java

@@ -1,6 +1,5 @@
 package dev.plex;
 
-import dev.plex.cache.DataUtils;
 import dev.plex.cache.PlayerCache;
 import dev.plex.config.Config;
 import dev.plex.handlers.CommandHandler;
@@ -8,15 +7,20 @@ import dev.plex.handlers.ListenerHandler;
 import dev.plex.hook.CoreProtectHook;
 import dev.plex.hook.PrismHook;
 import dev.plex.module.ModuleManager;
+import dev.plex.player.PlayerService;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.PunishmentManager;
 import dev.plex.services.ServiceManager;
 import dev.plex.storage.RedisConnection;
 import dev.plex.storage.SQLConnection;
+import dev.plex.storage.StorageExecutor;
 import dev.plex.storage.StorageType;
 import dev.plex.storage.player.SQLPlayerData;
 import dev.plex.storage.punishment.SQLNotes;
 import dev.plex.storage.punishment.SQLPunishment;
+import dev.plex.storage.repository.NoteRepository;
+import dev.plex.storage.repository.PlayerRepository;
+import dev.plex.storage.repository.PunishmentRepository;
 import dev.plex.util.BuildInfo;
 import dev.plex.util.BungeeUtil;
 import dev.plex.util.PlexLog;
@@ -52,10 +56,11 @@ public class Plex extends JavaPlugin
     private RedisConnection redisConnection;
 
     private PlayerCache playerCache;
-    private SQLPlayerData sqlPlayerData;
+    private PlayerRepository playerRepository;
+    private PlayerService playerService;
 
-    private SQLPunishment sqlPunishment;
-    private SQLNotes sqlNotes;
+    private PunishmentRepository punishmentRepository;
+    private NoteRepository noteRepository;
 
     private ModuleManager moduleManager;
     private ServiceManager serviceManager;
@@ -90,7 +95,7 @@ public class Plex extends JavaPlugin
             modulesFolder.mkdir();
         }
 
-        moduleManager = new ModuleManager();
+        moduleManager = new ModuleManager(this);
         moduleManager.loadAllModules();
         moduleManager.loadModules();
 
@@ -101,21 +106,23 @@ public class Plex extends JavaPlugin
     public void onEnable()
     {
         config.load();
+        PlexLog.setDebugEnabled(config.getBoolean("debug"));
         messages.load();
+        PlexUtils.configure(config, messages);
         toggles.load();
 
         // Don't add default entries to these files
         indefBans.load(false);
 
-        sqlConnection = new SQLConnection();
-        redisConnection = new RedisConnection();
+        sqlConnection = new SQLConnection(this);
+        redisConnection = new RedisConnection(this);
 
         playerCache = new PlayerCache();
 
         PlexLog.log("Attempting to connect to DB: {0}", plugin.config.getString("data.db.name"));
         try
         {
-            PlexUtils.testConnections();
+            PlexUtils.testConnections(this);
             PlexLog.log("Connected to " + storageType.name().toUpperCase());
         }
         catch (Exception e)
@@ -160,7 +167,7 @@ public class Plex extends JavaPlugin
             PlexLog.debug("Not hooking into SuperVanish / PremiumVanish");
         }
 
-        updateChecker = new UpdateChecker();
+        updateChecker = new UpdateChecker(this);
         PlexLog.log("Update checking enabled");
 
         // https://bstats.org/plugin/bukkit/Plex/14143
@@ -171,7 +178,7 @@ public class Plex extends JavaPlugin
         {
             redisConnection.getJedis();
             PlexLog.log("Connected to Redis!");
-            MessageUtil.subscribe();
+            MessageUtil.subscribe(this);
 
         }
         else
@@ -179,14 +186,15 @@ public class Plex extends JavaPlugin
             PlexLog.log("Redis is disabled in the configuration file, not connecting.");
         }
 
-        sqlPlayerData = new SQLPlayerData();
-        sqlPunishment = new SQLPunishment();
-        sqlNotes = new SQLNotes();
+        punishmentRepository = new SQLPunishment(sqlConnection.getConnectionSource());
+        playerRepository = new SQLPlayerData(sqlConnection.getConnectionSource(), punishmentRepository);
+        noteRepository = new SQLNotes(sqlConnection.getConnectionSource());
+        playerService = new PlayerService(playerCache, playerRepository);
 
-        new ListenerHandler();
-        new CommandHandler();
+        new ListenerHandler(this);
+        new CommandHandler(this);
 
-        punishmentManager = new PunishmentManager();
+        punishmentManager = new PunishmentManager(this);
         punishmentManager.mergeIndefiniteBans();
         PlexLog.log("Punishment System initialized");
 
@@ -196,7 +204,7 @@ public class Plex extends JavaPlugin
             generateWorlds();
         }
 
-        serviceManager = new ServiceManager();
+        serviceManager = new ServiceManager(this);
         PlexLog.log("Service Manager initialized");
         serviceManager.startServices();
         PlexLog.log("Started " + serviceManager.serviceCount() + " services.");
@@ -215,12 +223,11 @@ public class Plex extends JavaPlugin
         Bukkit.getOnlinePlayers().forEach(player ->
         {
             PlexPlayer plexPlayer = playerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
-            sqlPlayerData.update(plexPlayer);
+            playerRepository.update(plexPlayer);
         });
-        if (redisConnection != null && redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
+        if (redisConnection != null && redisConnection.isEnabled())
         {
             PlexLog.log("Disabling Redis/Jedis. No memory leaks in this Anarchy server!");
-            redisConnection.getJedis().close();
         }
 
         this.getServer().getMessenger().unregisterOutgoingPluginChannel(this);
@@ -231,6 +238,7 @@ public class Plex extends JavaPlugin
         {
             sqlConnection.close();
         }
+        StorageExecutor.shutdown();
     }
 
     private void generateWorlds()
@@ -238,7 +246,7 @@ public class Plex extends JavaPlugin
         PlexLog.log("Generating any worlds if needed...");
         for (String key : config.getConfigurationSection("worlds").getKeys(false))
         {
-            CustomWorld.generateConfigFlatWorld(key);
+            CustomWorld.generateConfigFlatWorld(this, key);
         }
         PlexLog.log("Finished with world generation!");
     }
@@ -247,7 +255,7 @@ public class Plex extends JavaPlugin
     {
         Bukkit.getOnlinePlayers().forEach(player ->
         {
-            PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
+            PlexPlayer plexPlayer = playerService.getPlayer(player.getUniqueId());
             playerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
         });
     }

server/src/main/java/dev/plex/PlexBase.java

@@ -1,6 +0,0 @@
-package dev.plex;
-
-public interface PlexBase
-{
-    Plex plugin = Plex.get();
-}

server/src/main/java/dev/plex/cache/DataUtils.java

@@ -1,103 +0,0 @@
-package dev.plex.cache;
-
-import dev.plex.Plex;
-import dev.plex.player.PlexPlayer;
-
-import java.util.Optional;
-import java.util.UUID;
-
-/**
- * Parent cache class
- */
-public class DataUtils
-{
-    /**
-     * Checks if the player has been on the server before
-     *
-     * @param uuid The unique ID of the player
-     * @return true if the player is registered in the database
-     */
-    public static boolean hasPlayedBefore(UUID uuid)
-    {
-        return Plex.get().getSqlPlayerData().exists(uuid);
-    }
-
-    public static boolean hasPlayedBefore(String username)
-    {
-        return Plex.get().getSqlPlayerData().exists(username);
-    }
-
-    /**
-     * Gets a player from cache or from the database
-     *
-     * @param uuid The unique ID of the player
-     * @return a PlexPlayer object
-     * @see PlexPlayer
-     */
-    public static PlexPlayer getPlayer(UUID uuid)
-    {
-        return getPlayer(uuid, true);
-    }
-
-    public static PlexPlayer getPlayer(UUID uuid, boolean loadExtraData)
-    {
-        if (Plex.get().getPlayerCache().getPlexPlayerMap().containsKey(uuid))
-        {
-            return Plex.get().getPlayerCache().getPlexPlayerMap().get(uuid);
-        }
-
-        return Plex.get().getSqlPlayerData().getByUUID(uuid, loadExtraData);
-    }
-
-    public static PlexPlayer getPlayer(String username)
-    {
-        return getPlayer(username, true);
-    }
-
-    public static PlexPlayer getPlayer(String username, boolean loadExtraData)
-    {
-        Optional<PlexPlayer> plexPlayer = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream().filter(player -> player.getName().equalsIgnoreCase(username)).findFirst();
-        return plexPlayer.orElseGet(() -> Plex.get().getSqlPlayerData().getByName(username, loadExtraData));
-    }
-
-    /**
-     * Gets a player from cache or from the database
-     *
-     * @param ip The IP address of the player.
-     * @return a PlexPlayer object
-     * @see PlexPlayer
-     */
-    public static PlexPlayer getPlayerByIP(String ip)
-    {
-        PlexPlayer player = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream().filter(plexPlayer -> plexPlayer.getIps().contains(ip)).findFirst().orElse(null);
-        if (player != null)
-        {
-            return player;
-        }
-
-        return Plex.get().getSqlPlayerData().getByIP(ip);
-    }
-
-    /**
-     * Updates a player's information in the database
-     *
-     * @param plexPlayer The PlexPlayer to update
-     * @see PlexPlayer
-     */
-    public static void update(PlexPlayer plexPlayer)
-    {
-        Plex.get().getSqlPlayerData().update(plexPlayer);
-    }
-
-    /**
-     * Inserts a player's information in the database
-     *
-     * @param plexPlayer The PlexPlayer to insert
-     * @see PlexPlayer
-     */
-    public static void insert(PlexPlayer plexPlayer)
-    {
-        Plex.get().getSqlPlayerData().insert(plexPlayer);
-    }
-
-}

server/src/main/java/dev/plex/command/PlexCommand.java

@@ -2,7 +2,6 @@ package dev.plex.command;
 
 import com.google.common.collect.Lists;
 import dev.plex.Plex;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
 import dev.plex.command.exception.CommandFailException;
@@ -43,7 +42,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     /**
      * Returns the instance of the plugin
      */
-    protected static Plex plugin = Plex.get();
+    protected final Plex plugin;
 
     /**
      * The parameters for the command
@@ -66,6 +65,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     public PlexCommand(boolean register)
     {
         super("");
+        this.plugin = Plex.get();
         this.params = getClass().getAnnotation(CommandParameters.class);
         this.perms = getClass().getAnnotation(CommandPermissions.class);
 
@@ -149,7 +149,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
 
         if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console")) //telnet
         {
-            PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
+            PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(sender.getName());
 
             if (!perms.permission().isEmpty() && !plugin.getPermissions().playerHas(null, Bukkit.getPlayer(plexPlayer.getName()), perms.permission()))
             {
@@ -218,7 +218,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
      */
     protected PlexPlayer getPlexPlayer(@NotNull Player player)
     {
-        return DataUtils.getPlayer(player.getUniqueId());
+        return plugin.getPlayerService().getPlayer(player.getUniqueId());
     }
 
     /**
@@ -431,7 +431,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
 
     protected PlexPlayer getOfflinePlexPlayer(UUID uuid)
     {
-        PlexPlayer plexPlayer = DataUtils.getPlayer(uuid);
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(uuid);
         if (plexPlayer == null)
         {
             throw new PlayerNotFoundException();
@@ -478,6 +478,6 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
 
     public CommandMap getMap()
     {
-        return Plex.get().getServer().getCommandMap();
+        return plugin.getServer().getCommandMap();
     }
 }

server/src/main/java/dev/plex/command/impl/AdminChatCMD.java

@@ -55,7 +55,7 @@ public class AdminChatCMD extends PlexCommand
         PlexLog.debug("admin chat prefix: {0}", prefix);
         String message = StringUtils.join(args, " ");
         plugin.getServer().getConsoleSender().sendMessage(messageComponent("adminChatFormat", sender.getName(), prefix, message));
-        MessageUtil.sendStaffChat(sender, SafeMiniMessage.mmDeserialize(message), PlexUtils.adminChat(sender.getName(), prefix, message).toArray(UUID[]::new));
+        MessageUtil.sendStaffChat(plugin, sender, SafeMiniMessage.mmDeserialize(message), PlexUtils.adminChat(sender.getName(), prefix, message).toArray(UUID[]::new));
         return null;
     }
 

server/src/main/java/dev/plex/command/impl/BanCMD.java

@@ -1,6 +1,6 @@
 package dev.plex.command.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -45,7 +45,7 @@ public class BanCMD extends PlexCommand
             return usage();
         }
 
-        final PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
+        final PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[0]);
 
         if (plexPlayer == null)
         {
@@ -88,7 +88,7 @@ public class BanCMD extends PlexCommand
             {
                 if (player != null)
                 {
-                    BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
+                    BungeeUtil.kickPlayer(plugin, player, Punishment.generateBanMessage(punishment, plugin.config.getString("banning.ban_url"), plugin.getPlayerService()));
                 }
             });
             PlexLog.debug("(From /ban command) PunishedPlayer UUID: " + plexPlayer.getUuid());

server/src/main/java/dev/plex/command/impl/BcastLoginMessageCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -31,7 +31,7 @@ public class BcastLoginMessageCMD extends PlexCommand
             return usage();
         }
 
-        PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[0]);
 
         if (plexPlayer == null)
         {

server/src/main/java/dev/plex/command/impl/CommandSpyCMD.java

@@ -1,6 +1,6 @@
 package dev.plex.command.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -27,7 +27,7 @@ public class CommandSpyCMD extends PlexCommand
         {
             PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayer(playerSender.getUniqueId());
             plexPlayer.setCommandSpy(!plexPlayer.isCommandSpy());
-            DataUtils.update(plexPlayer);
+            plugin.getPlayerService().update(plexPlayer);
             send(sender, messageComponent("toggleCommandSpy")
                     .append(Component.space())
                     .append(plexPlayer.isCommandSpy() ? messageComponent("enabled") : messageComponent("disabled")));

server/src/main/java/dev/plex/command/impl/DebugCMD.java

@@ -38,9 +38,9 @@ public class DebugCMD extends PlexCommand
             if (args.length == 2)
             {
                 Player player = getNonNullPlayer(args[1]);
-                if (plugin.getRedisConnection().getJedis().exists(player.getUniqueId().toString()))
+                if (plugin.getRedisConnection().query(jedis -> jedis.exists(player.getUniqueId().toString())))
                 {
-                    plugin.getRedisConnection().getJedis().del(player.getUniqueId().toString());
+                    plugin.getRedisConnection().execute(jedis -> jedis.del(player.getUniqueId().toString()));
                     return messageComponent("redisResetSuccessful", player.getName());
                 }
                 return messageComponent("redisResetPlayerNotFound");
@@ -50,7 +50,7 @@ public class DebugCMD extends PlexCommand
         {
             for (World world : Bukkit.getWorlds())
             {
-                GameRuleUtil.commitGlobalGameRules(world);
+                GameRuleUtil.commitGlobalGameRules(plugin, world);
                 PlexLog.log("Set global gamerules for world: " + world.getName());
             }
             for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
@@ -58,7 +58,7 @@ public class DebugCMD extends PlexCommand
                 World bukkitWorld = Bukkit.getWorld(world);
                 if (bukkitWorld != null)
                 {
-                    GameRuleUtil.commitSpecificGameRules(bukkitWorld);
+                    GameRuleUtil.commitSpecificGameRules(plugin, bukkitWorld);
                     PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
                 }
             }

server/src/main/java/dev/plex/command/impl/KickCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -38,7 +38,7 @@ public class KickCMD extends PlexCommand
             return usage();
         }
 
-        PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[0]);
         String reason = messageString("noReasonProvided");
 
         if (plexPlayer == null)
@@ -66,7 +66,7 @@ public class KickCMD extends PlexCommand
         punishment.setIp(player.getAddress().getAddress().getHostAddress().trim());
         plugin.getPunishmentManager().punish(plexPlayer, punishment);
         PlexUtils.broadcast(messageComponent("kickedPlayer", sender.getName(), plexPlayer.getName()));
-        BungeeUtil.kickPlayer(player, Punishment.generateKickMessage(punishment));
+        BungeeUtil.kickPlayer(plugin, player, Punishment.generateKickMessage(punishment, plugin.getPlayerService()));
         return null;
     }
 

server/src/main/java/dev/plex/command/impl/NotesCMD.java

@@ -1,6 +1,6 @@
 package dev.plex.command.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -36,7 +36,7 @@ public class NotesCMD extends PlexCommand
             return usage();
         }
 
-        PlexPlayer plexPlayer = DataUtils.getPlayer(args[0]);
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[0]);
 
         if (plexPlayer == null)
         {
@@ -47,7 +47,7 @@ public class NotesCMD extends PlexCommand
         {
             case "list":
             {
-                plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
+                plugin.getNoteRepository().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
                 {
                     if (notes.isEmpty())
                     {
@@ -69,7 +69,7 @@ public class NotesCMD extends PlexCommand
                 {
                     Note note = new Note(plexPlayer.getUuid(), content, playerSender.getUniqueId(), ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)));
                     plexPlayer.getNotes().add(note);
-                    plugin.getSqlNotes().addNote(note);
+                    plugin.getNoteRepository().addNote(note);
                     return messageComponent("noteAdded");
                 }
             }
@@ -88,14 +88,14 @@ public class NotesCMD extends PlexCommand
                 {
                     return messageComponent("unableToParseNumber", args[2]);
                 }
-                plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
+                plugin.getNoteRepository().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
                 {
                     boolean deleted = false;
                     for (Note note : notes)
                     {
                         if (note.getId() == id)
                         {
-                            plugin.getSqlNotes().deleteNote(id, plexPlayer.getUuid()).whenComplete((notes1, ex1) ->
+                            plugin.getNoteRepository().deleteNote(id, plexPlayer.getUuid()).whenComplete((notes1, ex1) ->
                                     send(sender, messageComponent("removedNote", id)));
                             deleted = true;
                         }
@@ -112,7 +112,7 @@ public class NotesCMD extends PlexCommand
             {
                 int count = plexPlayer.getNotes().size();
                 plexPlayer.getNotes().clear();
-                DataUtils.update(plexPlayer);
+                plugin.getPlayerService().update(plexPlayer);
                 return messageComponent("clearedNotes", count);
             }
             default:
@@ -127,7 +127,7 @@ public class NotesCMD extends PlexCommand
         AtomicReference<Component> noteList = new AtomicReference<>(messageComponent("notesHeader", plexPlayer.getName()));
         for (Note note : notes)
         {
-            Component noteLine = messageComponent("notePrefix", note.getId(), DataUtils.getPlayer(note.getWrittenBy()).getName(), TimeUtils.useTimezone(note.getTimestamp()));
+            Component noteLine = messageComponent("notePrefix", note.getId(), plugin.getPlayerService().getPlayer(note.getWrittenBy()).getName(), TimeUtils.useTimezone(note.getTimestamp()));
             noteLine = noteLine.append(messageComponent("noteLine", note.getNote()));
             noteList.set(noteList.get().append(Component.newline()));
             noteList.set(noteList.get().append(noteLine));

server/src/main/java/dev/plex/command/impl/PlexCMD.java

@@ -8,6 +8,7 @@ import dev.plex.command.source.RequiredCommandSource;
 import dev.plex.module.PlexModule;
 import dev.plex.module.PlexModuleFile;
 import dev.plex.util.BuildInfo;
+import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 
@@ -47,8 +48,10 @@ public class PlexCMD extends PlexCommand
         {
             checkPermission(sender, "plex.reload");
             plugin.config.load();
+            PlexLog.setDebugEnabled(plugin.config.getBoolean("debug"));
             send(sender, "Reloaded config file");
             plugin.messages.load();
+            PlexUtils.configure(plugin.config, plugin.messages);
             send(sender, "Reloaded messages file");
             plugin.indefBans.load(false);
             plugin.getPunishmentManager().mergeIndefiniteBans();
@@ -72,10 +75,10 @@ public class PlexCMD extends PlexCommand
             {
                 throw new CommandFailException("&cRedis is not enabled.");
             }
-            plugin.getRedisConnection().getJedis().set("test", "123");
+            plugin.getRedisConnection().execute(jedis -> jedis.set("test", "123"));
             send(sender, "Set test to 123. Now outputting key test...");
-            send(sender, plugin.getRedisConnection().getJedis().get("test"));
-            plugin.getRedisConnection().getJedis().close();
+            String test = plugin.getRedisConnection().query(jedis -> jedis.get("test"));
+            send(sender, test);
             return null;
         }
         else if (args[0].equalsIgnoreCase("modules"))

server/src/main/java/dev/plex/command/impl/PunishmentsCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -31,11 +31,11 @@ public class PunishmentsCMD extends PlexCommand
     {
         if (args.length == 0)
         {
-            new PunishmentMenu().open(playerSender);
+            new PunishmentMenu(plugin.getPlayerService()).open(playerSender);
         }
         else
         {
-            if (!DataUtils.hasPlayedBefore(args[0]))
+            if (!plugin.getPlayerService().hasPlayedBefore(args[0]))
             {
                 throw new PlayerNotFoundException();
             }
@@ -43,7 +43,7 @@ public class PunishmentsCMD extends PlexCommand
             final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(args[0]);
             final PlexPlayer player = offlinePlayer.isOnline() ? getOnlinePlexPlayer(args[0]) : getOfflinePlexPlayer(offlinePlayer.getUniqueId());
 
-            new PunishedPlayerMenu(player).open(playerSender);
+            new PunishedPlayerMenu(player, plugin.getPlayerService()).open(playerSender);
         }
 
         return null;

server/src/main/java/dev/plex/command/impl/RemoveLoginMessageCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -42,7 +42,7 @@ public class RemoveLoginMessageCMD extends PlexCommand
                 return messageComponent("specifyPlayer");
             }
 
-            PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
+            PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[1]);
             if (plexPlayer == null)
             {
                 return messageComponent("playerNotFound");

server/src/main/java/dev/plex/command/impl/SetLoginMessageCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -48,7 +48,7 @@ public class SetLoginMessageCMD extends PlexCommand
                 {
                     return messageComponent("specifyLoginMessage");
                 }
-                PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
+                PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(args[1]);
                 if (plexPlayer == null)
                 {
                     return messageComponent("playerNotFound");

server/src/main/java/dev/plex/command/impl/TagCMD.java

@@ -1,6 +1,6 @@
 package dev.plex.command.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -45,7 +45,7 @@ public class TagCMD extends PlexCommand
                 return messageComponent("noPermissionConsole");
             }
             assert playerSender != null;
-            PlexPlayer player = DataUtils.getPlayer(playerSender.getUniqueId());
+            PlexPlayer player = plugin.getPlayerService().getPlayer(playerSender.getUniqueId());
             if (args.length < 2)
             {
                 return usage("/tag set <prefix>");
@@ -59,7 +59,7 @@ public class TagCMD extends PlexCommand
             }
 
             player.setPrefix(MiniMessage.miniMessage().serialize(convertedComponent));
-            DataUtils.update(player);
+            plugin.getPlayerService().update(player);
             return messageComponent("prefixSetTo", MiniMessage.miniMessage().serialize(convertedComponent));
         }
 
@@ -77,16 +77,16 @@ public class TagCMD extends PlexCommand
                     return null;
                 }
 
-                PlexPlayer player = DataUtils.getPlayer(playerSender.getUniqueId());
+                PlexPlayer player = plugin.getPlayerService().getPlayer(playerSender.getUniqueId());
                 player.setPrefix(null);
-                DataUtils.update(player);
+                plugin.getPlayerService().update(player);
                 return messageComponent("prefixCleared");
             }
             checkPermission(sender, "plex.tag.clear.others");
             Player target = getNonNullPlayer(args[1]);
-            PlexPlayer plexTarget = DataUtils.getPlayer(target.getUniqueId());
+            PlexPlayer plexTarget = plugin.getPlayerService().getPlayer(target.getUniqueId());
             plexTarget.setPrefix(null);
-            DataUtils.update(plexTarget);
+            plugin.getPlayerService().update(plexTarget);
             return messageComponent("otherPrefixCleared", target.getName());
         }
         return usage();

server/src/main/java/dev/plex/command/impl/TempbanCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -39,7 +39,7 @@ public class TempbanCMD extends PlexCommand
             return usage();
         }
 
-        PlexPlayer target = DataUtils.getPlayer(args[0]);
+        PlexPlayer target = plugin.getPlayerService().getPlayer(args[0]);
         String reason;
 
         if (target == null)
@@ -78,7 +78,7 @@ public class TempbanCMD extends PlexCommand
         PlexUtils.broadcast(messageComponent("banningPlayer", sender.getName(), target.getName()));
         if (player != null)
         {
-            BungeeUtil.kickPlayer(player, Punishment.generateBanMessage(punishment));
+            BungeeUtil.kickPlayer(plugin, player, Punishment.generateBanMessage(punishment, plugin.config.getString("banning.ban_url"), plugin.getPlayerService()));
         }
         if (rollBack)
         {

server/src/main/java/dev/plex/command/impl/ToggleCMD.java

@@ -70,7 +70,7 @@ public class ToggleCMD extends PlexCommand
                 }
             }
         }
-        new ToggleMenu().open(playerSender);
+        new ToggleMenu(plugin).open(playerSender);
         return null;
     }
 

server/src/main/java/dev/plex/command/impl/UnbanCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -34,7 +34,7 @@ public class UnbanCMD extends PlexCommand
 
         if (args.length == 1)
         {
-            PlexPlayer target = DataUtils.getPlayer(args[0]);
+            PlexPlayer target = plugin.getPlayerService().getPlayer(args[0]);
 
             if (target == null)
             {

server/src/main/java/dev/plex/command/impl/UnfreezeCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -30,7 +30,7 @@ public class UnfreezeCMD extends PlexCommand
         {
             return usage();
         }
-        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
+        PlexPlayer punishedPlayer = plugin.getPlayerService().getPlayer(args[0]);
         if (punishedPlayer == null)
         {
             throw new PlayerNotFoundException();
@@ -44,7 +44,7 @@ public class UnfreezeCMD extends PlexCommand
         punishedPlayer.getPunishments().stream().filter(punishment -> punishment.getType() == PunishmentType.FREEZE && punishment.isActive()).forEach(punishment ->
         {
             punishment.setActive(false);
-            plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
+            plugin.getPunishmentRepository().updatePunishment(punishment.getType(), false, punishment.getPunished());
         });
         PlexUtils.broadcast(messageComponent("unfrozePlayer", sender.getName(), punishedPlayer.getName()));
         return null;

server/src/main/java/dev/plex/command/impl/UnmuteCMD.java

@@ -1,7 +1,7 @@
 package dev.plex.command.impl;
 
+
 import com.google.common.collect.ImmutableList;
-import dev.plex.cache.DataUtils;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -30,7 +30,7 @@ public class UnmuteCMD extends PlexCommand
         {
             return usage();
         }
-        PlexPlayer punishedPlayer = DataUtils.getPlayer(args[0]);
+        PlexPlayer punishedPlayer = plugin.getPlayerService().getPlayer(args[0]);
         if (punishedPlayer == null)
         {
             throw new PlayerNotFoundException();
@@ -44,7 +44,7 @@ public class UnmuteCMD extends PlexCommand
         punishedPlayer.getPunishments().stream().filter(punishment -> punishment.getType() == PunishmentType.MUTE && punishment.isActive()).forEach(punishment ->
         {
             punishment.setActive(false);
-            plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
+            plugin.getPunishmentRepository().updatePunishment(punishment.getType(), false, punishment.getPunished());
         });
         PlexUtils.broadcast(messageComponent("unmutedPlayer", sender.getName(), punishedPlayer.getName()));
         return null;

server/src/main/java/dev/plex/command/impl/WorldCMD.java

@@ -1,7 +1,6 @@
 package dev.plex.command.impl;
 
 import com.google.common.collect.Lists;
-import dev.plex.Plex;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.annotation.CommandParameters;
 import dev.plex.command.annotation.CommandPermissions;
@@ -36,7 +35,7 @@ public class WorldCMD extends PlexCommand
 
         World world = getNonNullWorld(args[0]);
         boolean playerWorld = args[0].matches("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
-        if (playerWorld && Plex.get().getModuleManager().getModules().stream().anyMatch(plexModule -> plexModule.getPlexModuleFile().getName().equalsIgnoreCase("Module-TFMExtras")))
+        if (playerWorld && plugin.getModuleManager().getModules().stream().anyMatch(plexModule -> plexModule.getPlexModuleFile().getName().equalsIgnoreCase("Module-TFMExtras")))
         {
             checkPermission(playerSender, "plex.world.playerworlds");
         }

server/src/main/java/dev/plex/handlers/CommandHandler.java

@@ -1,7 +1,7 @@
 package dev.plex.handlers;
 
 import com.google.common.collect.Lists;
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import dev.plex.command.PlexCommand;
 import dev.plex.command.impl.DebugCMD;
 import dev.plex.util.PlexLog;
@@ -11,10 +11,13 @@ import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Set;
 
-public class CommandHandler implements PlexBase
+public class CommandHandler
 {
-    public CommandHandler()
+    private final Plex plugin;
+
+    public CommandHandler(Plex plugin)
     {
+        this.plugin = plugin;
         Set<Class<? extends PlexCommand>> commandSet = ReflectionsUtil.getClassesBySubType("dev.plex.command.impl", PlexCommand.class);
         List<PlexCommand> commands = Lists.newArrayList();
 

server/src/main/java/dev/plex/handlers/ListenerHandler.java

@@ -1,7 +1,7 @@
 package dev.plex.handlers;
 
 import com.google.common.collect.Lists;
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import dev.plex.listener.PlexListener;
 import dev.plex.listener.annotation.Toggleable;
 import dev.plex.util.PlexLog;
@@ -11,10 +11,13 @@ import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Set;
 
-public class ListenerHandler implements PlexBase
+public class ListenerHandler
 {
-    public ListenerHandler()
+    private final Plex plugin;
+
+    public ListenerHandler(Plex plugin)
     {
+        this.plugin = plugin;
         Set<Class<? extends PlexListener>> listenerSet = ReflectionsUtil.getClassesBySubType("dev.plex.listener.impl", PlexListener.class);
         List<PlexListener> listeners = Lists.newArrayList();
 

server/src/main/java/dev/plex/listener/PlexListener.java

@@ -1,12 +1,20 @@
 package dev.plex.listener;
 
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import org.bukkit.event.Listener;
 
-public abstract class PlexListener implements Listener, PlexBase
+public abstract class PlexListener implements Listener
 {
+    protected final Plex plugin;
+
     public PlexListener()
     {
+        this(Plex.get());
+    }
+
+    protected PlexListener(Plex plugin)
+    {
+        this.plugin = plugin;
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 }

server/src/main/java/dev/plex/listener/impl/BanListener.java

@@ -1,7 +1,5 @@
 package dev.plex.listener.impl;
 
-import dev.plex.Plex;
-import dev.plex.cache.DataUtils;
 import dev.plex.listener.PlexListener;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
@@ -20,7 +18,7 @@ public class BanListener extends PlexListener
         if (uuidBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    !uuidBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("UUID", uuidBan.getReason()) : Punishment.generateIndefBanMessage("UUID"));
+                    !uuidBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("UUID", plugin.config.getString("banning.ban_url"), uuidBan.getReason()) : Punishment.generateIndefBanMessage("UUID", plugin.config.getString("banning.ban_url")));
             return;
         }
 
@@ -28,7 +26,7 @@ public class BanListener extends PlexListener
         if (ipBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    !ipBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("IP", ipBan.getReason()) : Punishment.generateIndefBanMessage("IP"));
+                    !ipBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("IP", plugin.config.getString("banning.ban_url"), ipBan.getReason()) : Punishment.generateIndefBanMessage("IP", plugin.config.getString("banning.ban_url")));
             return;
         }
 
@@ -37,32 +35,32 @@ public class BanListener extends PlexListener
         if (userBan != null)
         {
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    !userBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("username", userBan.getReason()) : Punishment.generateIndefBanMessage("username"));
+                    !userBan.getReason().isEmpty() ? Punishment.generateIndefBanMessageWithReason("username", plugin.config.getString("banning.ban_url"), userBan.getReason()) : Punishment.generateIndefBanMessage("username", plugin.config.getString("banning.ban_url")));
             return;
         }
 
         if (plugin.getPunishmentManager().isBanned(event.getUniqueId()))
         {
-            if (Plex.get().getPermissions() != null && Plex.get().getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
+            if (plugin.getPermissions() != null && plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
             {
                 return;
             }
-            PlexPlayer player = DataUtils.getPlayer(event.getUniqueId());
+            PlexPlayer player = plugin.getPlayerService().getPlayer(event.getUniqueId());
             player.getPunishments().stream().filter(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive()).findFirst().ifPresent(punishment ->
                     event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                            Punishment.generateBanMessage(punishment)));
+                            Punishment.generateBanMessage(punishment, plugin.config.getString("banning.ban_url"), plugin.getPlayerService())));
             return;
         }
         Punishment ipBannedPunishment = plugin.getPunishmentManager().getBanByIP(event.getAddress().getHostAddress());
         if (ipBannedPunishment != null)
         {
             // Don't check if the other account that's banned has bypass abilities, check if current has only
-            if (Plex.get().getPermissions() != null && Plex.get().getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
+            if (plugin.getPermissions() != null && plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(event.getUniqueId()), "plex.ban.bypass"))
             {
                 return;
             }
             event.disallow(AsyncPlayerPreLoginEvent.Result.KICK_BANNED,
-                    Punishment.generateBanMessage(ipBannedPunishment));
+                    Punishment.generateBanMessage(ipBannedPunishment, plugin.config.getString("banning.ban_url"), plugin.getPlayerService()));
         }
     }
 }

server/src/main/java/dev/plex/listener/impl/ChatListener.java

@@ -38,16 +38,15 @@ public class ChatListener extends PlexListener
     public static BiConsumer<AsyncChatEvent, PlexPlayer> PRE_RENDERER = ChatListener::defaultChatProcessing;
     private final PlexChatRenderer renderer = new PlexChatRenderer();
 
-    private static final Component format = SafeMiniMessage.mmDeserialize(plugin.config.getString("chat.format"));
-
     @EventHandler(priority = EventPriority.LOWEST)
     public void onChat(AsyncChatEvent event)
     {
         PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(event.getPlayer().getUniqueId());
+        renderer.format = SafeMiniMessage.mmDeserialize(plugin.config.getString("chat.format"));
         if (plexPlayer.isStaffChat())
         {
             String prefix = PlexUtils.mmSerialize(VaultHook.getPrefix(event.getPlayer())); // Don't use PlexPlayer#getPrefix because that returns their custom set prefix and not their group's
-            MessageUtil.sendStaffChat(event.getPlayer(), event.message(), PlexUtils.adminChat(event.getPlayer().getName(), prefix, SafeMiniMessage.mmSerialize(event.message())).toArray(UUID[]::new));
+            MessageUtil.sendStaffChat(plugin, event.getPlayer(), event.message(), PlexUtils.adminChat(event.getPlayer().getName(), prefix, SafeMiniMessage.mmSerialize(event.message())).toArray(UUID[]::new));
             plugin.getServer().getConsoleSender().sendMessage(PlexUtils.messageComponent("adminChatFormat", event.getPlayer().getName(), prefix, SafeMiniMessage.mmSerialize(event.message().replaceText(URL_REPLACEMENT_CONFIG))));
             event.setCancelled(true);
             return;
@@ -74,6 +73,7 @@ public class ChatListener extends PlexListener
     {
         public boolean hasPrefix;
         public Component prefix;
+        public Component format;
         public Supplier<Component> before = null;
 
         @Override

server/src/main/java/dev/plex/listener/impl/FreezeListener.java

@@ -1,6 +1,6 @@
 package dev.plex.listener.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.listener.PlexListener;
 import dev.plex.player.PlexPlayer;
 import org.bukkit.event.EventHandler;
@@ -12,7 +12,7 @@ public class FreezeListener extends PlexListener
     @EventHandler
     public void onPlayerMove(PlayerMoveEvent e)
     {
-        PlexPlayer player = DataUtils.getPlayer(e.getPlayer().getUniqueId());
+        PlexPlayer player = plugin.getPlayerService().getPlayer(e.getPlayer().getUniqueId());
         if (player.isFrozen())
         {
             e.setCancelled(true);
@@ -22,7 +22,7 @@ public class FreezeListener extends PlexListener
     @EventHandler
     public void onPlayerTeleport(PlayerTeleportEvent e)
     {
-        PlexPlayer player = DataUtils.getPlayer(e.getPlayer().getUniqueId());
+        PlexPlayer player = plugin.getPlayerService().getPlayer(e.getPlayer().getUniqueId());
         if (player.isFrozen())
         {
             e.setCancelled(true);

server/src/main/java/dev/plex/listener/impl/PlayerListener.java

@@ -1,6 +1,6 @@
 package dev.plex.listener.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.listener.PlexListener;
 import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
@@ -27,17 +27,17 @@ public class PlayerListener extends PlexListener
         Player player = event.getPlayer();
         PlexPlayer plexPlayer;
 
-        if (!DataUtils.hasPlayedBefore(player.getUniqueId()))
+        if (!plugin.getPlayerService().hasPlayedBefore(player.getUniqueId()))
         {
             PlexLog.log("A player with this name has not joined the server before, creating new entry.");
             plexPlayer = new PlexPlayer(player.getUniqueId()); // it doesn't! okay so now create the object
             plexPlayer.setName(player.getName()); // set the name of the player
             plexPlayer.setIps(List.of(player.getAddress().getAddress().getHostAddress().trim())); // set the arraylist of ips
-            DataUtils.insert(plexPlayer); // insert data in some wack db
+            plugin.getPlayerService().insert(plexPlayer); // insert data in some wack db
         }
         else
         {
-            plexPlayer = DataUtils.getPlayer(player.getUniqueId());
+            plexPlayer = plugin.getPlayerService().getPlayer(player.getUniqueId());
             List<String> ips = plexPlayer.getIps();
             String currentIP = player.getAddress().getAddress().getHostAddress().trim();
             if (!ips.contains(currentIP))
@@ -45,13 +45,13 @@ public class PlayerListener extends PlexListener
                 PlexLog.debug("New IP address detected for player: " + player.getName() + ". Adding " + currentIP + " to the database.");
                 ips.add(currentIP);
                 plexPlayer.setIps(ips);
-                DataUtils.update(plexPlayer);
+                plugin.getPlayerService().update(plexPlayer);
             }
             if (!plexPlayer.getName().equals(player.getName()))
             {
                 PlexLog.log(plexPlayer.getName() + " has a new name. Changing it to " + player.getName());
                 plexPlayer.setName(player.getName());
-                DataUtils.update(plexPlayer);
+                plugin.getPlayerService().update(plexPlayer);
             }
         }
         plugin.getPlayerCache().getPlexPlayerMap().put(player.getUniqueId(), plexPlayer);
@@ -66,9 +66,7 @@ public class PlayerListener extends PlexListener
             PlexUtils.broadcast(PlexUtils.stringToComponent(loginMessage));
         }
 
-        plexPlayer.loadNotes();
-
-        plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
+        plugin.getNoteRepository().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
         {
             if (!notes.isEmpty())
             {
@@ -82,14 +80,14 @@ public class PlayerListener extends PlexListener
     public void onPlayerSave(PlayerQuitEvent event)
     {
         PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(event.getPlayer().getUniqueId()); //get the player because it's literally impossible for them to not have an object
-        DataUtils.update(plexPlayer);
+        plugin.getPlayerService().update(plexPlayer);
         plugin.getPlayerCache().getPlexPlayerMap().remove(event.getPlayer().getUniqueId()); //remove them from cache
     }
 
     @EventHandler(priority = EventPriority.HIGHEST)
     public void onPlayerInventoryClose(InventoryCloseEvent event)
     {
-        PlexPlayer player = DataUtils.getPlayer(event.getPlayer().getUniqueId());
+        PlexPlayer player = plugin.getPlayerService().getPlayer(event.getPlayer().getUniqueId());
         if (player.isLockedUp())
         {
             Bukkit.getGlobalRegionScheduler().runDelayed(plugin, (scheduledTask) -> event.getPlayer().openInventory(event.getInventory()), 1L);
@@ -99,7 +97,7 @@ public class PlayerListener extends PlexListener
     @EventHandler(priority = EventPriority.HIGHEST)
     public void onInventoryClick(InventoryClickEvent event)
     {
-        PlexPlayer player = DataUtils.getPlayer(event.getWhoClicked().getUniqueId());
+        PlexPlayer player = plugin.getPlayerService().getPlayer(event.getWhoClicked().getUniqueId());
         if (player.isLockedUp())
         {
             event.setCancelled(true);

server/src/main/java/dev/plex/listener/impl/TabListener.java

@@ -1,6 +1,6 @@
 package dev.plex.listener.impl;
 
-import dev.plex.cache.DataUtils;
+
 import dev.plex.hook.VaultHook;
 import dev.plex.listener.PlexListener;
 import dev.plex.meta.PlayerMeta;
@@ -18,7 +18,7 @@ public class TabListener extends PlexListener
     public void onPlayerJoin(PlayerJoinEvent event)
     {
         Player player = event.getPlayer();
-        PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
-        player.playerListName(PlexUtils.mmDeserialize(PlayerMeta.getColor(plexPlayer) + player.getName()));
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(player.getUniqueId());
+        player.playerListName(PlexUtils.mmDeserialize(PlayerMeta.getColor(plugin.config, plexPlayer) + player.getName()));
     }
 }

server/src/main/java/dev/plex/listener/impl/TogglesListener.java

@@ -1,6 +1,5 @@
 package dev.plex.listener.impl;
 
-import dev.plex.Plex;
 import dev.plex.listener.PlexListener;
 import dev.plex.util.PlexUtils;
 import io.papermc.paper.event.player.AsyncChatEvent;
@@ -80,7 +79,7 @@ public class TogglesListener extends PlexListener
     public void onChat(AsyncChatEvent event)
     {
         Player player = event.getPlayer();
-        if (!plugin.toggles.getBoolean("chat") && !Plex.get().getPermissions().has(player, "plex.mute.bypass"))
+        if (!plugin.toggles.getBoolean("chat") && !plugin.getPermissions().has(player, "plex.mute.bypass"))
         {
             event.getPlayer().sendMessage(PlexUtils.messageComponent("chatIsOff"));
             event.setCancelled(true);
@@ -91,7 +90,7 @@ public class TogglesListener extends PlexListener
     public void onCommand(PlayerCommandPreprocessEvent event)
     {
         Player player = event.getPlayer();
-        if (!plugin.toggles.getBoolean("chat") && !Plex.get().getPermissions().has(player, "plex.mute.bypass"))
+        if (!plugin.toggles.getBoolean("chat") && !plugin.getPermissions().has(player, "plex.mute.bypass"))
         {
             String message = event.getMessage();
             message = message.replaceAll("\\s.*", "").replaceFirst("/", "");

server/src/main/java/dev/plex/listener/impl/VanishListener.java

@@ -1,7 +1,7 @@
 package dev.plex.listener.impl;
 
+
 import de.myzelyam.api.vanish.PlayerShowEvent;
-import dev.plex.cache.DataUtils;
 import dev.plex.listener.PlexListener;
 import dev.plex.meta.PlayerMeta;
 import dev.plex.player.PlexPlayer;
@@ -22,7 +22,7 @@ public class VanishListener extends PlexListener
         {
             return;
         }
-        PlexPlayer plexPlayer = DataUtils.getPlayer(event.getPlayer().getUniqueId());
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(event.getPlayer().getUniqueId());
         String loginMessage = PlayerMeta.getLoginMessage(plexPlayer);
         if (!loginMessage.isEmpty())
         {

server/src/main/java/dev/plex/menu/impl/PunishedPlayerMenu.java

@@ -1,8 +1,8 @@
 package dev.plex.menu.impl;
 
-import dev.plex.Plex;
 import dev.plex.menu.AbstractMenu;
 import dev.plex.menu.pagination.PageableMenu;
+import dev.plex.player.PlayerService;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.util.TimeUtils;
@@ -16,11 +16,13 @@ import org.bukkit.inventory.ItemStack;
 public class PunishedPlayerMenu extends PageableMenu<Punishment>
 {
     private final PlexPlayer punishedPlayer;
+    private final PlayerService playerService;
 
-    public PunishedPlayerMenu(PlexPlayer player)
+    public PunishedPlayerMenu(PlexPlayer player, PlayerService playerService)
     {
         super("<red><bold>Punishments - " + player.getName(), AbstractMenu.Rows.SIX);
         this.punishedPlayer = player;
+        this.playerService = playerService;
         onClick((inventoryView, itemStacks, player1, itemStack) -> true);
         this.init();
     }
@@ -28,7 +30,7 @@ public class PunishedPlayerMenu extends PageableMenu<Punishment>
     @Override
     protected ItemStack toItem(Punishment object)
     {
-        return new ItemBuilder(Material.PAPER).displayName("<!italic><red>" + object.getType().name()).lore("<!italic><red>By: <gold>" + (object.getPunisher() == null ? "CONSOLE" : Plex.get().getSqlPlayerData().getNameByUUID(object.getPunisher())), "<!italic><red>Issued: <gold>" + TimeUtils.useTimezone(object.getIssueDate()), "<!italic><red>Expire(d/s): <gold>" + TimeUtils.useTimezone(object.getEndDate()), "<!italic><red>Reason: <gold>" + object.getReason()).build();
+        return new ItemBuilder(Material.PAPER).displayName("<!italic><red>" + object.getType().name()).lore("<!italic><red>By: <gold>" + (object.getPunisher() == null ? "CONSOLE" : playerService.getNameByUUID(object.getPunisher())), "<!italic><red>Issued: <gold>" + TimeUtils.useTimezone(object.getIssueDate()), "<!italic><red>Expire(d/s): <gold>" + TimeUtils.useTimezone(object.getEndDate()), "<!italic><red>Reason: <gold>" + object.getReason()).build();
     }
 
     @Override

server/src/main/java/dev/plex/menu/impl/PunishmentMenu.java

@@ -1,8 +1,8 @@
 package dev.plex.menu.impl;
 
-import dev.plex.cache.DataUtils;
 import dev.plex.menu.AbstractMenu;
 import dev.plex.menu.pagination.PageableMenu;
+import dev.plex.player.PlayerService;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexLog;
 import dev.plex.util.item.ItemBuilder;
@@ -20,9 +20,12 @@ import org.bukkit.inventory.meta.SkullMeta;
 
 public class PunishmentMenu extends PageableMenu<Player>
 {
-    public PunishmentMenu()
+    private final PlayerService playerService;
+
+    public PunishmentMenu(PlayerService playerService)
     {
         super("<aqua><bold>Punishments", AbstractMenu.Rows.SIX);
+        this.playerService = playerService;
         PlexLog.debug("list: {0}", list().size());
         onClick((inventoryView, itemStacks, player, itemStack) ->
         {
@@ -35,14 +38,14 @@ public class PunishmentMenu extends PageableMenu<Player>
             {
                 meta.setOwningPlayer(Bukkit.getOfflinePlayer("markbyron"));
             }
-            PlexPlayer punishedPlayer = DataUtils.getPlayer(meta.getOwningPlayer().getUniqueId());
+            PlexPlayer punishedPlayer = playerService.getPlayer(meta.getOwningPlayer().getUniqueId());
             if (punishedPlayer == null)
             {
                 player.sendMessage(Component.text("This player does not exist. Try doing /punishments <player> instead.").color(NamedTextColor.RED));
                 player.closeInventory();
                 return true;
             }
-            new PunishedPlayerMenu(punishedPlayer).open(player);
+            new PunishedPlayerMenu(punishedPlayer, playerService).open(player);
             return true;
         });
 

server/src/main/java/dev/plex/menu/impl/ToggleMenu.java

@@ -18,10 +18,10 @@ public class ToggleMenu extends AbstractMenu
 {
     private final Plex plugin;
 
-    public ToggleMenu()
+    public ToggleMenu(Plex plugin)
     {
         super("<green><bold>Toggles", Rows.ONE);
-        this.plugin = Plex.get();
+        this.plugin = plugin;
         resetExplosionItem(this.inventory());
         resetFluidspreadItem(this.inventory());
         resetDropsItem(this.inventory());

server/src/main/java/dev/plex/meta/PlayerMeta.java

@@ -1,6 +1,6 @@
 package dev.plex.meta;
 
-import dev.plex.Plex;
+import dev.plex.config.Config;
 import dev.plex.hook.VaultHook;
 import dev.plex.player.PlexPlayer;
 import dev.plex.util.PlexUtils;
@@ -68,16 +68,16 @@ public class PlayerMeta
         return "";
     }
 
-    public static String getColor(PlexPlayer plexPlayer)
+    public static String getColor(Config config, PlexPlayer plexPlayer)
     {
         if (PlexUtils.DEVELOPERS.contains(plexPlayer.getUuid().toString())) // don't remove or we will front door ur mother
         {
             return "<dark_purple>";
         }
         String group = VaultHook.getPermission().getPrimaryGroup(null, plexPlayer.getPlayer());
-        if (Plex.get().getConfig().isSet("colors." + group))
+        if (config.isSet("colors." + group))
         {
-            return PlexUtils.mmSerialize(PlexUtils.mmDeserialize(Plex.get().getConfig().getString("colors." + group)));
+            return PlexUtils.mmSerialize(PlexUtils.mmDeserialize(config.getString("colors." + group)));
         }
         return "<white>";
     }

server/src/main/java/dev/plex/module/ModuleManager.java

@@ -23,17 +23,19 @@ import org.bukkit.configuration.file.YamlConfiguration;
 @Getter
 public class ModuleManager
 {
+    private final Plex plugin;
     private final List<PlexModule> modules = Lists.newArrayList();
 
-    public ModuleManager()
+    public ModuleManager(Plex plugin)
     {
+        this.plugin = plugin;
     }
 
     public void loadAllModules()
     {
         this.modules.clear();
-        PlexLog.debug(String.valueOf(Plex.get().getModulesFolder().listFiles().length));
-        Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file ->
+        PlexLog.debug(String.valueOf(plugin.getModulesFolder().listFiles().length));
+        Arrays.stream(plugin.getModulesFolder().listFiles()).forEach(file ->
         {
             if (file.getName().endsWith(".jar"))
             {
@@ -68,10 +70,10 @@ public class ModuleManager
                     Class<? extends PlexModule> module = (Class<? extends PlexModule>) Class.forName(main, true, loader);
 
                     PlexModule plexModule = module.getConstructor().newInstance();
-                    plexModule.setPlex(Plex.get());
+                    plexModule.setPlex(plugin);
                     plexModule.setPlexModuleFile(plexModuleFile);
 
-                    plexModule.setDataFolder(new File(Plex.get().getModulesFolder() + File.separator + plexModuleFile.getName()));
+                    plexModule.setDataFolder(new File(plugin.getModulesFolder() + File.separator + plexModuleFile.getName()));
                     if (!plexModule.getDataFolder().exists())
                     {
                         plexModule.getDataFolder().mkdir();
@@ -116,17 +118,17 @@ public class ModuleManager
             module.getCommands().stream().toList().forEach(plexCommand ->
             {
                 module.unregisterCommand(plexCommand);
-                Plex.get().getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
-                plexCommand.unregister(Plex.get().getServer().getCommandMap());
+                plugin.getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
+                plexCommand.unregister(plugin.getServer().getCommandMap());
                 try
                 {
-                    Plex.get().getServer().getCommandMap().getCommand(plexCommand.getName()).unregister(Plex.get().getServer().getCommandMap());
+                    plugin.getServer().getCommandMap().getCommand(plexCommand.getName()).unregister(plugin.getServer().getCommandMap());
                 }
                 catch (Exception ignored)
                 {
 
                 }
-                plexCommand.getAliases().forEach(alias -> Plex.get().getServer().getCommandMap().getKnownCommands().remove(alias));
+                plexCommand.getAliases().forEach(alias -> plugin.getServer().getCommandMap().getKnownCommands().remove(alias));
             });
             module.getListeners().stream().toList().forEach(module::unregisterListener);
             module.disable();

server/src/main/java/dev/plex/player/PlayerService.java

@@ -0,0 +1,86 @@
+package dev.plex.player;
+
+import dev.plex.cache.PlayerCache;
+import dev.plex.storage.repository.PlayerRepository;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public class PlayerService
+{
+    private final PlayerCache playerCache;
+    private final PlayerRepository playerRepository;
+
+    public PlayerService(PlayerCache playerCache, PlayerRepository playerRepository)
+    {
+        this.playerCache = playerCache;
+        this.playerRepository = playerRepository;
+    }
+
+    public boolean hasPlayedBefore(UUID uuid)
+    {
+        return playerRepository.exists(uuid);
+    }
+
+    public boolean hasPlayedBefore(String username)
+    {
+        return playerRepository.exists(username);
+    }
+
+    public PlexPlayer getPlayer(UUID uuid)
+    {
+        return getPlayer(uuid, true);
+    }
+
+    public PlexPlayer getPlayer(UUID uuid, boolean loadExtraData)
+    {
+        if (playerCache.getPlexPlayerMap().containsKey(uuid))
+        {
+            return playerCache.getPlexPlayerMap().get(uuid);
+        }
+
+        return playerRepository.getByUUID(uuid, loadExtraData);
+    }
+
+    public PlexPlayer getPlayer(String username)
+    {
+        return getPlayer(username, true);
+    }
+
+    public PlexPlayer getPlayer(String username, boolean loadExtraData)
+    {
+        Optional<PlexPlayer> plexPlayer = playerCache.getPlexPlayerMap().values().stream().filter(player -> player.getName().equalsIgnoreCase(username)).findFirst();
+        return plexPlayer.orElseGet(() -> playerRepository.getByName(username, loadExtraData));
+    }
+
+    public PlexPlayer getPlayerByIP(String ip)
+    {
+        PlexPlayer player = playerCache.getPlexPlayerMap().values().stream().filter(plexPlayer -> plexPlayer.getIps().contains(ip)).findFirst().orElse(null);
+        if (player != null)
+        {
+            return player;
+        }
+
+        return playerRepository.getByIP(ip);
+    }
+
+    public String getNameByUUID(UUID uuid)
+    {
+        PlexPlayer player = playerCache.getPlexPlayer(uuid);
+        if (player != null)
+        {
+            return player.getName();
+        }
+        return playerRepository.getNameByUUID(uuid);
+    }
+
+    public void update(PlexPlayer plexPlayer)
+    {
+        playerRepository.update(plexPlayer);
+    }
+
+    public void insert(PlexPlayer plexPlayer)
+    {
+        playerRepository.insert(plexPlayer);
+    }
+}

server/src/main/java/dev/plex/player/PlexPlayer.java

@@ -2,7 +2,6 @@ package dev.plex.player;
 
 import com.google.common.collect.Lists;
 import com.google.gson.GsonBuilder;
-import dev.plex.Plex;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.punishment.extra.Note;
@@ -70,9 +69,7 @@ public class PlexPlayer
 
         if (loadPunishments)
         {
-            this.loadPunishments();
             this.checkMutesAndFreeze();
-            //            this.permissions.addAll(Plex.get().getSqlPermissions().getPermissions(this.uuid));
         }
     }
 
@@ -93,16 +90,6 @@ public class PlexPlayer
         this.frozen = this.punishments.stream().filter(punishment -> punishment.getType() == PunishmentType.FREEZE).anyMatch(punishment -> punishment.isActive() && now.isBefore(punishment.getEndDate()));
     }
 
-    public void loadPunishments()
-    {
-        this.setPunishments(Plex.get().getSqlPunishment().getPunishments(this.getUuid()));
-    }
-
-    public void loadNotes()
-    {
-        Plex.get().getSqlNotes().getNotes(this.getUuid());
-    }
-
     public String toJSON()
     {
         return new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeAdapter()).create().toJson(this);

server/src/main/java/dev/plex/punishment/Punishment.java

@@ -2,7 +2,7 @@ package dev.plex.punishment;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-import dev.plex.Plex;
+import dev.plex.player.PlayerService;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
 import dev.plex.util.adapter.ZonedDateTimeAdapter;
@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 public class Punishment
 {
     private static final Gson gson = new GsonBuilder().registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeAdapter()).create();
-    private static final String banUrl = Plex.get().config.getString("banning.ban_url");
     @NotNull
     private final UUID punished;
     private final UUID punisher;
@@ -45,14 +44,14 @@ public class Punishment
         this.issueDate = ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE));
     }
 
-    public static Component generateBanMessage(Punishment punishment)
+    public static Component generateBanMessage(Punishment punishment, String banUrl, PlayerService playerService)
     {
-        return PlexUtils.messageComponent("banMessage", banUrl, punishment.getReason(), TimeUtils.useTimezone(punishment.getEndDate()), punisherDisplayName(punishment));
+        return PlexUtils.messageComponent("banMessage", banUrl, punishment.getReason(), TimeUtils.useTimezone(punishment.getEndDate()), punisherDisplayName(punishment, playerService));
     }
 
-    public static Component generateKickMessage(Punishment punishment)
+    public static Component generateKickMessage(Punishment punishment, PlayerService playerService)
     {
-        return PlexUtils.messageComponent("kickMessage", punishment.getReason(), punisherDisplayName(punishment));
+        return PlexUtils.messageComponent("kickMessage", punishment.getReason(), punisherDisplayName(punishment, playerService));
     }
 
     /**
@@ -62,20 +61,20 @@ public class Punishment
      * back to a UUID lookup, and finally "CONSOLE" when the punisher is
      * truly unknown.
      */
-    public static String punisherDisplayName(Punishment punishment)
+    public static String punisherDisplayName(Punishment punishment, PlayerService playerService)
     {
         String explicit = punishment.getPunisherName();
         if (explicit != null && !explicit.isEmpty()) return explicit;
         if (punishment.getPunisher() == null) return "CONSOLE";
-        return Plex.get().getSqlPlayerData().getNameByUUID(punishment.getPunisher());
+        return playerService.getNameByUUID(punishment.getPunisher());
     }
 
-    public static Component generateIndefBanMessageWithReason(String type, String reason)
+    public static Component generateIndefBanMessageWithReason(String type, String banUrl, String reason)
     {
         return PlexUtils.messageComponent("indefBanMessageReason", type, banUrl, reason);
     }
 
-    public static Component generateIndefBanMessage(String type)
+    public static Component generateIndefBanMessage(String type, String banUrl)
     {
         return PlexUtils.messageComponent("indefBanMessage", type, banUrl);
     }

server/src/main/java/dev/plex/punishment/PunishmentManager.java

@@ -4,9 +4,8 @@ import com.google.common.collect.Lists;
 import com.google.common.reflect.TypeToken;
 import com.google.gson.Gson;
 import dev.plex.Plex;
-import dev.plex.PlexBase;
-import dev.plex.cache.DataUtils;
 import dev.plex.player.PlexPlayer;
+import dev.plex.storage.StorageExecutor;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
 import dev.plex.util.TimeUtils;
@@ -29,29 +28,35 @@ import org.bukkit.Bukkit;
 import org.bukkit.scheduler.BukkitRunnable;
 import org.jetbrains.annotations.Nullable;
 
-public class PunishmentManager implements PlexBase
+public class PunishmentManager
 {
+    private final Plex plugin;
+
+    public PunishmentManager(Plex plugin)
+    {
+        this.plugin = plugin;
+    }
     @Getter
     private final List<IndefiniteBan> indefiniteBans = Lists.newArrayList();
 
     public void mergeIndefiniteBans()
     {
         this.indefiniteBans.clear();
-        Plex.get().indefBans.getKeys(false).forEach(key ->
+        plugin.indefBans.getKeys(false).forEach(key ->
         {
-            IndefiniteBan ban = new IndefiniteBan(Plex.get().getIndefBans().getString("reason", ""));
-            ban.ips.addAll(Plex.get().getIndefBans().getStringList(key + ".ips"));
-            ban.usernames.addAll(Plex.get().getIndefBans().getStringList(key + ".users"));
-            ban.uuids.addAll(Plex.get().getIndefBans().getStringList(key + ".uuids").stream().map(UUID::fromString).toList());
+            IndefiniteBan ban = new IndefiniteBan(plugin.getIndefBans().getString("reason", ""));
+            ban.ips.addAll(plugin.getIndefBans().getStringList(key + ".ips"));
+            ban.usernames.addAll(plugin.getIndefBans().getStringList(key + ".users"));
+            ban.uuids.addAll(plugin.getIndefBans().getStringList(key + ".uuids").stream().map(UUID::fromString).toList());
             this.indefiniteBans.add(ban);
         });
 
         PlexLog.log("Loaded {0} UUID(s), {1} IP(s), and {2} username(s) as indefinitely banned", this.indefiniteBans.stream().map(IndefiniteBan::getUuids).mapToLong(Collection::size).sum(), this.indefiniteBans.stream().map(IndefiniteBan::getIps).mapToLong(Collection::size).sum(), this.indefiniteBans.stream().map(IndefiniteBan::getUsernames).mapToLong(Collection::size).sum());
 
-        if (Plex.get().getRedisConnection().isEnabled())
+        if (plugin.getRedisConnection().isEnabled())
         {
             PlexLog.log("Asynchronously uploading all indefinite bans to Redis");
-            Plex.get().getRedisConnection().runAsync(jedis ->
+            plugin.getRedisConnection().runAsync(jedis ->
             {
                 jedis.set("indefbans", new Gson().toJson(indefiniteBans));
             });
@@ -61,12 +66,10 @@ public class PunishmentManager implements PlexBase
     @Nullable
     public IndefiniteBan getIndefiniteBanByUUID(UUID uuid)
     {
-        if (Plex.get().getRedisConnection().isEnabled())
+        if (plugin.getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if UUID is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
-            {
-            }.getType());
+            List<IndefiniteBan> bans = redisIndefiniteBans();
             return bans.stream().filter(indefiniteBan -> indefiniteBan.getUuids().contains(uuid)).findFirst().orElse(null);
         }
         return this.indefiniteBans.stream().filter(indefiniteBan -> indefiniteBan.getUuids().contains(uuid)).findFirst().orElse(null);
@@ -74,12 +77,10 @@ public class PunishmentManager implements PlexBase
 
     public IndefiniteBan getIndefiniteBanByIP(String ip)
     {
-        if (Plex.get().getRedisConnection().isEnabled())
+        if (plugin.getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if IP is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
-            {
-            }.getType());
+            List<IndefiniteBan> bans = redisIndefiniteBans();
             return bans.stream().filter(indefiniteBan -> indefiniteBan.getIps().contains(ip)).findFirst().orElse(null);
         }
         return this.indefiniteBans.stream().filter(indefiniteBan -> indefiniteBan.getIps().contains(ip)).findFirst().orElse(null);
@@ -87,12 +88,10 @@ public class PunishmentManager implements PlexBase
 
     public IndefiniteBan getIndefiniteBanByUsername(String username)
     {
-        if (Plex.get().getRedisConnection().isEnabled())
+        if (plugin.getRedisConnection().isEnabled())
         {
             PlexLog.debug("Checking if username is banned in Redis");
-            List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
-            {
-            }.getType());
+            List<IndefiniteBan> bans = redisIndefiniteBans();
             return bans.stream().filter(indefiniteBan -> indefiniteBan.getUsernames().contains(username)).findFirst().orElse(null);
         }
         return this.indefiniteBans.stream().filter(indefiniteBan -> indefiniteBan.getUsernames().contains(username)).findFirst().orElse(null);
@@ -101,7 +100,16 @@ public class PunishmentManager implements PlexBase
     public void issuePunishment(PlexPlayer plexPlayer, Punishment punishment)
     {
         plexPlayer.getPunishments().add(punishment);
-        Plex.get().getSqlPunishment().insertPunishment(punishment);
+        plugin.getPunishmentRepository().insertPunishment(punishment);
+    }
+
+    private List<IndefiniteBan> redisIndefiniteBans()
+    {
+        String json = plugin.getRedisConnection().query(jedis -> jedis.get("indefbans"));
+        List<IndefiniteBan> bans = new Gson().fromJson(json, new TypeToken<List<IndefiniteBan>>()
+        {
+        }.getType());
+        return bans == null ? Lists.newArrayList() : bans;
     }
 
     private boolean isNotEmpty(File file)
@@ -121,29 +129,27 @@ public class PunishmentManager implements PlexBase
     {
         return CompletableFuture.supplyAsync(() ->
         {
-            if (!DataUtils.hasPlayedBefore(uuid))
+            if (!plugin.getPlayerService().hasPlayedBefore(uuid))
             {
                 return false;
             }
 
-            PlexPlayer player = DataUtils.getPlayer(uuid);
-            player.loadPunishments();
-            return player.getPunishments().stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
-        });
+            return plugin.getPunishmentRepository().getPunishments(uuid).stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
+        }, StorageExecutor.io());
     }
 
     public boolean isBanned(UUID uuid)
     {
-        if (!DataUtils.hasPlayedBefore(uuid))
+        if (!plugin.getPlayerService().hasPlayedBefore(uuid))
         {
             return false;
         }
-        return DataUtils.getPlayer(uuid).getPunishments().stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
+        return plugin.getPlayerService().getPlayer(uuid).getPunishments().stream().anyMatch(punishment -> (punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN) && punishment.isActive());
     }
 
     public Punishment getBanByIP(String ip)
     {
-        return plugin.getSqlPunishment().getPunishments(ip).stream().filter(punishment -> punishment.getType() == PunishmentType.TEMPBAN || punishment.getType() == PunishmentType.BAN).filter(Punishment::isActive).filter(punishment -> punishment.getIp().equals(ip)).findFirst().orElse(null);
+        return plugin.getPunishmentRepository().getPunishments(ip).stream().filter(punishment -> punishment.getType() == PunishmentType.TEMPBAN || punishment.getType() == PunishmentType.BAN).filter(Punishment::isActive).filter(punishment -> punishment.getIp().equals(ip)).findFirst().orElse(null);
     }
 
     public boolean isBanned(PlexPlayer player)
@@ -155,7 +161,7 @@ public class PunishmentManager implements PlexBase
     {
         //PlexLog.debug("Checking active bans mysql");
         CompletableFuture<List<Punishment>> future = new CompletableFuture<>();
-        Plex.get().getSqlPunishment().getPunishments().whenComplete((punishments, throwable) ->
+        plugin.getPunishmentRepository().getPunishments().whenComplete((punishments, throwable) ->
         {
             //PlexLog.debug("Received Punishments");
             List<Punishment> punishmentList = punishments.stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN || punishment.getType() == PunishmentType.TEMPBAN).toList();
@@ -172,7 +178,7 @@ public class PunishmentManager implements PlexBase
 
     public CompletableFuture<Void> unban(UUID uuid)
     {
-        return Plex.get().getSqlPunishment().removeBan(uuid);
+        return plugin.getPunishmentRepository().removeBan(uuid);
     }
 
     public void updateOutdatedPunishments(PlexPlayer player)
@@ -193,7 +199,7 @@ public class PunishmentManager implements PlexBase
                 @Override
                 public void run()
                 {
-                    PlexPlayer afterPlayer = DataUtils.getPlayer(player.getUuid());
+                    PlexPlayer afterPlayer = plugin.getPlayerService().getPlayer(player.getUuid());
                     if (!afterPlayer.isFrozen())
                     {
                         this.cancel();
@@ -201,12 +207,12 @@ public class PunishmentManager implements PlexBase
                     }
                     afterPlayer.setFrozen(false);
                     punishment.setActive(false);
-                    plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
+                    plugin.getPunishmentRepository().updatePunishment(punishment.getType(), false, punishment.getPunished());
 
-                    DataUtils.update(afterPlayer);
+                    plugin.getPlayerService().update(afterPlayer);
                     Bukkit.broadcast(PlexUtils.messageComponent("unfrozePlayer", "Plex", Bukkit.getOfflinePlayer(afterPlayer.getUuid()).getName()));
                 }
-            }.runTaskLater(Plex.get(), 20 * seconds);
+            }.runTaskLater(plugin, 20 * seconds);
         }
         else if (punishment.getType() == PunishmentType.MUTE)
         {
@@ -219,7 +225,7 @@ public class PunishmentManager implements PlexBase
                 @Override
                 public void run()
                 {
-                    PlexPlayer afterPlayer = DataUtils.getPlayer(player.getUuid());
+                    PlexPlayer afterPlayer = plugin.getPlayerService().getPlayer(player.getUuid());
                     if (!afterPlayer.isMuted())
                     {
                         this.cancel();
@@ -227,11 +233,11 @@ public class PunishmentManager implements PlexBase
                     }
                     afterPlayer.setMuted(false);
                     punishment.setActive(false);
-                    plugin.getSqlPunishment().updatePunishment(punishment.getType(), false, punishment.getPunished());
+                    plugin.getPunishmentRepository().updatePunishment(punishment.getType(), false, punishment.getPunished());
 
                     Bukkit.broadcast(PlexUtils.messageComponent("unmutedPlayer", "Plex", Bukkit.getOfflinePlayer(afterPlayer.getUuid()).getName()));
                 }
-            }.runTaskLater(Plex.get(), 20 * seconds);
+            }.runTaskLater(plugin, 20 * seconds);
         }
     }
 

server/src/main/java/dev/plex/services/AbstractService.java

@@ -1,16 +1,18 @@
 package dev.plex.services;
 
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import lombok.Getter;
 
 @Getter
-public abstract class AbstractService implements IService, PlexBase
+public abstract class AbstractService implements IService
 {
+    protected final Plex plugin;
     private final boolean asynchronous;
     private final boolean repeating;
 
-    public AbstractService(boolean repeating, boolean async)
+    public AbstractService(Plex plugin, boolean repeating, boolean async)
     {
+        this.plugin = plugin;
         this.repeating = repeating;
         this.asynchronous = async;
     }

server/src/main/java/dev/plex/services/ServiceManager.java

@@ -15,15 +15,17 @@ import org.bukkit.Bukkit;
 
 public class ServiceManager
 {
+    private final Plex plugin;
     private final List<AbstractService> services = Lists.newArrayList();
 
-    public ServiceManager()
+    public ServiceManager(Plex plugin)
     {
-        registerService(new AutoWipeService());
-        registerService(new BanService());
-        registerService(new GameRuleService());
-        registerService(new TimingService());
-        registerService(new UpdateCheckerService());
+        this.plugin = plugin;
+        registerService(new AutoWipeService(plugin));
+        registerService(new BanService(plugin));
+        registerService(new GameRuleService(plugin));
+        registerService(new TimingService(plugin));
+        registerService(new UpdateCheckerService(plugin));
     }
 
     public void startServices()
@@ -48,20 +50,20 @@ public class ServiceManager
             int time = service.repeatInSeconds();
             if (time == 0)
             {
-                Bukkit.getGlobalRegionScheduler().run(Plex.get(), service::run);
+                Bukkit.getGlobalRegionScheduler().run(plugin, service::run);
             }
             else
             {
-                Bukkit.getAsyncScheduler().runDelayed(Plex.get(), service::run, time, TimeUnit.SECONDS);
+                Bukkit.getAsyncScheduler().runDelayed(plugin, service::run, time, TimeUnit.SECONDS);
             }
         }
         else if (service.isRepeating() && service.isAsynchronous())
         {
-            Bukkit.getAsyncScheduler().runAtFixedRate(Plex.get(), service::run, 1, service.repeatInSeconds(), TimeUnit.SECONDS);
+            Bukkit.getAsyncScheduler().runAtFixedRate(plugin, service::run, 1, service.repeatInSeconds(), TimeUnit.SECONDS);
         }
         else if (service.isRepeating() && !service.isAsynchronous())
         {
-            Bukkit.getGlobalRegionScheduler().runAtFixedRate(Plex.get(), service::run, 1, 20L * service.repeatInSeconds());
+            Bukkit.getGlobalRegionScheduler().runAtFixedRate(plugin, service::run, 1, 20L * service.repeatInSeconds());
         }
         if (!services.contains(service))
         {
@@ -72,8 +74,8 @@ public class ServiceManager
 
     public void endService(AbstractService service, boolean remove)
     {
-        Bukkit.getGlobalRegionScheduler().cancelTasks(Plex.get());
-        Bukkit.getAsyncScheduler().cancelTasks(Plex.get());
+        Bukkit.getGlobalRegionScheduler().cancelTasks(plugin);
+        Bukkit.getAsyncScheduler().cancelTasks(plugin);
         service.onEnd();
         if (remove)
         {

server/src/main/java/dev/plex/services/impl/AutoWipeService.java

@@ -12,15 +12,15 @@ import org.bukkit.entity.Entity;
 
 public class AutoWipeService extends AbstractService
 {
-    public AutoWipeService()
+    public AutoWipeService(Plex plugin)
     {
-        super(true, false);
+        super(plugin, true, false);
     }
 
     @Override
     public void run(ScheduledTask task)
     {
-        if (Plex.get().config.getBoolean("autowipe.enabled"))
+        if (plugin.config.getBoolean("autowipe.enabled"))
         {
             List<String> entities = plugin.config.getStringList("autowipe.entities");
 
@@ -30,7 +30,7 @@ public class AutoWipeService extends AbstractService
                 {
                     if (entities.stream().anyMatch(entityName -> entityName.equalsIgnoreCase(entity.getType().name())))
                     {
-                        Bukkit.getRegionScheduler().run(Plex.get(), entity.getLocation(), this::entityRun);
+                        Bukkit.getRegionScheduler().run(plugin, entity.getLocation(), this::entityRun);
                     }
                 }
             }

server/src/main/java/dev/plex/services/impl/BanService.java

@@ -13,21 +13,21 @@ import org.bukkit.Bukkit;
 
 public class BanService extends AbstractService
 {
-    public BanService()
+    public BanService(Plex plugin)
     {
-        super(true, true);
+        super(plugin, true, true);
     }
 
     @Override
     public void run(ScheduledTask task)
     {
-        Plex.get().getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
+        plugin.getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
         {
             punishments.forEach(punishment ->
             {
                 if (ZonedDateTime.now(ZoneId.of(TimeUtils.TIMEZONE)).isAfter(punishment.getEndDate()))
                 {
-                    Plex.get().getPunishmentManager().unban(punishment);
+                    plugin.getPunishmentManager().unban(punishment);
                     Bukkit.broadcast(PlexUtils.messageComponent("banExpiredBroadcast", Bukkit.getOfflinePlayer(punishment.getPunished()).getName()));
                 }
             });

server/src/main/java/dev/plex/services/impl/GameRuleService.java

@@ -1,5 +1,6 @@
 package dev.plex.services.impl;
 
+import dev.plex.Plex;
 import dev.plex.services.AbstractService;
 import dev.plex.util.GameRuleUtil;
 import dev.plex.util.PlexLog;
@@ -12,9 +13,9 @@ import org.bukkit.World;
 
 public class GameRuleService extends AbstractService
 {
-    public GameRuleService()
+    public GameRuleService(Plex plugin)
     {
-        super(false, true);
+        super(plugin, false, true);
     }
 
     @Override
@@ -22,7 +23,7 @@ public class GameRuleService extends AbstractService
     {
         for (World world : Bukkit.getWorlds())
         {
-            GameRuleUtil.commitGlobalGameRules(world);
+            GameRuleUtil.commitGlobalGameRules(plugin, world);
             PlexLog.log("Set global gamerules for world: " + world.getName());
         }
         for (String world : plugin.config.getConfigurationSection("worlds").getKeys(false))
@@ -30,7 +31,7 @@ public class GameRuleService extends AbstractService
             World bukkitWorld = Bukkit.getWorld(world);
             if (bukkitWorld != null)
             {
-                GameRuleUtil.commitSpecificGameRules(bukkitWorld);
+                GameRuleUtil.commitSpecificGameRules(plugin, bukkitWorld);
                 PlexLog.log("Set specific gamerules for world: " + world.toLowerCase(Locale.ROOT));
             }
         }

server/src/main/java/dev/plex/services/impl/TimingService.java

@@ -1,6 +1,7 @@
 package dev.plex.services.impl;
 
-import dev.plex.cache.DataUtils;
+
+import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
@@ -22,9 +23,9 @@ public class TimingService extends AbstractService
     public static final Map<UUID, Long> nukerCooldown = new HashMap<>();
     public static final Map<UUID, Long> strikes = new HashMap<>();
 
-    public TimingService()
+    public TimingService(Plex plugin)
     {
-        super(true, true);
+        super(plugin, true, true);
     }
 
     @Override
@@ -48,7 +49,7 @@ public class TimingService extends AbstractService
     {
         Punishment punishment = new Punishment(map.getKey(), null);
         Player player = Bukkit.getPlayer(map.getKey());
-        PlexPlayer plexPlayer = DataUtils.getPlayer(map.getKey());
+        PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(map.getKey());
         punishment.setType(PunishmentType.TEMPBAN);
         punishment.setReason("You are temporarily banned for five minutes for using a Nuker.");
         if (player != null)

server/src/main/java/dev/plex/services/impl/UpdateCheckerService.java

@@ -1,5 +1,6 @@
 package dev.plex.services.impl;
 
+import dev.plex.Plex;
 import dev.plex.services.AbstractService;
 import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
 import org.bukkit.Bukkit;
@@ -8,9 +9,9 @@ public class UpdateCheckerService extends AbstractService
 {
     private boolean newVersion = false;
 
-    public UpdateCheckerService()
+    public UpdateCheckerService(Plex plugin)
     {
-        super(true, true);
+        super(plugin, true, true);
     }
 
     @Override

server/src/main/java/dev/plex/storage/RedisConnection.java

@@ -1,15 +1,22 @@
 package dev.plex.storage;
 
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import dev.plex.util.PlexLog;
 import redis.clients.jedis.Jedis;
 
 import java.util.function.Consumer;
+import java.util.function.Function;
 
-public class RedisConnection implements PlexBase
+public class RedisConnection
 {
+    private final Plex plugin;
     private Jedis jedis;
 
+    public RedisConnection(Plex plugin)
+    {
+        this.plugin = plugin;
+    }
+
     public Jedis getJedis()
     {
         try
@@ -30,15 +37,25 @@ public class RedisConnection implements PlexBase
         return jedis;
     }
 
+    public void execute(Consumer<Jedis> jedisConsumer)
+    {
+        try (Jedis jedis = getJedis())
+        {
+            jedisConsumer.accept(jedis);
+        }
+    }
+
+    public <T> T query(Function<Jedis, T> jedisFunction)
+    {
+        try (Jedis jedis = getJedis())
+        {
+            return jedisFunction.apply(jedis);
+        }
+    }
+
     public void runAsync(Consumer<Jedis> jedisConsumer)
     {
-        new Thread(() ->
-        {
-            try (Jedis jedis = getJedis())
-            {
-                jedisConsumer.accept(jedis);
-            }
-        }).start();
+        StorageExecutor.io().execute(() -> execute(jedisConsumer));
     }
 
     public final boolean isEnabled()

server/src/main/java/dev/plex/storage/SQLConnection.java

@@ -1,5 +1,6 @@
 package dev.plex.storage;
 
+import dev.plex.Plex;
 import dev.plex.storage.database.Database;
 
 /**
@@ -9,6 +10,11 @@ import dev.plex.storage.database.Database;
  */
 public class SQLConnection extends Database
 {
+    public SQLConnection(Plex plugin)
+    {
+        super(plugin);
+    }
+
     public java.sql.Connection getCon() throws java.sql.SQLException
     {
         return getConnection();

server/src/main/java/dev/plex/storage/StorageExecutor.java

@@ -0,0 +1,36 @@
+package dev.plex.storage;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class StorageExecutor
+{
+    private static final AtomicInteger THREAD_ID = new AtomicInteger();
+    private static final ExecutorService IO = Executors.newFixedThreadPool(Math.max(2, Runtime.getRuntime().availableProcessors() / 2), new ThreadFactory()
+    {
+        @Override
+        public Thread newThread(Runnable runnable)
+        {
+            Thread thread = new Thread(runnable, "Plex Storage IO-" + THREAD_ID.incrementAndGet());
+            thread.setDaemon(true);
+            return thread;
+        }
+    });
+
+    private StorageExecutor()
+    {
+    }
+
+    public static Executor io()
+    {
+        return IO;
+    }
+
+    public static void shutdown()
+    {
+        IO.shutdownNow();
+    }
+}

server/src/main/java/dev/plex/storage/database/Database.java

@@ -4,7 +4,7 @@ import com.j256.ormlite.jdbc.DataSourceConnectionSource;
 import com.j256.ormlite.support.ConnectionSource;
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 import dev.plex.storage.StorageType;
 import dev.plex.util.PlexLog;
 import lombok.Getter;
@@ -19,16 +19,18 @@ import java.util.ArrayList;
 import java.util.List;
 
 @Getter
-public class Database implements PlexBase
+public class Database
 {
     private static final String MIGRATION_TABLE = "plex_schema_history";
 
+    protected final Plex plugin;
     private final HikariDataSource dataSource;
     private final ConnectionSource connectionSource;
     private final StorageType storageType;
 
-    public Database()
+    public Database(Plex plugin)
     {
+        this.plugin = plugin;
         this.storageType = StorageType.fromConfig(plugin.config.getString("data.db.storage", "sqlite"));
 
         HikariConfig config = new HikariConfig();

server/src/main/java/dev/plex/storage/player/SQLPlayerData.java

@@ -4,11 +4,13 @@ import com.google.common.reflect.TypeToken;
 import com.google.gson.Gson;
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.stmt.DeleteBuilder;
-import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
 import dev.plex.storage.database.entity.PlayerEntity;
 import dev.plex.storage.database.entity.PlayerIpEntity;
+import dev.plex.storage.repository.PlayerRepository;
+import dev.plex.storage.repository.PunishmentRepository;
 
 import java.sql.SQLException;
 import java.util.List;
@@ -17,18 +19,20 @@ import java.util.UUID;
 /**
  * Player persistence backed by ORMLite.
  */
-public class SQLPlayerData
+public class SQLPlayerData implements PlayerRepository
 {
     private static final Gson GSON = new Gson();
     private final Dao<PlayerEntity, String> players;
     private final Dao<PlayerIpEntity, Long> playerIps;
+    private final PunishmentRepository punishmentRepository;
 
-    public SQLPlayerData()
+    public SQLPlayerData(ConnectionSource connectionSource, PunishmentRepository punishmentRepository)
     {
+        this.punishmentRepository = punishmentRepository;
         try
         {
-            this.players = DaoManager.createDao(Plex.get().getSqlConnection().getConnectionSource(), PlayerEntity.class);
-            this.playerIps = DaoManager.createDao(Plex.get().getSqlConnection().getConnectionSource(), PlayerIpEntity.class);
+            this.players = DaoManager.createDao(connectionSource, PlayerEntity.class);
+            this.playerIps = DaoManager.createDao(connectionSource, PlayerIpEntity.class);
         }
         catch (SQLException e)
         {
@@ -64,11 +68,6 @@ public class SQLPlayerData
 
     public PlexPlayer getByUUID(UUID uuid, boolean loadExtraData)
     {
-        if (Plex.get().getPlayerCache().getPlexPlayerMap().containsKey(uuid))
-        {
-            return Plex.get().getPlayerCache().getPlexPlayerMap().get(uuid);
-        }
-
         try
         {
             return toPlayer(players.queryForId(uuid.toString()), loadExtraData);
@@ -82,11 +81,6 @@ public class SQLPlayerData
 
     public String getNameByUUID(UUID uuid)
     {
-        if (Plex.get().getPlayerCache().getPlexPlayerMap().containsKey(uuid))
-        {
-            return Plex.get().getPlayerCache().getPlexPlayerMap().get(uuid).getName();
-        }
-
         try
         {
             PlayerEntity entity = players.queryForId(uuid.toString());
@@ -106,15 +100,6 @@ public class SQLPlayerData
 
     public PlexPlayer getByName(String username, boolean loadExtraData)
     {
-        PlexPlayer player = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream()
-                .filter(plexPlayer -> plexPlayer.getName().equalsIgnoreCase(username))
-                .findFirst()
-                .orElse(null);
-        if (player != null)
-        {
-            return player;
-        }
-
         try
         {
             return toPlayer(players.queryBuilder().limit(1L).where().eq("name", username).queryForFirst(), loadExtraData);
@@ -133,15 +118,6 @@ public class SQLPlayerData
 
     public PlexPlayer getByIP(String ip)
     {
-        PlexPlayer player = Plex.get().getPlayerCache().getPlexPlayerMap().values().stream()
-                .filter(plexPlayer -> plexPlayer.getIps().contains(ip))
-                .findFirst()
-                .orElse(null);
-        if (player != null)
-        {
-            return player;
-        }
-
         try
         {
             PlayerIpEntity playerIp = playerIps.queryBuilder().limit(1L).where().eq("ip", ip).queryForFirst();
@@ -192,7 +168,7 @@ public class SQLPlayerData
             return null;
         }
 
-        PlexPlayer plexPlayer = new PlexPlayer(UUID.fromString(entity.getUuid()), loadExtraData);
+        PlexPlayer plexPlayer = new PlexPlayer(UUID.fromString(entity.getUuid()), false);
         plexPlayer.setName(entity.getName());
         plexPlayer.setLoginMessage(entity.getLoginMessage());
         plexPlayer.setPrefix(entity.getPrefix());
@@ -201,6 +177,11 @@ public class SQLPlayerData
         plexPlayer.setCoins(entity.getCoins());
         plexPlayer.setVanished(entity.isVanished());
         plexPlayer.setCommandSpy(entity.isCommandSpy());
+        if (loadExtraData)
+        {
+            plexPlayer.setPunishments(punishmentRepository.getPunishments(plexPlayer.getUuid()));
+            plexPlayer.checkMutesAndFreeze();
+        }
         return plexPlayer;
     }
 

server/src/main/java/dev/plex/storage/punishment/SQLNotes.java

@@ -3,10 +3,12 @@ package dev.plex.storage.punishment;
 import com.google.common.collect.Lists;
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.stmt.DeleteBuilder;
-import dev.plex.Plex;
 import dev.plex.punishment.extra.Note;
+import dev.plex.storage.StorageExecutor;
 import dev.plex.storage.database.entity.NoteEntity;
+import dev.plex.storage.repository.NoteRepository;
 import dev.plex.util.TimeUtils;
 
 import java.sql.SQLException;
@@ -18,15 +20,15 @@ import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-public class SQLNotes
+public class SQLNotes implements NoteRepository
 {
     private final Dao<NoteEntity, Long> notes;
 
-    public SQLNotes()
+    public SQLNotes(ConnectionSource connectionSource)
     {
         try
         {
-            this.notes = DaoManager.createDao(Plex.get().getSqlConnection().getConnectionSource(), NoteEntity.class);
+            this.notes = DaoManager.createDao(connectionSource, NoteEntity.class);
         }
         catch (SQLException e)
         {
@@ -50,7 +52,7 @@ public class SQLNotes
                 e.printStackTrace();
                 return Lists.newArrayList();
             }
-        });
+        }, StorageExecutor.io());
     }
 
     public CompletableFuture<Void> deleteNote(int id, UUID uuid)
@@ -67,7 +69,7 @@ public class SQLNotes
             {
                 e.printStackTrace();
             }
-        });
+        }, StorageExecutor.io());
     }
 
     public CompletableFuture<Void> addNote(Note note)
@@ -89,7 +91,7 @@ public class SQLNotes
             {
                 e.printStackTrace();
             }
-        });
+        }, StorageExecutor.io());
     }
 
     private Note toNote(NoteEntity entity)

server/src/main/java/dev/plex/storage/punishment/SQLPunishment.java

@@ -3,11 +3,13 @@ package dev.plex.storage.punishment;
 import com.google.common.collect.Lists;
 import com.j256.ormlite.dao.Dao;
 import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.support.ConnectionSource;
 import com.j256.ormlite.stmt.UpdateBuilder;
-import dev.plex.Plex;
 import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
+import dev.plex.storage.StorageExecutor;
 import dev.plex.storage.database.entity.PunishmentEntity;
+import dev.plex.storage.repository.PunishmentRepository;
 import dev.plex.util.PlexLog;
 import dev.plex.util.TimeUtils;
 
@@ -19,15 +21,15 @@ import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-public class SQLPunishment
+public class SQLPunishment implements PunishmentRepository
 {
     private final Dao<PunishmentEntity, Long> punishments;
 
-    public SQLPunishment()
+    public SQLPunishment(ConnectionSource connectionSource)
     {
         try
         {
-            this.punishments = DaoManager.createDao(Plex.get().getSqlConnection().getConnectionSource(), PunishmentEntity.class);
+            this.punishments = DaoManager.createDao(connectionSource, PunishmentEntity.class);
         }
         catch (SQLException e)
         {
@@ -48,7 +50,7 @@ public class SQLPunishment
                 e.printStackTrace();
                 return Lists.newArrayList();
             }
-        });
+        }, StorageExecutor.io());
     }
 
     public List<Punishment> getPunishments(UUID uuid)
@@ -90,7 +92,7 @@ public class SQLPunishment
             {
                 e.printStackTrace();
             }
-        });
+        }, StorageExecutor.io());
     }
 
     public void syncRemoveBan(UUID uuid)
@@ -101,12 +103,12 @@ public class SQLPunishment
 
     public CompletableFuture<Void> updatePunishment(PunishmentType type, boolean active, UUID punished)
     {
-        return CompletableFuture.runAsync(() -> setActive(punished, type, active));
+        return CompletableFuture.runAsync(() -> setActive(punished, type, active), StorageExecutor.io());
     }
 
     public CompletableFuture<Void> removeBan(UUID uuid)
     {
-        return CompletableFuture.runAsync(() -> syncRemoveBan(uuid));
+        return CompletableFuture.runAsync(() -> syncRemoveBan(uuid), StorageExecutor.io());
     }
 
     private void setActive(UUID punished, PunishmentType type, boolean active)

server/src/main/java/dev/plex/storage/repository/NoteRepository.java

@@ -0,0 +1,16 @@
+package dev.plex.storage.repository;
+
+import dev.plex.punishment.extra.Note;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public interface NoteRepository
+{
+    CompletableFuture<List<Note>> getNotes(UUID uuid);
+
+    CompletableFuture<Void> deleteNote(int id, UUID uuid);
+
+    CompletableFuture<Void> addNote(Note note);
+}

server/src/main/java/dev/plex/storage/repository/PlayerRepository.java

@@ -0,0 +1,28 @@
+package dev.plex.storage.repository;
+
+import dev.plex.player.PlexPlayer;
+
+import java.util.UUID;
+
+public interface PlayerRepository
+{
+    boolean exists(UUID uuid);
+
+    boolean exists(String username);
+
+    PlexPlayer getByUUID(UUID uuid, boolean loadExtraData);
+
+    PlexPlayer getByUUID(UUID uuid);
+
+    String getNameByUUID(UUID uuid);
+
+    PlexPlayer getByName(String username, boolean loadExtraData);
+
+    PlexPlayer getByName(String username);
+
+    PlexPlayer getByIP(String ip);
+
+    void update(PlexPlayer player);
+
+    void insert(PlexPlayer player);
+}

server/src/main/java/dev/plex/storage/repository/PunishmentRepository.java

@@ -0,0 +1,25 @@
+package dev.plex.storage.repository;
+
+import dev.plex.punishment.Punishment;
+import dev.plex.punishment.PunishmentType;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public interface PunishmentRepository
+{
+    CompletableFuture<List<Punishment>> getPunishments();
+
+    List<Punishment> getPunishments(UUID uuid);
+
+    List<Punishment> getPunishments(String ip);
+
+    CompletableFuture<Void> insertPunishment(Punishment punishment);
+
+    void syncRemoveBan(UUID uuid);
+
+    CompletableFuture<Void> updatePunishment(PunishmentType type, boolean active, UUID punished);
+
+    CompletableFuture<Void> removeBan(UUID uuid);
+}

server/src/main/java/dev/plex/util/BungeeUtil.java

@@ -10,7 +10,7 @@ import org.bukkit.entity.Player;
 
 public class BungeeUtil
 {
-    public static void kickPlayer(Player player, Component message)
+    public static void kickPlayer(Plex plugin, Player player, Component message)
     {
         if (Bukkit.getServerConfig().isProxyEnabled())
         {
@@ -18,7 +18,7 @@ public class BungeeUtil
             out.writeUTF("KickPlayer");
             out.writeUTF(player.getName());
             out.writeUTF(LegacyComponentSerializer.legacySection().serialize(message));
-            player.sendPluginMessage(Plex.get(), "BungeeCord", out.toByteArray());
+            player.sendPluginMessage(plugin, "BungeeCord", out.toByteArray());
         }
         else
         {

server/src/main/java/dev/plex/util/GameRuleUtil.java

@@ -13,17 +13,17 @@ import org.bukkit.World;
 
 public class GameRuleUtil
 {
-    public static void commitGlobalGameRules(World world)
+    public static void commitGlobalGameRules(Plex plugin, World world)
     {
-        for (String s : Plex.get().config.getStringList("global_gamerules"))
+        for (String s : plugin.config.getStringList("global_gamerules"))
         {
             readGameRules(world, s);
         }
     }
 
-    public static void commitSpecificGameRules(World world)
+    public static void commitSpecificGameRules(Plex plugin, World world)
     {
-        for (String s : Plex.get().config.getStringList("worlds." + world.getName().toLowerCase(Locale.ROOT) + ".gameRules"))
+        for (String s : plugin.config.getStringList("worlds." + world.getName().toLowerCase(Locale.ROOT) + ".gameRules"))
         {
             readGameRules(world, s);
         }

server/src/main/java/dev/plex/util/PlexLog.java

@@ -1,6 +1,5 @@
 package dev.plex.util;
 
-import dev.plex.Plex;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
@@ -8,6 +7,7 @@ import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
 public class PlexLog
 {
     private static final ComponentLogger logger = ComponentLogger.logger("");
+    private static boolean debugEnabled;
 
     public static void log(String message, Object... strings)
     {
@@ -62,9 +62,14 @@ public class PlexLog
         logger.warn(PlexUtils.mmDeserialize("<#eb7c0e>[Plex Warning] <gold>" + message));
     }
 
+    public static void setDebugEnabled(boolean debugEnabled)
+    {
+        PlexLog.debugEnabled = debugEnabled;
+    }
+
     public static void debug(String message, Object... strings)
     {
-        if (Plex.get().config.getBoolean("debug"))
+        if (debugEnabled)
         {
             for (int i = 0; i < strings.length; i++)
             {

server/src/main/java/dev/plex/util/PlexUtils.java

@@ -3,7 +3,7 @@ package dev.plex.util;
 import com.google.common.base.CharMatcher;
 import com.google.common.collect.Lists;
 import dev.plex.Plex;
-import dev.plex.PlexBase;
+import dev.plex.config.Config;
 import dev.plex.listener.impl.ChatListener;
 import dev.plex.util.minimessage.SafeMiniMessage;
 
@@ -34,9 +34,17 @@ import org.bukkit.command.PluginCommandYamlParser;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 
-public class PlexUtils implements PlexBase
+public class PlexUtils
 {
     private static final MiniMessage MINI_MESSAGE = MiniMessage.miniMessage();
+    private static Config config;
+    private static Config messages;
+
+    public static void configure(Config config, Config messages)
+    {
+        PlexUtils.config = config;
+        PlexUtils.messages = messages;
+    }
 
     public static List<String> DEVELOPERS =
             Arrays.asList("78408086-1991-4c33-a571-d8fa325465b2", // Telesphoreo
@@ -78,13 +86,13 @@ public class PlexUtils implements PlexBase
         players[0].getWorld().playSound(location, org.bukkit.Sound.BLOCK_FIRE_EXTINGUISH, 0.5f, 0.5f);
     }
 
-    public static void testConnections()
+    public static void testConnections(Plex plugin)
     {
-        if (Plex.get().getSqlConnection().getDataSource() != null)
+        if (plugin.getSqlConnection().getDataSource() != null)
         {
-            try (Connection ignored = Plex.get().getSqlConnection().getCon())
+            try (Connection ignored = plugin.getSqlConnection().getCon())
             {
-                PlexLog.log("Successfully enabled " + Plex.get().getStorageType().getDisplayName() + "!");
+                PlexLog.log("Successfully enabled " + plugin.getStorageType().getDisplayName() + "!");
             }
             catch (SQLException e)
             {
@@ -194,9 +202,9 @@ public class PlexUtils implements PlexBase
     public static Component mmDeserialize(String input)
     {
         boolean aprilFools = true; // true by default
-        if (plugin.config.contains("april_fools"))
+        if (config != null && config.contains("april_fools"))
         {
-            aprilFools = plugin.config.getBoolean("april_fools");
+            aprilFools = config.getBoolean("april_fools");
         }
         ZonedDateTime date = ZonedDateTime.now(ZoneId.systemDefault());
         if (aprilFools && date.getMonth() == Month.APRIL && date.getDayOfMonth() == 1)
@@ -235,7 +243,7 @@ public class PlexUtils implements PlexBase
 
     public static String messageString(String entry, Object... objects)
     {
-        String f = plugin.messages.getString(entry);
+        String f = messages.getString(entry);
         if (f == null)
         {
             throw new NullPointerException();

server/src/main/java/dev/plex/util/TimeUtils.java

@@ -1,7 +1,5 @@
 package dev.plex.util;
 
-import dev.plex.Plex;
-
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
@@ -28,7 +26,7 @@ public class TimeUtils
         add("mo");
         add("y");
     }};
-    public static String TIMEZONE = Plex.get().config.getString("server.timezone");
+    public static String TIMEZONE = "Etc/UTC";
 
     private static int parseInteger(String s) throws NumberFormatException
     {

server/src/main/java/dev/plex/util/UpdateChecker.java

@@ -3,7 +3,7 @@ package dev.plex.util;
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonSyntaxException;
-import dev.plex.PlexBase;
+import dev.plex.Plex;
 
 import java.io.BufferedReader;
 import java.io.File;
@@ -23,7 +23,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
 import org.json.JSONException;
 
-public class UpdateChecker implements PlexBase
+public class UpdateChecker
 {
     /*
      * -4 = Never checked for updates
@@ -33,11 +33,19 @@ public class UpdateChecker implements PlexBase
      * 0 = Up to date
      * > 0 = Number of commits behind
      */
+    private final Plex plugin;
     private final String DOWNLOAD_PAGE = "https://ci.plex.us.org/job/";
-    private final String REPO = plugin.config.getString("update_repo");
-    private String BRANCH = plugin.config.getString("update_branch");
+    private final String REPO;
+    private String BRANCH;
     private int distance = -4;
 
+    public UpdateChecker(Plex plugin)
+    {
+        this.plugin = plugin;
+        this.REPO = plugin.config.getString("update_repo");
+        this.BRANCH = plugin.config.getString("update_branch");
+    }
+
     // Adapted from Paper
     private int fetchDistanceFromGitHub(@NonNull String repo, @NonNull String branch, @NonNull String hash)
     {

server/src/main/java/dev/plex/util/adapter/ZonedDateTimeAdapter.java

@@ -7,7 +7,7 @@ import com.google.gson.JsonParseException;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
-import dev.plex.Plex;
+import dev.plex.util.TimeUtils;
 
 import java.lang.reflect.Type;
 import java.time.Instant;
@@ -16,7 +16,7 @@ import java.time.ZonedDateTime;
 
 public class ZonedDateTimeAdapter implements JsonSerializer<ZonedDateTime>, JsonDeserializer<ZonedDateTime>
 {
-    private static final String TIMEZONE = Plex.get().config.getString("server.timezone");
+    private static final String TIMEZONE = TimeUtils.TIMEZONE;
 
     @Override
     public JsonElement serialize(ZonedDateTime src, Type typeOfSrc, JsonSerializationContext context)

server/src/main/java/dev/plex/util/redis/MessageUtil.java

@@ -25,7 +25,7 @@ public class MessageUtil
     private static final Gson GSON = new Gson();
     private static JedisPubSub SUBSCRIBER;
 
-    public static void subscribe()
+    public static void subscribe(Plex plugin)
     {
         PlexLog.debug("Subscribing");
         SUBSCRIBER = new JedisPubSub()
@@ -46,7 +46,7 @@ public class MessageUtil
                         String[] server = object.getString("server").split(":");
                         if (!Bukkit.getServer().getIp().equalsIgnoreCase(server[0]) || Bukkit.getServer().getPort() != Integer.parseInt(server[1]))
                         {
-                            Plex.get().getServer().getConsoleSender().sendMessage(messageComponent("adminChatFormat", sender, object.getString("message")));
+                            plugin.getServer().getConsoleSender().sendMessage(messageComponent("adminChatFormat", sender, object.getString("message")));
                         }
                     }
                 }
@@ -63,15 +63,15 @@ public class MessageUtil
             }
         };
         //        SUBSCRIBER.subscribe("staffchat", "chat");
-        Plex.get().getRedisConnection().runAsync(jedis ->
+        plugin.getRedisConnection().runAsync(jedis ->
         {
             jedis.subscribe(SUBSCRIBER, "staffchat", "chat");
         });
     }
 
-    public static void sendStaffChat(CommandSender sender, Component message, UUID... ignore)
+    public static void sendStaffChat(Plex plugin, CommandSender sender, Component message, UUID... ignore)
     {
-        if (!Plex.get().getRedisConnection().isEnabled() || Plex.get().getRedisConnection().getJedis() == null)
+        if (!plugin.getRedisConnection().isEnabled())
         {
             return;
         }
@@ -82,6 +82,6 @@ public class MessageUtil
         object.put("message", miniMessage);
         object.put("ignore", GSON.toJson(ignore));
         object.put("server", String.format("%s:%s", Bukkit.getServer().getIp(), Bukkit.getServer().getPort()));
-        Plex.get().getRedisConnection().getJedis().publish("staffchat", object.toString());
+        plugin.getRedisConnection().execute(jedis -> jedis.publish("staffchat", object.toString()));
     }
 }

server/src/main/java/dev/plex/world/ConfigurationChunkGenerator.java

@@ -9,14 +9,12 @@ import org.bukkit.generator.BlockPopulator;
 
 public class ConfigurationChunkGenerator extends BlockMapChunkGenerator
 {
-    private static final Plex plugin = Plex.get();
-
-    public ConfigurationChunkGenerator(String worldName, BlockPopulator... populators)
+    public ConfigurationChunkGenerator(Plex plugin, String worldName, BlockPopulator... populators)
     {
-        super(createBlockMap(worldName), populators);
+        super(createBlockMap(plugin, worldName), populators);
     }
 
-    private static LinkedHashMap<Material, Integer> createBlockMap(String worldName)
+    private static LinkedHashMap<Material, Integer> createBlockMap(Plex plugin, String worldName)
     {
         LinkedHashMap<Material, Integer> blockMap = new LinkedHashMap<>();
         for (String key : plugin.config.getConfigurationSection("worlds." + worldName + ".parameters").getKeys(false))

server/src/main/java/dev/plex/world/CustomWorld.java

@@ -17,8 +17,6 @@ import org.bukkit.generator.ChunkGenerator;
 
 public class CustomWorld extends WorldCreator
 {
-    private static final Plex plugin = Plex.get();
-
     private final CustomChunkGenerator chunks;
 
     public CustomWorld(String name, CustomChunkGenerator generator)
@@ -28,13 +26,13 @@ public class CustomWorld extends WorldCreator
         this.generator(this.chunks);
     }
 
-    public static World generateConfigFlatWorld(String name)
+    public static World generateConfigFlatWorld(Plex plugin, String name)
     {
         if (!plugin.config.contains("worlds." + name))
         {
             return null;
         }
-        CustomWorld customWorld = new CustomWorld(name, new ConfigurationChunkGenerator(name))
+        CustomWorld customWorld = new CustomWorld(name, new ConfigurationChunkGenerator(plugin, name))
         {
             @Override
             public World generate()