GUI_Controller.java

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

import javafx.fxml.*;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Label;
import javafx.scene.control.PasswordField;
import javafx.scene.control.RadioButton;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.control.ToggleGroup;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SplittableRandom;
import java.util.concurrent.TimeUnit;

import com.sun.javafx.image.impl.ByteIndexed.Getter;

/**
 *
 * @author Lars Habier,Felix Tenbruck,Gerrit Schulz
 *
 * Folgende Anwendung dient dazu, eine bestimmte Datenmenge mit Hilfe eines Skalierungsfaktor n in eine Datenbank einzufügen und die Dauer dieses
 * einfügens zu messen. Dabei ist (unsere) effektivste Methode immer unter der Methode insertData() zu finden, und weniger effektiver Methoden sind
 * entweder auskommentiert, oder in ältern Revisionen zu finden.
 *
 */
public class GUI_Controller {

    // Deklarationen der Variablen die Methoden übergreifend sind
    protected Connection connection;
    protected String ip;
    protected String db;
    protected String user;
    protected String psw;
    protected int n;

    //Deklaration der Controll-Objekte für den SceneBuilder
    @FXML
    Label l_connectServer_title;
    @FXML
    Label l_connectServer_IP;
    @FXML
    Label l_connectServer_DB;
    @FXML
    Label l_connectServer_USER;
    @FXML
    Label l_connectServer_PSW;
    @FXML
    Label l_context_n;
    @FXML
    Label l_IP;
    @FXML
    Label l_DB;
    @FXML
    Label l_USER;
    @FXML
    Label l_PSW;

    @FXML
    CheckBox cb_autoclear;
    @FXML
    CheckBox cb_db_avail;
    @FXML
    CheckBox cb_show_psw;
    @FXML
    RadioButton r_lokal;
    @FXML
    RadioButton r_extern;

    @FXML
    ToggleGroup connectServer_toggleGroup_radio = new ToggleGroup();


    @FXML
    TextField tf_connectServer_IP;
    @FXML
    TextField tf_connectServer_DB;
    @FXML
    TextField tf_connectServer_USER;
    @FXML
    TextField tf_connectServer_PSW;
    @FXML
    TextField tf_get_n;

    @FXML
    PasswordField pf_connectServer_PSW;

    @FXML
    TextArea console;

    @FXML
    Button btn_connectServer_connect;
    @FXML
    Button btn_createDB;
    @FXML
    Button btn_createTables;
    @FXML
    Button btn_dropDB;
    @FXML
    Button btn_dropTables;
    @FXML
    Button btn_startInsert;
    @FXML
    Button btn_createLog;

    /**
     * Diese Methode dient dazu, bei einem Klick auf den Radiobutton "lokal" die Textfelder vorab schonmal mit Inhalt zu füllen
     */
    @FXML
    protected void connectServer_lokal_onclick() {
        tf_connectServer_IP.setText("localhost");
        tf_connectServer_DB.setText("");
        tf_connectServer_USER.setText("root");
        tf_connectServer_PSW.setText("");

    }

    /**
     * Diese Methode leert die Textfelder, damit nun eigenständig Eingaben gemacht werden können
     */
    @FXML
    protected void connectServer_extern_onclick() {
        tf_connectServer_IP.setText("");
        tf_connectServer_DB.setText("");
        tf_connectServer_USER.setText("");
        tf_connectServer_PSW.setText("");
    }
    /**
     * Diese Methode aktiviert das TextFeld tf_connectServer_DB, wenn ein Haken reingesetzt wird
     */
    @FXML
    protected void connectServer_db_available_onclick() {
        if(tf_connectServer_DB.isDisabled()) {
            tf_connectServer_DB.setDisable(false);
            tf_connectServer_DB.setText("benchmark_db");
        }
        else {
            tf_connectServer_DB.setDisable(true);
            tf_connectServer_DB.setText("");
        }
    }

