IDEA-vollständiger Code zum Herstellen einer Verbindung mit einer MySQL-Datenbank und Durchführen von Abfragevorgängen

Paket com.wretchant.fredis.menu.mysql;

importiere com.intellij.notification.NotificationType;
importiere com.intellij.openapi.actionSystem.AnAction;
importiere com.intellij.openapi.actionSystem.AnActionEvent;
importiere com.wretchant.fredis.gui.dialog.TableDialog;
importiere com.wretchant.fredis.util.NotifyUtils;
importiere com.wretchant.fredis.util.PropertiesUtils;
importiere org.jetbrains.annotations.NotNull;

importiere javax.swing.*;
importiere java.util.Map;
importiere java.util.Properties;

/**
 * @author Erstellt von Tan Jian am 26.08.2020. Mittwoch. 15:24.
 * © Alle Rechte vorbehalten.
 */
öffentliche Klasse MysqlConfig erweitert AnAction {

    @Überschreiben
    öffentliche void actionPerformed(@NotNull AnActionEvent event) {

        Eigenschafteneigenschaften = PropertiesUtils.readFromSystem();
        if (Eigenschaften != null) {
            TableDialog.TableField erstellen = TableDialog.TableField.build(properties.stringPropertyNames());
            TableDialog-Dialog = neuer TableDialog("Mysql-Verbindungskonfiguration", Build);
            für (int i = 0; i < dialog.getLabels().size(); i++) {
                JLabel-Beschriftung = dialog.getLabels().get(i);
                JTextField textField = dialog.getInputs().get(i);
                Zeichenfolgeneigenschaft = Eigenschaften.getProperty(label.getText());
                textField.setText(Eigenschaft);
            }
            dialog.anzeigen();
            wenn (dialog.istOK()) {
                Map<String, String> valueMap = dialog.getValueMap();
                valueMap.fürEach(Eigenschaften::festlegen der Eigenschaft);
                PropertiesUtils.write2System(Eigenschaften);
            }
        } anders {
            NotifyUtils.notifyUser(event.getProject(), "Konfigurationsdatei konnte nicht gelesen werden, Konfigurationsdatei existiert nicht", NotificationType.ERROR);
        }
    }

} 

Paket com.wretchant.fredis.support;

importiere cn.hutool.core.util.StrUtil;
importiere com.intellij.notification.NotificationType;
importiere com.intellij.openapi.actionSystem.AnActionEvent;
importiere com.intellij.openapi.actionSystem.PlatformDataKeys;
importiere com.intellij.openapi.editor.SelectionModel;
importiere com.wretchant.fredis.util.ClipboardUtils;
importiere com.wretchant.fredis.util.NotifyUtils;
importiere com.wretchant.fredis.util.PropertiesUtils;
importiere com.wretchant.fredis.value.StringValue;
importiere org.apache.commons.lang.StringUtils;
importiere org.jetbrains.annotations.NotNull;

importiere java.sql.*;
importiere java.util.*;

/**
 * @author Erstellt von Tan Jian am 12.08.2020. Mittwoch. 17:42.
 * © Alle Rechte vorbehalten.
 */
