private String hostname, database, username, passwort;
    private int port;
    private static Connection connection;
    private ExecutorService executorService;

    public Database(String hostname, int port, String database, String username, String passwort) {
        this.hostname = hostname;
        this.port = port;
        this.database = database;
        this.username = username;
        this.passwort = passwort;
        this.executorService = Executors.newCachedThreadPool();

        openConnection();
    }

    private void openConnection() {
        try {
            if (getConnection() != null && !getConnection().isClosed()) {
                return;
            }
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://" + this.hostname + ":" + this.port + "/" + this.database + "?autoReconnect=true", this.username, this.passwort);
            Bukkit.getConsoleSender().sendMessage(Data.returnPrefix() + "Die Verbindung zum Datenbank-Server wurde hergestellt.");
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public void closeConnection() {

        if (isConnected()) {
            try {
                connection.close();
                Bukkit.getConsoleSender().sendMessage(Data.returnPrefix() + "Die Verbindung zum Datenbank-Server wurde getrennt.");
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                connection = null;
            }
        }
    }

    public Connection getConnection() {
        if (isConnected()) {
            return connection;
        }
        return null;
    }

    public boolean isConnected() {
        try {
            if (getConnection() == null || !getConnection().isValid(10) || getConnection().isClosed()) {
                return false;
            }
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    public void update(PreparedStatement preparedStatement) {
        if (isConnected()) {
            executorService.execute(() -> queryUpdate(preparedStatement));
        }
    }

    public void update(String s) {
        if (isConnected()) {
            executorService.execute(() -> queryUpdate(s));
        }
    }

    public ResultSet asyncQuery(PreparedStatement preparedStatement) {
        if (isConnected()) {
            Future<ResultSet> future = executorService.submit(() -> query(preparedStatement));
            try {
                return future.get();
            } catch (InterruptedException | ExecutionException exception) {
                exception.printStackTrace();
            }
        }
        return null;
    }

    public ResultSet asyncQuery(String s) {
        if (isConnected()) {
            Future<ResultSet> future = this.executorService.submit(() -> query(s));
            try {
                return future.get();
            } catch (InterruptedException | ExecutionException exception) {
                exception.printStackTrace();
            }
        }
        return null;
    }

    public PreparedStatement preparedStatement(String query) {
        if (isConnected()) {
            try {
                return getConnection().prepareStatement(query);
            } catch (SQLException exception) {
                exception.printStackTrace();
            }
        }
        return null;
    }

    public void queryUpdate(String query) {
        if (isConnected()) {
            try (PreparedStatement statment = getConnection().prepareStatement(query)) {
                queryUpdate(statment);
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
    }

    public ResultSet query(String query) {
        if (isConnected()) {
            try {
                return query(getConnection().prepareStatement(query));
            } catch (SQLException exception) {
                exception.printStackTrace();
            }
        }
        return null;
    }

    public void queryUpdate(PreparedStatement preparedStatement) {
        if (isConnected()) {
            try {
                preparedStatement.executeUpdate();
            } catch (SQLException exception) {
                exception.printStackTrace();
            }
        }
    }

    public ResultSet query(PreparedStatement preparedStatement) {
        if (isConnected()) {
            try {
                return preparedStatement.executeQuery();
            } catch (SQLException exception) {
                exception.printStackTrace();
            }
        }
        return null;
    }
}