    /**
     * Diese Methode dient dazu, die Objekte nach dem erfolgreichen anmelden anzuzeigen
     */
    @FXML
    protected void show_connected_Controlls() {
        l_IP.setVisible(true);
        l_IP.setText("IP-Adresse: "+getIp());
        l_DB.setVisible(true);
        if(getDb().isEmpty()) {
            l_DB.setText("Datenbank: keine vorhanden");
        }
        else {
        l_DB.setText("Datenbank: "+getDb());
        }
        l_USER.setVisible(true);
        l_USER.setText("Benutzer: "+getUser());
        String encrypted_psw = "";
        int length = getPsw().length();
        if(length == 0) {
            encrypted_psw = "-";
        }else {

        for(int i = 1;i<=length;i++) {
            encrypted_psw = encrypted_psw+"*";
        }
        }
        l_PSW.setVisible(true);
        l_PSW.setText("Passwort: "+encrypted_psw);
        btn_createDB.setVisible(true);
        btn_createTables.setVisible(true);
        btn_dropDB.setVisible(true);
        btn_dropTables.setVisible(true);
        btn_startInsert.setVisible(true);
        l_context_n.setVisible(true);
        tf_get_n.setVisible(true);
        console.setVisible(true);
        cb_autoclear.setVisible(true);
        btn_createLog.setVisible(true);
    }

    /**
     * Diese Methode dient dazu, alle Objekte, die beim Start im Verbindungsfenster zu sehen sind, unsichtbar zu machen, so dass die neuen Objekte
     * im Vordergrund stehen
     */
    @FXML
    protected void hide_connectServer_Controlls() {
        l_connectServer_IP.setVisible(false);
        l_connectServer_DB.setVisible(false);
        l_connectServer_USER.setVisible(false);
        l_connectServer_PSW.setVisible(false);
        l_connectServer_title.setVisible(false);
        tf_connectServer_IP.setVisible(false);
        tf_connectServer_DB.setVisible(false);
        tf_connectServer_USER.setVisible(false);
        tf_connectServer_PSW.setVisible(false);
        r_lokal.setVisible(false);
        r_extern.setVisible(false);
        btn_connectServer_connect.setVisible(false);
        cb_db_avail.setVisible(false);
        cb_show_psw.setVisible(false);
        pf_connectServer_PSW.setVisible(false);
    }


    /**
     * Diese Methode dient dazu, eine Verbindung zu einem Datenbankserver herzustellen und diese global zu speichern, oder beim einem Fehlschlag den
     * Benutzer darüber zu informieren.
     */
    @FXML protected void connectServer_connect() {
        connection = null;
         ip = tf_connectServer_IP.getText();
         db = tf_connectServer_DB.getText();
         user = tf_connectServer_USER.getText();
         if(pf_connectServer_PSW.getText().isEmpty()) {
         psw = tf_connectServer_PSW.getText();
         }
         else {
             psw = pf_connectServer_PSW.getText();
         }
        try {
            if(cb_db_avail.isSelected()) {
            String url = "jdbc:mysql://"+ip+"/"+db+"?useUnicode=true&characterEncoding=UTF-8" +
                   "&rewriteBatchedStatements=true&useSSL=false";
            connection = DriverManager.getConnection(url, user, psw);
            setConnection(connection);
            setIp(ip);
            setDb(db);
            setUser(user);
            setPsw(psw);
            hide_connectServer_Controlls();
            show_connected_Controlls();
            }
            else {
                String url = "jdbc:mysql://"+ip+"/"+"?useUnicode=true&characterEncoding=UTF-8" +
                        "&rewriteBatchedStatements=true&useSSL=false";
                connection = DriverManager.getConnection(url, user, psw);
                setConnection(connection);
                setIp(ip);
                setUser(user);
                setPsw(psw);
                hide_connectServer_Controlls();
                show_connected_Controlls();
            }


        }
        catch(Exception e) {
            e.printStackTrace();
            Alert alert = new Alert(AlertType.ERROR);
            alert.setHeaderText(null);
            alert.setTitle("Verbindung konnte nicht hergestellt werden.");
            alert.setContentText("Die Verbindung zum Datenbankserver konnte nicht hergestellt werden. Bitte überprüfen Sie ihre Eingaben.");
            alert.showAndWait();
        }
    }