öffentliche Klasse Mysql {


    /**
     * Führen Sie die Abfrageanweisung aus, um das Ergebnis zurückzugeben */
    öffentliche statische Klasse Rs {

        öffentliche Rs(Liste<Map<String, Objekt>> r) {
            dies.r = r;
            dies.Anzahl = r.Größe();
        }

        private Liste<Map<String, Objekt>> r = neue ArrayList<>();

        private int-Anzahl;

        öffentliche Liste<Map<String, Objekt>> getR() {
            Rückkehr r;
        }

        public void setR(Liste<Map<Zeichenfolge, Objekt>> r) {
            dies.r = r;
        }

        öffentliche int getCount() {
            Anzahl zurückgeben;
        }

        öffentliche void setCount(int Anzahl) {
            dies.Anzahl = Anzahl;
        }

        öffentliche Map<String, Objekt> eins() {
            wenn (Objects.isNull(r) || r.isEmpty()) {
                gibt null zurück;
            }
            r.get(0) zurückgeben;
        }


        öffentliches Objekt oneGet(String key) {
            gib eins zurück().get(Schlüssel);
        }
    }


    // Referenz: https://www.cnblogs.com/jyroy/p/9637149.html

    öffentliche statische Klasse JDBCUtil {


        /**
         * SQL ausführen und Kartendaten zurückgeben *
         * @param sql
         * @zurückkehren
         */
        öffentliche statische Rs rs(String sql) {
            Verbindung Verbindung = null;
            Anweisung Anweisung = null;
            Ergebnismenge Ergebnismenge = null;
            Liste<Map<String, Objekt>> r = neue ArrayList<>();
            versuchen {
                Verbindung = Mysql.DatabaseUtils.getConnection();
                Anweisung = Verbindung.createStatement();
                Ergebnismenge = Anweisung.executeQuery(sql);

                // Grundlegende Informationen ResultSetMetaData metaData = resultSet.getMetaData();
                // Wie viele Felder werden zurückgegeben int columnCount = metaData.getColumnCount();


                während (resultSet.next()) {
                    Map<String, Objekt> valueMap = neue LinkedHashMap<>();
                    für (int i = 0; i < Spaltenanzahl; i++) {
                        // Welcher Datentyp ist dieses Feld? String columnClassName = metaData.getColumnClassName(i);
                        //Feldname String columnName = metaData.getColumnName(i);
                        Objektwert = resultSet.getObject(Spaltenname);
                        valueMap.put(Spaltenname, Wert);
                    }
                    r.add(Wertezuordnung);
                }
            } Fang (Ausnahme e1) {
                NotifyUtils.notifyUser(null, "Fehler", Benachrichtigungstyp.ERROR);
                e1.printStackTrace();
            Endlich
                Release (Verbindung, Anweisung, Ergebnismenge);
            }
            gib neue Rs(r) zurück;
        }

        öffentliches statisches ResultSet es(String sql) {
            Verbindungsverbindung;
            Aussage Aussage;
            Ergebnismenge Ergebnismenge = null;
            versuchen {
                Verbindung = Mysql.DatabaseUtils.getConnection();
                Anweisung = Verbindung.createStatement();
                Ergebnismenge = Anweisung.executeQuery(sql);
            } Fang (Ausnahme e1) {
                NotifyUtils.notifyUser(null, "Fehler", Benachrichtigungstyp.ERROR);
                e1.printStackTrace();
            }
            Ergebnismenge zurückgeben;
        }


        öffentliche statische void release(Verbindung Verbindung, Anweisung st, Ergebnismenge rs) {
            closeConn(Verbindung);
            schließenRs(rs);
            schließenSt(st);
        }

        öffentliche statische Leere closeRs (ResultSet rs) {
            versuchen {
                wenn (rs != null) {
                    rs.schließen();
                }
            } Fang (SQLException e) {
                e.printStackTrace();
            Endlich
                rs = null;
            }
        }

        private static void closeSt(Anweisung st) {
            versuchen {
                wenn (st != null) {
                    st.schließen();
                }
            } Fang (SQLException e) {
                e.printStackTrace();
            Endlich
                st = null;
            }
        }

        private static void closeConn(Verbindung Verbindung) {
            versuchen {
                wenn (Verbindung != null) {
                    Verbindung.schließen();
                }
            } Fang (SQLException e) {
                e.printStackTrace();
            Endlich
                Verbindung = null;
            }
        }

    }

    öffentliche statische Klasse DatabaseUtils {
        private statische Verbindung Verbindung = null;

        statisch {
            Eigenschafteneigenschaften = PropertiesUtils.readFromSystem();
            versuchen {
                if (Eigenschaften != null) {
                    Klasse.fürName("com.mysql.cj.jdbc.Driver");
                    Verbindung = DriverManager.getConnection(
                            Eigenschaften.getProperty("mysql.url"),
                            Eigenschaften.getProperty("mysql.username"),
                            Eigenschaften.getProperty("mysql.password")
                    );
                    NotifyUtils.notifyUser(null, "Datenbankverbindung erfolgreich", NotificationType.INFORMATION);
                }
            } Fang (Ausnahme e) {
                NotifyUtils.notifyUser(null, "Datenbankverbindung fehlgeschlagen", NotificationType.ERROR);
                e.printStackTrace();
            }
        }

        öffentliche statische Verbindung getConnection() {
            Rückverbindung;
        }
    }


    öffentliche statische void exec(@NotNull AnActionEvent-Ereignis, Vorlage Vorlage) {
        StringValue stringValue = neuer StringValue(template.getDefaultValue());
        Optional.vonNullable(event.getData(PlatformDataKeys.EDITOR)).
                wennVorhanden(Editor -> {
                    Auswahlmodell Auswahlmodell = editor.getSelectionModel();
                    Zeichenfolge ausgewählter Text = Auswahlmodell.getSelectedText();
                    wenn (StringUtils.isNotBlank(selectedText)) {
                        stringValue.setValue(StrUtil.format(template.getDynamicValue(), selectedText));
                    }
                });
        : ClipboardUtils.clipboard(stringValue.getValue());
        BenachrichtigenUtils.notifyUser(event.getProject(), stringValue.getValue(), Benachrichtigungstyp.INFORMATION);
    }

    /**
     * SQL-Anweisungsvorlage */
    öffentliche Enumerationsvorlage {

        SELECT("SELECT * FROM x WHERE 1 = 1 AND ", "SELECT * FROM {} WHERE 1 = 1 AND ", "Abfrageanweisung"),
        UPDATE("UPDATE x SET x = x WHERE 1 = 1 AND ", "UPDATE {} SET x = x WHERE 1 = 1 AND ", "Update-Anweisung"),
        LÖSCHEN("LÖSCHEN VON x, WO 1 = 1 ", "LÖSCHEN VON {}, WO 1 = 1 ", "Löschanweisung"),
        INSERT("INSERT INTO * (x) VALUES (x) ", "INSERT INTO {} (x) VALUES (x) ", "Neue Anweisung"),
        ;

        Vorlage(String Standardwert, String dynamischer Wert, String beschreiben) {
            this.defaultValue = Standardwert;
            this.dynamicValue = dynamischerWert;
            this.describe = beschreiben;
        }

        öffentliche Zeichenfolge getDynamicValue() {
            gibt dynamischen Wert zurück;
        }

        öffentliche Zeichenfolge getDefaultValue() {
            Standardwert zurückgeben;
        }

        öffentliche Zeichenfolge getDescribe() {
            zurückgeben, beschreiben;
        }

        /**
         *Vorlageninhalt: Standardwert*/
        privater endgültiger String Standardwert;
        /**
         * Dynamischer Inhalt */
        privater endgültiger String dynamischer Wert;
        /**
         * Beschreibung */
        private endgültige String-Beschreibung;


    }

}

