MySQL Passwort Clientseitig ändern und über Button ausführen

[Marczii]

Hallo Freunde,

Ich versuche immoment in meiner App, das Passwort Clientseitig zu ändern und dies in der Datenbank anzupassen. Dazu habe ich drei Passwortfelder realisiert (Altes Passwort, neues Passwort und neuesPasswortwiederholen). Über einen Buttonclick in meinem Controller (der über die fxml erstellt wird), soll nach eingegebenen Daten alles funktionieren.

In meiner Klasse: MySQLDB, möchte Ich demnach eine Methode haben, die das gewährleistet.
Mir ist demnach noch nicht genau klar, wie Ich weitermachen soll und ob Ich auf dem richtigen weg bin.

Die MySQLDB Klasse:

public class MySQLDB implements DataBase {
 
    private final String aesKey = "(4+(#4..0.";

   private Connection conn;
   private String dbURL;
   private String user;
   private String password;

   public MySQLDB(final String databaseURL, final String userName, final String pass) {

        this.dbURL = databaseURL;
        this.user = userName;
        this.password = pass;
    }

    public void setDbURL(final String databaseURL) {
        this.dbURL = databaseURL;
    }

    public void setUser(final String userName) {
        this.user = userName;
    }

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

    public int init() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (Exception e) {
            System.err.println("Driver kann nicht geladen werden");
            e.printStackTrace();
            return -1;
        }
        System.out.println("Driver wurde geladen");
        try {
            conn = DriverManager.getConnection(dbURL, user, password);
            return 1;
        } catch (SQLException e) {
            System.err.println("Datenbankverbindung unterbrochen");
            return 0;
        }
    }
    public boolean close() {
        try {
            conn.close();
            System.out.println("Datenbankverbindung wurde geschlossen");
            return true;
        } catch (SQLException e) {
            System.err.println("Kann Datenbankverbindung nicht schließen");
            e.printStackTrace();
            return false;
        } catch (NullPointerException e) {
            System.err.println("Kann keine Datenbankverbindung schließen, die nicht etabliert ist");
            return false;
        }
    }

    public Boolean verify(final AuthRequest req) {

        PreparedStatement statement = null;
        final String sql = "SELECT name, password FROM user WHERE name LIKE ? AND password = AES_ENCRYPT(?,?);";

        try {

            int hits = 0;
            statement = conn.prepareStatement(sql);
            statement.setString(1, req.getUsername());
            statement.setString(2, req.getPassword());
            statement.setString(3, aesKey);
            ResultSet rs = statement.executeQuery();

            while (rs.next()) {
                hits++;
            }

            if (hits == 1) {
                return true;
            }

            statement.close();

            return false;

        } catch (SQLException e) {
            System.err.println(e.getMessage());
            return false;
        } catch (NullPointerException e) {
            System.err.println("Kann keine Datenbankverbindung schließen, die nicht etabliert ist");
            return false;
        } catch (Exception e) {
            System.err.println(e.getMessage());
            return false;
        }
    }

    public Boolean add(final AuthRequest req) {


        PreparedStatement statement = null;
        final String sql = "INSERT INTO user (name, password) VALUES (?, AES_ENCRYPT(?,?));";

        try {


            if (countUsername(req.getUsername()) > 0) {
                System.err.println("Benutzername existiert bereits");
                return false;
            }

            statement = conn.prepareStatement(sql);
            statement.setString(1, req.getUsername());
            statement.setString(2, req.getPassword());
            statement.setString(3, aesKey);
            statement.executeUpdate();

            statement.close();

            return true;

        } catch (SQLException e) {
            System.err.println(e.getMessage());
            return false;
        } catch (NullPointerException e) {
            System.err.println("Kann keine Datenbankverbindung schließen, die nicht etabliert ist");
            return false;
        } catch (Exception e) {
            System.err.println(e.getMessage());
            return false;
        }
    }