    /**
     * Diese Methode dient dazu, dem Benutzer Applikationsnah Veränderungen an dem Datenbankserver vornehmen lassen zu können, wie zum Beispiel das Löschen
     * der Datenbank, mit der man gerade verbunden ist.
     */
    @FXML protected void dropDB() {
        resetConnection();
        try {

            Statement stmt = connection.createStatement();
            String sql = "DROP DATABASE "+getDb();
            stmt.executeUpdate(sql);
            writeIntoConsole("Die Datenbank "+getDb()+" wurde erfolgreich gelöscht.");
            l_DB.setText("Datenbank: keine vorhanden ");
            setDb("");
        } catch (SQLException e) {
            writeIntoConsole("Löschen der Datenbank ist fehlgeschlagen! Überprüfen Sie, ob diese existiert!");
            e.printStackTrace();
        }

    }
    /**
     * Diese Methode dient dazu, dem Benutzer Applikationsnah Veränderungen an dem Datenbankserver vornehmen lassen zu können, wie zum Beispiel das Löschen der
     * Tabellen branches,accounts,tellers,history.
     *
     */
    @FXML protected void dropTables() throws SQLException {
        Statement stmt;
        Connection conn = getConnection();
        try {
            conn.setAutoCommit(false);
            stmt = connection.createStatement();
            String sql="SET FOREIGN_KEY_CHECKS=0;";
            stmt.executeUpdate(sql);
            sql = "DROP TABLE branches;";
            stmt.executeUpdate(sql);
            sql = "DROP TABLE accounts;";
            stmt.executeUpdate(sql);
            sql = "DROP TABLE tellers;";
            stmt.executeUpdate(sql);
            sql = "DROP TABLE history;";
            stmt.executeUpdate(sql);
            sql = "SET FOREIGN_KEY_CHECKS=1;";
            stmt.executeUpdate(sql);
            conn.commit();
            writeIntoConsole("Die Tabellen branches,accounts,tellers und history wurden erfolgreich gelöscht.");
        }
         catch (SQLException e) {
            writeIntoConsole("Die Tabellen konnten nicht gelöscht werden!");
            e.printStackTrace();
            conn.rollback();
         }
        }
    /**
     * Diese Methode dient dazu, dem Benutzer Applikationsnah Veränderungen an dem Datenbankserver vornehmen lassen zu können, wie zum Beispiel das Erstellen einer Datenbank
     * benchmark_db.
     */
    @FXML protected void createDB() {
        try {
            Statement stmt = connection.createStatement();
            String sql = "CREATE DATABASE benchmark_db";
            stmt.executeUpdate(sql);
            writeIntoConsole("Die Datenbank benchmark_db wurde erfolgreich erstellt.");
            l_DB.setText("Datenbank: benchmark_db");
            setDb("benchmark_db");
        }
        catch(SQLException e) {
            writeIntoConsole("Beim erstellen der Datenbank ist ein Fehler aufgetreten. Überprüfen Sie ob eine Datenbank benchmark_db schon existiert.");
            e.printStackTrace();
        }
    }
    /**
     * Diese Methode dient dazu, dem Benutzer Applikationsnah Veränderungen an dem Datenbankserver vornehmen lassen zu können, wie zum Beispiel das Erstellen der Tabellen
     * branches,accounts,tellers,history.
     */
    @FXML protected void createTables() throws SQLException {
        resetConnection();
        Statement stmt;
        Connection conn = connection;
        try {
            conn.setAutoCommit(false);
            stmt = conn.createStatement();
            String query = "create table branches\r\n" +
                    "( branchid int not null,\r\n" +
                    " branchname char(20) not null,\r\n" +
                    " balance int not null,\r\n" +
                    " address char(72) not null,\r\n" +
                    " primary key (branchid) );";

                   stmt.executeUpdate(query);
                   query = "create table accounts\r\n" +
                        "( accid int not null,\r\n" +
                        " name char(20) not null,\r\n" +
                        " balance int not null,\r\n" +
                        "branchid int not null,\r\n" +
                        "address char(68) not null,\r\n" +
                        "primary key (accid),\r\n" +
                        "foreign key (branchid) references branches (branchid))";
                   stmt.executeUpdate(query);
                   query = "create table tellers\r\n" +
                        "( tellerid int not null,\r\n" +
                        " tellername char(20) not null,\r\n" +
                        " balance int not null,\r\n" +
                        " branchid int not null,\r\n" +
                        " address char(68) not null,\r\n" +
                        " primary key (tellerid),\r\n" +
                        " foreign key (branchid) references branches (branchid))";
                   stmt.executeUpdate(query);
                   query = "create table history\r\n" +
                        "( accid int not null,\r\n" +
                        " tellerid int not null,\r\n" +
                        " delta int not null,\r\n" +
                        " branchid int not null,\r\n" +
                        " accbalance int not null,\r\n" +
                        " cmmnt char(30) not null,\r\n" +
                        " foreign key (accid) references accounts (accid),\r\n" +
                        " foreign key (tellerid) references tellers (tellerid),\r\n" +
                        " foreign key (branchid) references branches(branchid)) ";
                   stmt.executeUpdate(query);
            conn.commit();
            writeIntoConsole("Die Tabellen branches,accounts,tellers und history wurden erfolgreich erstellt.");
        }
         catch (SQLException e) {
            writeIntoConsole("Die Tabellen konnten auf Grund eines Fehlers nicht erstellt werden. Überprüfen Sie ob diese nicht schon existieren.");
            e.printStackTrace();
            conn.rollback();
         }
        }
    /**
     * Diese Methode entspricht dem Herz des Programms, denn diese dient dazu die Tabellen mit Daten nach Vorgabe der Aufgabe zu füllen.
     * @throws SQLException
     */
    @FXML protected void insertData() throws SQLException {
        if(tf_get_n.getText().isEmpty()) {
            Alert alert = new Alert(AlertType.ERROR);
            alert.setHeaderText(null);
            alert.setTitle("Geben Sie einen Skalierungsfaktor n an.");
            alert.setContentText("Sie haben keinen Skalierungsfaktor n angegeben! Die Tabellen werden mit Hilfe von einem Skalierungsfaktor n erstellt. Dieser wird benötigt um eine Messung starten zu können.");
            alert.showAndWait();
        }
        else {
            int n = Integer.parseInt(tf_get_n.getText());
            resetConnection();
            Connection conn = getConnection();
            conn.setAutoCommit(false);
            writeIntoConsole("---------------------------------------------------------------------------------------------------------------");
            try {
                final long timeStart = System.currentTimeMillis();
                executeSQL_fillBranches(conn, n);
                executeSQL_fillAccounts(conn, n);
                executeSQL_fillTellers(conn, n);
                conn.commit();
                final long timeEnd = System.currentTimeMillis();
                final long timeMillis = timeEnd - timeStart;
                long timeSeconds = TimeUnit.MILLISECONDS.toSeconds(timeMillis);
                long timeMinutes = TimeUnit.MILLISECONDS.toMinutes(timeMillis);
                writeIntoConsole("Alle Tabellen wurde mit dem Faktor n = "+n+" erstellt und dies hat "+timeMillis+" Millisekunden, "+timeSeconds+" Sekunden bzw. "+timeMinutes+":"+(timeSeconds%60)+" Minuten gedauert.");
                long tps = n + n*100000 + n*10;
                long averageTPS = tps/timeSeconds;
                writeIntoConsole("Es wurden insgesamt "+tps+" Transaktionen durchgeführt und es wurden durchschnittlich "+averageTPS+" Transaktionen pro Sekunde erreicht.");
                if(cb_autoclear.isSelected()) {
                clearTables();
                }



            } catch (SQLException e) {
                conn.rollback();
                writeIntoConsole("Das füllen der Tabellen mit Daten ist fehlgeschlagen!");
                e.printStackTrace();
            }

        }
    }