Paket com.wretchant.fredis.menu.mysql;

importiere com.intellij.notification.NotificationType;
importiere com.intellij.openapi.actionSystem.AnAction;
importiere com.intellij.openapi.actionSystem.AnActionEvent;
importiere com.wretchant.fredis.support.Mysql;
importiere com.wretchant.fredis.util.NotifyUtils;
importiere org.jetbrains.annotations.NotNull;

importiere java.sql.ResultSet;

/**
 * @author Erstellt von Tan Jian am 15.09.2020. Dienstag. 10:17.
 * © Alle Rechte vorbehalten.
 */
öffentliche Klasse MysqlConn erweitert AnAction {


    @Überschreiben
    öffentliche void actionPerformed(@NotNull AnActionEvent event) {
        versuchen {
            ResultSet es = Mysql.JDBCUtil.es("wähle 1 als ct aus");
            es.next();
            int ct = es.getInt("ct");
            wenn (ct == 1) {
                NotifyUtils.notifyUser(null, "Die Verbindung ist normal", NotificationType.INFORMATION);
            } anders {
                NotifyUtils.notifyUser(null, "Verbindung ist abnormal", NotificationType.ERROR);
            }
            Mysql.JDBCUtil.closeRs(es);
        } Fang (Ausnahme e1) {
            e1.printStackTrace();
            NotifyUtils.notifyUser(null, "Verbindung ist abnormal", NotificationType.ERROR);
        }
    }
}