/* Methode um das Passwort zu ändern */
    public boolean changePassword (final String password) {
        if (conn != null) {
            try {
                Statement stmt = conn.createStatement();

               //Code

    private int countUsername(final String userName) {

        PreparedStatement statement = null;

        try {
            final String sql = "SELECT COUNT(name) AS result FROM user WHERE name LIKE ?;";

            statement = conn.prepareStatement(sql);
            statement.setString(1, userName);
            ResultSet rs = statement.executeQuery();

            int number = 0;

            while (rs.next()) {
                number = rs.getInt("result");

            }
            statement.close();
            return number;
        } catch (SQLException e) {
            System.err.println(e.getMessage());
            return 0;
        }

    }
}

Ebenso habe Ich eine zweite Klasse UserManagement, die den Zugriff über den Server klärt:

/**
* The User-management Service.
*/
public class UserManagement {


    private List<User> userList;
    private DBConnector dbc;
    private NetCom net;

    public UserManagement() {
        this.userList = new ArrayList<>();
    }

    @Subscribe
    public void auth(final AuthRequest req) {

        if (net.isRunning()) {

            User user = new User(req.getUsername(), req.getUserID());
            AuthResponse response;

            if (req.shouldAdd()) {
                response = new AuthResponse(dbc.add(req));
            } else {
                if (containsUsername(req.getUsername())) {
                    System.out.println("Already Contains!");
                    response = new AuthResponse(false);
                } else {
                    System.out.println("Verify User!");
                    response = new AuthResponse(dbc.verify(req));
                }
            }

            net.send(response, user.getId());

            if (response.isSucceeded()) {
                ReadWriteLock rwLock = new ReentrantReadWriteLock();
                Lock readLock = rwLock.readLock();

                readLock.lock();

                try {
                    this.userList.add(user);
                    net.identify(user.getId());
                    net.send(new UserListResponse(exportNames()), getUserIDs());
                } finally {
                    readLock.unlock();
                }
            }

        } else {
            System.err.println("Server was never launched!");
        }

    }

    @Subscribe
    public void logoutUser(final LogoutRequest request) {
        removeUser(request.getUserID());
        net.send(new UserListResponse(exportNames()), getUserIDs());
    }

    public void init(DBConnector db, NetCom netHandler) {
        dbc = db;
        this.net = netHandler;
        this.net.register(this);
    }

    public List<String> getUserIDs() { return userList.stream()
            .map(User::getId).collect(Collectors.toList()); }

    public User getUser(final String userID) {
        Optional<User> opt = userList.stream().filter(p -> p.getId()
                .equals(userID)).findAny();
        return opt.orElse(null);
    }

    public List<String> exportNames() {
        return userList.stream().map(User::getUserName)
                .collect(Collectors.toList());
    }

    private void removeUser(final String userID) {
        ReadWriteLock rwLock = new ReentrantReadWriteLock();
        Lock readLock = rwLock.readLock();

        readLock.lock();

        try {
            Optional<User> opt = userList.stream().filter(p -> p.getId()
                    .equals(userID)).findAny();

            opt.ifPresent(user -> userList.remove(user));
        } finally {
            readLock.unlock();
        }
    }
    boolean containsUser(final String id) {
        boolean retVal;

        ReadWriteLock rwLock = new ReentrantReadWriteLock();
        Lock writeLock = rwLock.writeLock();

        writeLock.lock();

        try {
            retVal = userList.stream().anyMatch(p -> p.getId()
                    .equals(id));
        } finally {
            writeLock.unlock();
        }


        return retVal;
    }


    boolean containsUsername(final String username) {
        boolean retVal;

        ReadWriteLock rwLock = new ReentrantReadWriteLock();
        Lock writeLock = rwLock.writeLock();

        writeLock.lock();

        try {
            retVal = userList.stream()
                    .anyMatch(p -> p.getUserName().equals(username));
        } finally {
            writeLock.unlock();
        }

        return retVal;
    }

    public List<User> getUserList() {
        return userList;
    }
}

Mir ist vielleicht erstmal wichtig, wie ich das angehen sollte.