    /**
     * Diese Methode füllt die Tabelle Branches mit n beliebigen Tupeln
     * @param n - Parameter für die Anzahl mit der multipliziert werden soll
     * @throws SQLException
     */

    protected static void executeSQL_fillBranches(Connection conn, int n) throws SQLException {
        Connection connection = conn;
        try{


        conn.setAutoCommit(false);
        String query = "Insert INTO branches(branchid,branchname,address,balance) VALUES(?,?,?,?)";
        PreparedStatement ps = conn.prepareStatement(query);
        for(int i = 1; i<=n;i++) {
            ps.setInt(1, i);
            ps.setString(2,"abcdefghijklmnopqrst");
            ps.setString(3, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrst");
            ps.setInt(4, 0);
            ps.addBatch();

        }
        ps.executeBatch();
        conn.commit();
        }
        catch(Exception e){
            connection.rollback();
            System.out.println("Es ist ein Fehler beim füllen der Tabelle Branches aufgetreten.");
            e.printStackTrace();
        }

    }
    /**
     * Diese Methode füllt die Tabelle Accounts mit n beliebigen Tupeln
     * @param conn - Hier wird die Datenbankverbindung übergeben
     * @param n - Parameter für die Anzahl, mit der multipliziert werden soll
     * @throws SQLException
     */

    protected static void executeSQL_fillAccounts(Connection conn, int n) throws SQLException{
        Connection connection = conn;
        SplittableRandom random = new SplittableRandom();
        int count = 0;
        final int batchSize = 10000;
        //final int transactionSize = 100000;
        int zufallsID = 0;
        try{
        conn.setAutoCommit(false);
        String query = "INSERT INTO accounts(accid,name,balance,branchid,address) VALUES(?,?,?,?,?)";
        PreparedStatement ps = conn.prepareStatement(query);
        for(int i = 1;i<=n*100000;i++){
             zufallsID = random.nextInt(0,n)+1;
             ps.setInt(1, i);
             ps.setString(2, "abcdefghijklmnopqrst");
             ps.setInt(3, 0);
             ps.setInt(4, zufallsID);
             ps.setString(5,"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnop");
             ps.addBatch();
             ps.clearParameters();


             // erreicht der Batch eine Größe von 10000 wird diese ausgeführt
             if(i%batchSize == 0) {
                 ps.executeBatch();
                 ps.clearBatch();
             }

             /*
             // diese IF-Bedingung sorgt dafür, dass nicht eine große Transaktion mit mehreren Millionen inserts durchgeführt wird, sondern jede transaktion 100.000 inserts beinhaltet
             if(++count % transactionSize == 0 ) {
                 conn.commit();
             }
             */

        }

        ps.executeBatch();
        conn.commit();
        }
        catch(Exception e){
            connection.rollback();
            System.out.println("Es ist ein Fehler beim füllen der Tabelle Accounts aufgetreten.");
            e.printStackTrace();
        }

    }
    /**
     * Diese Methode füllt die Tabelle Tellers mit n beliebigen Tupeln
     * @param conn - Hier wird die Datenbankverbindung übergeben
     * @param n - Parameter für die Anzahl, mit der multipliziert werden soll
     * @throws SQLException
     */
    protected static void executeSQL_fillTellers(Connection conn, int n) throws SQLException{
        Connection connection = conn;
        SplittableRandom random = new SplittableRandom();
        int zufallsID = 0;
        try{
        conn.setAutoCommit(false);
        String query = "INSERT INTO tellers(tellerid,tellername,balance,branchid,address) VALUES(?,?,?,?,?)";
        PreparedStatement ps = conn.prepareStatement(query);
        for(int i = 1;i<=n*10;i++){
            zufallsID = random.nextInt(0,n)+1;
            ps.setInt(1, i);
            ps.setString(2,"abcdefghijklmnopqrst");
            ps.setInt(3, 0);
            ps.setInt(4, zufallsID);
            ps.setString(5, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnop");

             ps.addBatch();
        }
        ps.executeBatch();
        conn.commit();
        }
        catch(Exception e){
            connection.rollback();
            System.out.println("Es ist ein Fehler beim füllen der Tabelle Tellers aufgetreten.");
            e.printStackTrace();
        }
    }

    /**
     * Diese Methode dient dazu, alle Tabellen nach einem Aufruf von insertData() automatisch zu löschen, vorrausgesetzt der Haken bei
     * der CheckBox ist aktiv.
     * @throws SQLException
     */
    protected void clearTables() throws SQLException {
        resetConnection();
        Connection conn = getConnection();
        try {
            conn.setAutoCommit(false);
            Statement stmt = conn.createStatement();

            String sql = "SET FOREIGN_KEY_CHECKS=0;";
            stmt.addBatch(sql);
            stmt.executeBatch();
            sql = "DELETE FROM branches";
            stmt.addBatch(sql);
            sql = "DELETE FROM accounts";
            stmt.addBatch(sql);
            sql = "DELETE FROM tellers";
            stmt.addBatch(sql);
            sql = "DELETE FROM history";
            stmt.addBatch(sql);
            stmt.executeBatch();
            sql = "SET FOREIGN_KEY_CHECKS=1;";
            stmt.addBatch(sql);
            stmt.executeBatch();
            conn.commit();
            writeIntoConsole("Die Tabellen wurden automatisch geleert.");
        } catch (SQLException e) {
            writeIntoConsole("Die Tabellen konnten nicht geleert werden.");
            conn.rollback();
            e.printStackTrace();
        }


    }

    /**
     * Diese Methode dient dazu, eine Verbindung zu erneuern, falls der Benutzer während der Sitzung Tabellen/Datenbanken gelöscht/erstellt hat.
     */
    private void resetConnection()  {
        String url = "jdbc:mysql://"+getIp()+"/"+getDb()+"?useUnicode=true&characterEncoding=UTF-8" +
               "&rewriteBatchedStatements=true&useSSL=false";
        try {
            connection = DriverManager.getConnection(url, user, psw);
        } catch (SQLException e) {
            Alert alert = new Alert(AlertType.ERROR);
            alert.setHeaderText(null);
            alert.setTitle("Verbindung konnte nicht resetet werden.");
            alert.setContentText("Die Verbindung zum Datenbankserver konnte nicht erneuert werden. Das Programm wird nun beendet.");
            alert.showAndWait();
            e.printStackTrace();
            System.exit(1);
        }
        setConnection(connection);
    }

    /**
     * Diese Methode entspricht einem Logger, der universal alle Nachrichten in der TextArea console einfügt.
     * @param message - In diesem Parameter muss die Nachricht angegeben werden, die in der Konsole erscheinen soll.
     */
    private void writeIntoConsole(String message) {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String uhrzeit = sdf.format(new Date());
        console.appendText(uhrzeit+" - "+message+"\n");
    }

    /**
     * Diese Method dient dazu, bei Bedarf nach mehreren Messungen eine .txt Datei zu erstellen, in der alle Messungen festgehalten werden.
     * @throws IOException
     */
    @FXML
    private void createLog() throws IOException {
        FileWriter fw = null;
        BufferedWriter bw = null;
        String[] console_lines = console.getText().split("\n");
        SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy-HH-mm");
        String date = sdf.format(new Date());
        String path = "/Users/"+System.getProperty("user.name")+"/Desktop/";
        String dirname = "Benchmark_logs";
        String fileName = "dbi_"+date+".txt";
        File file= new File(path + dirname +"/"+fileName);
        File dir = new File(path + dirname);

        if(dir.exists()) {
            try {
                file.createNewFile();
                fw = new FileWriter(file);
                bw = new BufferedWriter(fw);
                for(int i = 1;i<console_lines.length;i++) {
                    bw.write(console_lines[i]);
                    bw.write(System.getProperty("line.separator"));
                }
                writeIntoConsole("Es wurde ein .txt erstellt unter "+path+" mit dem Namen "+fileName);
            } catch (IOException e) {
                Alert alert = new Alert(AlertType.ERROR);
                alert.setHeaderText(null);
                alert.setTitle("Log.txt konnte nicht erstellt werden.");
                alert.setContentText("Das Erstellen der log.txt ist fehlgeschlagen.");
                alert.showAndWait();
                e.printStackTrace();
            }
        }
        else {
            dir.mkdir();
            try {
                file.createNewFile();
                fw = new FileWriter(file);
                bw = new BufferedWriter(fw);
                for(int i = 1;i<console_lines.length;i++) {
                    bw.write(console_lines[i]);
                    bw.write(System.getProperty("line.separator"));
                }
                writeIntoConsole("Es wurde ein .txt erstellt unter "+path+" mit dem Namen "+fileName);
            } catch (IOException e) {
                Alert alert = new Alert(AlertType.ERROR);
                alert.setHeaderText(null);
                alert.setTitle("Log.txt konnte nicht erstellt werden.");
                alert.setContentText("Das Erstellen der log.txt ist fehlgeschlagen.");
                alert.showAndWait();
                e.printStackTrace();
            }

        }

        bw.close();


    }
    /**
     * Diese Methode lässt beim anklicken das Passwort anzeigen
     */
    @FXML
    protected void show_password() {
        if(cb_show_psw.isSelected()) {
            String psw = pf_connectServer_PSW.getText();
            pf_connectServer_PSW.setVisible(false);
            tf_connectServer_PSW.setVisible(true);
            tf_connectServer_PSW.setText(psw);
        }
        else {
            String psw = tf_connectServer_PSW.getText();
            pf_connectServer_PSW.setVisible(true);
            tf_connectServer_PSW.setVisible(false);
            pf_connectServer_PSW.setText(psw);
        }
    }


    // Übliche Getter und Setter

    public Connection getConnection() {
        return connection;
    }
    public void setConnection(Connection connection) {
        this.connection = connection;
    }
    public String getDb() {
        return db;
    }
    public void setDb(String db) {
        this.db = db;
    }
    public String getUser() {
        return user;
    }
    public void setUser(String user) {
        this.user = user;
    }
    public String getPsw() {
        return psw;
    }
    public void setPsw(String psw) {
        this.psw = psw;
    }
    public String getIp() {
        return ip;
    }
    public void setIp(String ip) {
        this.ip = ip;
    }
    public int getN() {
        return n;
    }
    public void setN(int n) {
        this.n = n;
    }


}