Einzelne Zeile aus einer txt Datei in einem String speichern

[melaniemueller]

Hey zusammen,

ich hab eine txt Datei mit genau 2 Zeilen. In der ersten Zeile steht eine Emailadresse und in der 2. das dazugehörige Kennwort.
Diese bleiben gleich. Nun möchte ich Zeile 1 auslesen und die Emailadresse in einem String abspeichern und das selbige mit dem Kennwort.

Ich hab versucht:

FileReader fr = new FileReader("anmeldedaten.txt");
        BufferedReader br = new BufferedReader(fr);
        String zeileBenutzername = "";
        int i = 0;
        while ((zeileBenutzername = br.readLine()) != null) {
            i++;
            if (i == 1) {
                br.close();
                String benutzername = zeileBenutzername;
            }
        br.close();

Funktioniert überhaupt nicht. Wenn ich dann den String benutzername an anderer Stelle verwenden möchte kommt die Variable kann nicht aufgelöst werden. Hab hier im Forum schon rum gesucht und dadurch ist der Code oben entstanden. Wer kann helfen?

 

[Robert Zenz]

Du denkst da einfach zu kompliziert. Wenn du dich darauf verlassen kannst dass die Datei so aufgebaut ist, kannst du ja direkt in die Variablen lesen:

String benutzername = null;
String passwort = null;

// Irgendwann spaeter.

try (BuffeeredReader reader = new BufferedReader(new FileReader("anmeldedaten.txt") {
    benutzername = reader.readLine();
    passwort = reader.readLine();
}

Du musst natuerlich die Variablen dort deklarieren wo du sie brauchst, als Klassenvariablen oder so zum Beispiel.

 

[melaniemueller]

Du denkst da einfach zu kompliziert. Wenn du dich darauf verlassen kannst dass die Datei so aufgebaut ist, kannst du ja direkt in die Variablen lesen:

String benutzername = null;
String passwort = null;

// Irgendwann spaeter.

try (BuffeeredReader reader = new BufferedReader(new FileReader("anmeldedaten.txt") {
    benutzername = reader.readLine();
    passwort = reader.readLine();
}

Du musst natuerlich die Variablen dort deklarieren wo du sie brauchst, als Klassenvariablen oder so zum Beispiel.

Ok das ist echt um einiges unkomplizierter - danke! Habs soeben geändert und er zeigt mir schon mal keine Fehlermeldung mehr an. Werds nun mal noch komplett testen

 

[melaniemueller]

Irgendwas funktioniert nun leider doch nicht. Ich hab catch ergänzt und beim Ausführen bringt er mir in der Konsole genau den Text den ich dort angegeben hab, also scheitert es. Damit man besser versteht worums genau geht - es ist ein Emailprogramm und beim Nachrichten empfangen und beim Senden muss sich eingeloggt werden damit das ganze von der entsprechenden Email aus passiert.

Hier mal nun die Methode zum Nachrichten empfangen:

    private void nachrichtenAbholen() {
        
        try (BufferedReader reader = new BufferedReader(new FileReader("anmeldedaten.txt"))) {
            benutzername = reader.readLine();
            passwort = reader.readLine();
        }
        catch (IOException e) {
            System.out.println("Die Anmeldedaten konnten nicht gefunden werden");
        }

        //der Server
        String server = "pop.gmail.com";

        //die Eigenschaften setzen
        Properties eigenschaften = new Properties();
        //das Protokoll
        eigenschaften.put("mail.store.protocol", "pop3");
        //den Host
        eigenschaften.put("mail.pop3.host", server);
        //den Port zum Empfangen
        eigenschaften.put("mail.pop3.port", "995");
        //die Authentifizierung über TLS       
        eigenschaften.put("mail.pop3.starttls.enable", "true");
        //das Session-Objekt erstellen
        Session sitzung = Session.getDefaultInstance(eigenschaften);

        //das Store-Objekt über die Sitzung erzeugen
        try (Store store = sitzung.getStore("pop3s")){
            //und verbinden
            store.connect(server, benutzername, passwort);
            //ein Ordnerobjekt für den Posteingang erzeugen     
            Folder posteingang  = store.getFolder("INBOX");
            //und öffnen
            //dabei sind auch änderungen zugelassen
            posteingang.open(Folder.READ_WRITE);

            //die Nachrichten beschaffen
            Message nachrichten[] = posteingang.getMessages();

            //gibt es neue Nachrichten?
            if (nachrichten.length != 0) {
                //dann die Anzahl zeigen
                JOptionPane.showMessageDialog(this, "Es gibt "+ posteingang.getUnreadMessageCount() + " neue Nachrichten.");
                //jede Nachricht verarbeiten
                for(Message nachricht : nachrichten)
                    nachrichtVerarbeiten(nachricht);
            }               
            else
                JOptionPane.showMessageDialog(this, "Es gibt keine neue Nachrichten.");

            //den Ordner schließen
            //durch das Argument true werden die Nachrichten gelöscht
            posteingang.close(true);
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }

Ich hab oben nun den Part eingefügt zum speichern vom Benutzernamen und Passwort und weiter unten wird das ganze dann zum Verbinden verwendet. Nur anscheinend funktioniert das nicht. Die txt Datei hab ich im Paket erstellt.

 

[Robert Zenz]

System.out.println("Die Anmeldedaten konnten nicht gefunden werden");

Du solltest Ausnahmen und Fehler nicht so schlucken, so kommst du nie auf Fehler d'rauf und was los ist. Mindestens solltest du die Ausnahme immer mit ausgeben:

System.out.println("Die Anmeldedaten konnten nicht geladen werden: " + e);
// Oder einfach nur:
e.printStacktrace();

Die txt Datei hab ich im Paket erstellt.

Das ist wahrscheinlich falsch. FileReader wird die Datei im aktuellen Arbeitsverzeichnis suchen. Wenn du sie aus den Klassenpfad laden willst (sprich sie ist im jar eingebettet), dann musst du diese ueber den Klassenlader laden.

try (BufferedReader reader = new BufferedReader(new InputStreamReader(DeineKlasse.class.getResourceAsStream("/das/paket/in/dem/die/datei/liegt/anmeldedaten.txt")))) {

Ich vergesse aber immer ob man dabei den fuehrenden Schraegstrich am Pfad braucht oder nicht...


Als Anmerkung, wenn die Text-Datei nicht vorgegeben ist, wuerde ich auf eine Properties-Datei umsteigen. Die sieht dann so aus:

benutzername=bla@bla.com
passwort=geheim

Und wird dann gelesen mit:

Properties konfiguration = new Properties();

try (BufferedReader reader = new BufferedReader(new FileReader("anmeldedaten.txt"))) {
    konfiguration.load(reader);
}

// Verwendung
konfiguration.getProperty("benutzername");

Macht die Datei einfacher zu lesen und erlaubt es dir dann diese einfacher zu erweitern.

 

[M.L.]

Eigenrecherche "java read nth line file" (da aber nicht garantiert ist, die gewünschten Daten immer an genau den angegebenen Stellen anzutreffen, sind andere Ansätze langfristig wohl die flexiblere Lösung)

 

[yfons123]

du kannst in die property Datei ja auch den Email kram tun

 

[melaniemueller]

So konnte es heute nochmal ausprobieren.
Die txt. Datei ist leider notwendig. Alternative wäre nur über eine bereits vorhandene Datenbank aber ich empfand eine txt Datei als unkomplizierter.
Den fehlenden Pfad etc hab ich ergänzt, das scheint ein Fehler gewesen zu sein. Jedoch wenn ich nun empfangen klicke bekomme ich folgende Exception:

Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
    at java.base/java.io.Reader.<init>(Reader.java:167)
    at java.base/java.io.InputStreamReader.<init>(InputStreamReader.java:72)
    at de.fernschulen.minimail.Empfangen.nachrichtenAbholen(Empfangen.java:162)
    at de.fernschulen.minimail.Empfangen.nachrichtenEmpfangen(Empfangen.java:155)
    at de.fernschulen.minimail.Empfangen$MeinWindowAdapter.windowOpened(Empfangen.java:47)
    at java.desktop/java.awt.Window.processWindowEvent(Window.java:2072)
    at java.desktop/javax.swing.JFrame.processWindowEvent(JFrame.java:298)
    at java.desktop/java.awt.Window.processEvent(Window.java:2034)
    at java.desktop/java.awt.Component.dispatchEventImpl(Component.java:4990)
    at java.desktop/java.awt.Container.dispatchEventImpl(Container.java:2321)
    at java.desktop/java.awt.Window.dispatchEventImpl(Window.java:2769)
    at java.desktop/java.awt.Component.dispatchEvent(Component.java:4822)
    at java.desktop/java.awt.EventQueue.dispatchEventImpl(EventQueue.java:772)
    at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:721)
    at java.desktop/java.awt.EventQueue$4.run(EventQueue.java:715)
    at java.base/java.security.AccessController.doPrivileged(AccessController.java:391)
    at java.base/java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:85)
    at java.base/java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:95)
    at java.desktop/java.awt.EventQueue$5.run(EventQueue.java:745)
    at java.desktop/java.awt.EventQueue$5.run(EventQueue.java:743)
    at java.base/java.security.AccessController.doPrivileged(AccessController.java:391)
    at java.base/java.security.ProtectionDomain$JavaSecurityAccessImpl.doIntersectionPrivilege(ProtectionDomain.java:85)
    at java.desktop/java.awt.EventQueue.dispatchEvent(EventQueue.java:742)
    at java.desktop/java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:203)
    at java.desktop/java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:124)
    at java.desktop/java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:113)
    at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:109)
    at java.desktop/java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:101)
    at java.desktop/java.awt.EventDispatchThread.run(EventDispatchThread.java:90)

und meine geänderte Methode sieht nun so aus:

private Session verbindungHerstellen() {

          

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(Empfangen.class.getResourceAsStream("/MiniMailKomplett/src/de/fernschulen/minimail/anmeldedaten.txt")))) {

            benutzername = reader.readLine();

            passwort = reader.readLine();

        }

        catch (IOException e) {

            System.out.println("Die Anmeldedaten konnten nicht gefunden werden" + e);

        }

        //der Server

        String server = "smtp.gmail.com";



        //die Eigenschaften setzen

        Properties eigenschaften = new Properties();

        //die Authentifizierung über TLS

        eigenschaften.put("mail.smtp.auth", "true");

        eigenschaften.put("mail.smtp.starttls.enable", "true");

        //der Server

        eigenschaften.put("mail.smtp.host", server);

        //der Port zum Versenden

        eigenschaften.put("mail.smtp.port", "587");

  



        // das Session-Objekt erstellen

        Session sitzung = Session.getInstance(eigenschaften, new Authenticator() {

            protected PasswordAuthentication getPasswordAuthentication() {

                return new PasswordAuthentication(benutzername, passwort);

            }

        });

      

        return sitzung;

 

[Robert Zenz]

Nein, das ist der Pfad im Projekt (mit Projektnamen), aber du brauchst den Pfad anhand der Pakete, als "/de/fernschulen/minimail/anmeldedaten.txt".

 

[melaniemueller]

Nein, das ist der Pfad im Projekt (mit Projektnamen), aber du brauchst den Pfad anhand der Pakete, als "/de/fernschulen/minimail/anmeldedaten.txt".

Halleluja wie doof - DANKE! Es funktioniert 🤩

 

[melaniemueller]

Ich hätte noch eine weitere Frage zum Emailprogramm. Ich stell sie mal direkt hier
Als nächste Aufgabe soll die Funktion Weiterleiten und Antworten hinzugefügt werden. Sobald man auf das jeweilige Symbol klickt soll das Nachrichtenfenster öffnen und im Betreff AW z.B. stehen und im Text unten dann sowas wie "Text der ursprünglichen Nachricht" und der Text der Email. Nun hab ich bereits die Symbolleiste eingefügt mit Shortcuts etc bestückt und Methoden zum Antworten und Weiterleiten erstellt sowie Klassen dazu. Was nun nicht klappt ist, dass das AW etc angezeigt wird. Mir wird das gleiche Feld wie wenn ich eine neue Mail verschicke angezeigt also leer.

Hier meine Klasse Empfangen in welcher die Symbolleiste hinzugefügt wird und ich die Methoden erstellt habe und die Klassen zum Weiterleiten, Antworten aufrufen möchten:

package de.fernschulen.minimail;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Store;
import javax.swing.AbstractAction;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
import javax.swing.table.DefaultTableModel;

public class Empfangen extends JFrame {
    //automatisch über Eclipse ergänzt
    private static final long serialVersionUID = 2905894464790399040L;

    //für die Tabelle
    private JTable tabelle;
    //für das Modell
    private DefaultTableModel modell;
    // Aufgabe 1: Variablen für Benutzernamen und Passwort festlegen - vorerst mit dem Wert null, der Inhalt wird später in der Methode gesetzt
    private String benutzername = null;
    private String passwort = null;
    // Aufgabe 2: Aktionen zum Beantworten und Weiterleiten deklarieren
    private MeineAktionen beantwortenAct, weiterleitenAct;

    //eine innere Klasse für den WindowListener und den ActionListener
    //die Klasse ist von WindowAdapter abgeleitet
    class MeinWindowAdapter extends WindowAdapter{
        //für das Öffnen des Fensters
        @Override
        public void windowOpened(WindowEvent e) {
            //die Methode nachrichtenEmpfangen() aufrufen
            nachrichtenEmpfangen();
        }
    }
    
    // Aufgabe 2: eine innere Klasse für die Aktionen erstellen
    class MeineAktionen extends AbstractAction {
        private static final long serialVersionUID = -2679115823310162426L;
        public MeineAktionen(String text, ImageIcon icon, String beschreibung, KeyStroke shortcut, String actionText) {
            super (text, icon);
            putValue(SHORT_DESCRIPTION, beschreibung);
            putValue(ACCELERATOR_KEY, shortcut);
            putValue(ACTION_COMMAND_KEY, actionText);
        }
        @Override
        public void actionPerformed(ActionEvent e) {
            if(e.getActionCommand().equals("beantworten"))
                beantworten();
            if(e.getActionCommand().equals("weiterleiten"))
                weiterleiten();
            
        }
        
    }

    //der Konstruktor
    Empfangen() {
        super();

        setTitle("E-Mail empfangen");
        //wir nehmen ein Border-Layout
        setLayout(new BorderLayout());

        setVisible(true);
        setSize(700, 300);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        
        // Aufgabe 2: Aktionen erstellen
        beantwortenAct = new MeineAktionen("Beantworten", new ImageIcon("C:/Users/melli/Documents/ILS/Java17d/java17d_beispiele/icons/mail-reply.gif"), "Beantwortet diese E-Mail", null, "beantworten");
        weiterleitenAct = new MeineAktionen("Weiterleiten", new ImageIcon("C:/Users/melli/Documents/ILS/Java17d/java17d_beispiele/icons/mail-forward.gif"), "Leitet diese E-Mail weiter", null, "weiterleiten");
        
        //Aufgabe 2: Die Symbolleiste einfügen
        add(symbolleiste(), BorderLayout.NORTH);
        
        
        
        //den Listener verbinden
        addWindowListener(new MeinWindowAdapter());

        //die Tabelle erstellen und anzeigen
        tabelleErstellen();
        tabelleAktualisieren();
        
        
        
        
    }
    
    // Aufgabe 2: Erstellen der Methode beantworten()
        private void beantworten() {
            int zeile=tabelle.getSelectedRow();
                if (zeile > -1) {
                    String sender, betreff, inhalt, ID;
                    ID = tabelle.getModel().getValueAt(zeile, 0).toString();
                    sender = tabelle.getModel().getValueAt(zeile, 1).toString();
                    betreff = "AW: " + tabelle.getModel().getValueAt(zeile, 2).toString();
                    inhalt = "\n------------------Text der ursprünglichen Nachricht------------------\n" + tabelle.getModel().getValueAt(zeile, 3).toString();
                    new Antworten(Empfangen.this,true,ID,sender,betreff,inhalt);
                    tabelleAktualisieren();
                }
                else
                    JOptionPane.showMessageDialog(null, "Es wurde keine Zeile markiert");
                }
        // Aufgabe 2: Erstellen der Methode weiterleiten()
        private void weiterleiten() {
            int zeile=tabelle.getSelectedRow();
                if (zeile > -1) {
                    String empfaenger, betreff, inhalt, ID;
                    ID = tabelle.getModel().getValueAt(zeile, 0).toString();
                    empfaenger = null;
                    betreff = "WG: " + tabelle.getModel().getValueAt(zeile, 2).toString();
                    inhalt = "\n------------------Text der ursprünglichen Nachricht------------------\n" + tabelle.getModel().getValueAt(zeile, 3).toString();
                    new Weiterleitung(Empfangen.this,true,ID,empfaenger,betreff,inhalt);
                    tabelleAktualisieren();
                }
                else
                    JOptionPane.showMessageDialog(null, "Es wurde keine Zeile markiert");
                }
        

    //zum Erstellen der Tabelle
    private void tabelleErstellen() {
        //für die Spaltenbezeichner
        String[] spaltenNamen = {"ID", "Sender", "Betreff", "Text"};

        //ein neues Standardmodell erstellen
        modell = new DefaultTableModel();
        //die Spaltennamen setzen
        modell.setColumnIdentifiers(spaltenNamen);
        //die Tabelle erzeugen
        tabelle = new JTable();
        //und mit dem Modell verbinden
        tabelle.setModel(modell);
        //wir haben keinen Editor, können die Tabelle also nicht bearbeiten
        tabelle.setDefaultEditor(Object.class, null);
        //es sollen immer alle Spalten angepasst werden
        tabelle.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
        //und die volle Größe genutzt werden
        tabelle.setFillsViewportHeight(true);
        //die Tabelle setzen wir in ein Scrollpane
        JScrollPane scroll = new JScrollPane(tabelle);
        scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        add(scroll);

        //einen Maus-Listener ergänzen
        tabelle.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                //war es ein Doppelklick?
                if (e.getClickCount() == 2) {
                    //die Zeile beschaffen
                    int zeile = tabelle.getSelectedRow();
                    //die Daten beschaffen
                    String sender, betreff, inhalt, ID;
                    ID = tabelle.getModel().getValueAt(zeile, 0).toString();
                    sender = tabelle.getModel().getValueAt(zeile, 1).toString();
                    betreff = tabelle.getModel().getValueAt(zeile, 2).toString();
                    inhalt = tabelle.getModel().getValueAt(zeile, 3).toString();
                    //und anzeigen
                    //übergeben wird der Frame der äußeren Klasse
                    new Anzeige(Empfangen.this, true, ID, sender, betreff, inhalt);
                }
            }
        });
    }
    
    // Aufgabe 2: Die Symbolleiste über eine Methode erstellen
    
    private JToolBar symbolleiste() {
        JToolBar leiste = new JToolBar();
        // die Symbole über die ersrtellten Aktionen hinzufügen
        leiste.add(beantwortenAct);
        leiste.add(weiterleitenAct);
        // die Leiste zurückgeben
        return (leiste);
    }
    
    

    private void tabelleAktualisieren() {
        //für den Datenbankzugriff
        Connection verbindung;
        ResultSet ergebnisMenge;

        //für die Spalten
        String sender, betreff, inhalt, ID;
        //die Inhalte löschen
        modell.setRowCount(0);

        try{
            //Verbindung herstellen und Ergebnismenge beschaffen
            verbindung = MiniDBTools.oeffnenDB("jdbc:derby:mailDB");
            ergebnisMenge = MiniDBTools.liefereErgebnis(verbindung, "SELECT * FROM empfangen");
            //die Einträge in die Tabelle schreiben
            while (ergebnisMenge.next()) {
                ID = ergebnisMenge.getString("iNummer");
                sender = ergebnisMenge.getString("sender");
                betreff = ergebnisMenge.getString("betreff");
                //den Inhalt vom CLOB beschaffen und in einen String umbauen
                Clob clob;
                clob = ergebnisMenge.getClob("inhalt");
                inhalt = clob.getSubString(1, (int) clob.length());

                //die Zeile zum Modell hinzufügen
                //dazu benutzen wir ein Array vom Typ Object
                modell.addRow(new Object[] {ID, sender, betreff, inhalt} );
            }
            //die Verbindungen wieder schließen und trennen
            ergebnisMenge.close();
            verbindung.close();
            MiniDBTools.schliessenDB("jdbc:derby:mailDB");
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }

    private void nachrichtenEmpfangen() {
        nachrichtenAbholen();
        //nach dem Empfangen lassen wir die Anzeige aktualisieren
        tabelleAktualisieren();
    }

    private void nachrichtenAbholen() {
        // Aufgabe 1: Einen neuen BufferedReader erstellen und auf die angelegte txt. Datei "anmeldedaten.txt über das Paket zugreifen
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(Empfangen.class.getResourceAsStream("/de/fernschulen/minimail/anmeldedaten.txt")))) {
            // Aufgabe 1: in der ersten Zeile ist der Benutzername hinterlegt, somit wird nun die erste Zeile ausgelesen
            benutzername = reader.readLine();
            // Aufgabe 1: anschließend wird die nächste Zeile ausgelesen für das dazugehörige Passwort
            passwort = reader.readLine();
        }
        catch (IOException e) {
            System.out.println("Die Anmeldedaten konnten nicht gefunden werden" + e);
        }

        //der Server
        String server = "pop.gmail.com";

        //die Eigenschaften setzen
        Properties eigenschaften = new Properties();
        //das Protokoll
        eigenschaften.put("mail.store.protocol", "pop3");
        //den Host
        eigenschaften.put("mail.pop3.host", server);
        //den Port zum Empfangen
        eigenschaften.put("mail.pop3.port", "995");
        //die Authentifizierung über TLS       
        eigenschaften.put("mail.pop3.starttls.enable", "true");
        //das Session-Objekt erstellen
        Session sitzung = Session.getDefaultInstance(eigenschaften);

        //das Store-Objekt über die Sitzung erzeugen
        try (Store store = sitzung.getStore("pop3s")){
            //und verbinden
            store.connect(server, benutzername, passwort);
            //ein Ordnerobjekt für den Posteingang erzeugen     
            Folder posteingang  = store.getFolder("INBOX");
            //und öffnen
            //dabei sind auch Änderungen zugelassen
            posteingang.open(Folder.READ_WRITE);

            //die Nachrichten beschaffen
            Message nachrichten[] = posteingang.getMessages();

            //gibt es neue Nachrichten?
            if (nachrichten.length != 0) {
                //dann die Anzahl zeigen
                JOptionPane.showMessageDialog(this, "Es gibt "+ posteingang.getUnreadMessageCount() + " neue Nachrichten.");
                //jede Nachricht verarbeiten
                for(Message nachricht : nachrichten)
                    nachrichtVerarbeiten(nachricht);
            }               
            else
                JOptionPane.showMessageDialog(this, "Es gibt keine neue Nachrichten.");

            //den Ordner schließen
            //durch das Argument true werden die Nachrichten gelöscht
            posteingang.close(true);
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }

    private void nachrichtVerarbeiten(Message nachricht) {
        try {
            //ist es einfacher Text?
            if (nachricht.isMimeType("text/plain")) {
                //den ersten Sender beschaffen
                String sender = nachricht.getFrom()[0].toString();
                //den Betreff
                String betreff = nachricht.getSubject();
                //den Inhalt
                String inhalt = nachricht.getContent().toString();
                //und die Nachricht speichern
                nachrichtSpeichern(sender, betreff, inhalt);
                //und zum Löschen markieren
                nachricht.setFlag(Flags.Flag.DELETED, true);
            }
            //sonst geben wir eine Meldung aus
            else
                JOptionPane.showMessageDialog(this, "Der Typ der Nachricht " + nachricht.getContentType() + "kann nicht verarbeitet werden.");   
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }


    private void nachrichtSpeichern(String sender, String betreff, String inhalt) {
        //für die Verbindung
        Connection verbindung;

        //die Datenbank öffnen
        verbindung=MiniDBTools.oeffnenDB("jdbc:derby:mailDB");
        try {
            //einen Eintrag in der Tabelle empfangen anlegen
            //über ein vorbereitetes Statement
            PreparedStatement prepState;
            prepState = verbindung.prepareStatement("insert into empfangen (sender, betreff, inhalt) values (?, ?, ?)");
            prepState.setString(1, sender);
            prepState.setString(2, betreff);
            prepState.setString(3, inhalt);
            //das Statement ausführen
            prepState.executeUpdate();
            verbindung.commit();

            //Verbindung schließen
            prepState.close();
            verbindung.close();
            //und die Datenbank schließen
            MiniDBTools.schliessenDB("jdbc:derby:mailDB");
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }

    public void actionPerformed(ActionEvent e) {
        // TODO Automatisch generierter Methodenstub
        
    }
}

und hier meine Klasse Weiterleiten: (Antworten sieht im Grunde genauso aus):

package de.fernschulen.minimail;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Weiterleitung extends JDialog{
    //automatisch über Eclipse erzeugt
    private static final long serialVersionUID = -5496318621928815910L;

    //für die Eingabefelder
    private JTextField empfaenger, betreff;
    private JTextArea inhalt;
    //für die Schaltflächen
    private JButton ok, abbrechen;
    // Aufgabe 1: Variablen für Benutzernamen und Passwort festlegen - vorerst mit dem Wert null, der Inhalt wird später gesetzt
    String benutzername = null;
    String passwort = null;
    

    //die innere Klasse für den ActionListener
    class NeuListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            //wurde auf OK geklickt?
            if (e.getActionCommand().equals("weiterleiten"))
                try {
                    senden();
                } catch (IOException e1) {
                    // TODO Automatisch generierter Erfassungsblock
                    e1.printStackTrace();
                }
            //wurde auf Abbrechen geklickt?
            if (e.getActionCommand().equals("abbrechen"))
                //dann Dialog schließen
                dispose();
        }
    }

    //der Konstruktor
    public Weiterleitung(JFrame parent, boolean modal, String iD, String empfaenger2, String betreff2, String inhalt2) {
        setTitle("Nachricht weiterleiten");
        //die Oberfläche erstellen
        initGui();

        //Standardoperation setzen
        //hier den Dialog ausblenden und löschen
        setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
    }

    private void initGui() {
        setLayout(new BorderLayout());
        JPanel oben = new JPanel();
        oben.setLayout(new GridLayout(0, 2));
        oben.add(new JLabel("Empfänger:"));
        empfaenger = new JTextField();
        oben.add(empfaenger);
        oben.add(new JLabel("Betreff:"));
        betreff = new JTextField();
        oben.add(betreff);
        add(oben, BorderLayout.NORTH);
        inhalt = new JTextArea();
        //den Zeilenumbruch aktivieren
        inhalt.setLineWrap(true);
        inhalt.setWrapStyleWord(true);
        //das Feld setzen wir in ein Scrollpane
        JScrollPane scroll = new JScrollPane(inhalt);
        scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        add(scroll);

        JPanel unten = new JPanel();
        //die Schaltflächen
        ok = new JButton("Weiterleiten");
        ok.setActionCommand("weiterleiten");
        abbrechen = new JButton("Abbrechen");
        abbrechen.setActionCommand("abbrechen");

        NeuListener listener = new NeuListener();
        ok.addActionListener(listener);
        abbrechen.addActionListener(listener);

        unten.add(ok);
        unten.add(abbrechen);
        add(unten, BorderLayout.SOUTH);

        //anzeigen
        setSize(600, 300);
        setVisible(true);
    }

    //die Methode verschickt die Nachricht
    private void senden() throws IOException {
        //für die Sitzung
        Session sitzung;

        //die Verbindung herstellen
        sitzung = verbindungHerstellen();
        //die Nachricht verschicken und speichern
        nachrichtVerschicken(sitzung);
        nachrichtSpeichern();
    }

    private Session verbindungHerstellen() {
        // Aufgabe 1: Einen neuen BufferedReader erstellen und auf die angelegte txt. Datei "anmeldedaten.txt über das Paket zugreifen
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(Empfangen.class.getResourceAsStream("/de/fernschulen/minimail/anmeldedaten.txt")))) {
            // Aufgabe 1: in der ersten Zeile ist der Benutzername hinterlegt, somit wird nun die erste Zeile ausgelesen
            benutzername = reader.readLine();
            // Aufgabe 1: anschließend wird die nächste Zeile ausgelesen für das dazugehörige Passwort
            passwort = reader.readLine();
        }
        catch (IOException e) {
            System.out.println("Die Anmeldedaten konnten nicht gefunden werden" + e);
        }
        //der Server
        String server = "smtp.gmail.com";

        //die Eigenschaften setzen
        Properties eigenschaften = new Properties();
        //die Authentifizierung über TLS
        eigenschaften.put("mail.smtp.auth", "true");
        eigenschaften.put("mail.smtp.starttls.enable", "true");
        //der Server
        eigenschaften.put("mail.smtp.host", server);
        //der Port zum Versenden
        eigenschaften.put("mail.smtp.port", "587");
    

        // das Session-Objekt erstellen
        Session sitzung = Session.getInstance(eigenschaften, new Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(benutzername, passwort);
            }
        });
        
        return sitzung;
        
    }

    private void nachrichtVerschicken(Session sitzung) {
        //der Absender
        String absender = "mel92mueller@gmail.com";

        try {
            //eine neue Nachricht vom Typ MimeMessage erzeugen
            MimeMessage nachricht = new MimeMessage(sitzung);
            //den Absender setzen
            nachricht.setFrom(new InternetAddress(absender));
            //den Empfänger
            nachricht.setRecipients(Message.RecipientType.TO, InternetAddress.parse(empfaenger.getText()));
            //den Betreff
            nachricht.setSubject(betreff.getText());
            //und den Text
            nachricht.setText(inhalt.getText());
            //die Nachricht verschicken
            Transport.send(nachricht);

            JOptionPane.showMessageDialog(this, "Die Nachricht wurde verschickt.");

            //den Dialog schließen
            dispose();

        }
        catch (MessagingException e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }       
    }

    private void nachrichtSpeichern() {
        //für die Verbindung
        Connection verbindung;

        //die Datenbank öffnen
        verbindung=MiniDBTools.oeffnenDB("jdbc:derby:mailDB");
        try {
            //einen Eintrag in der Tabelle gesendet anlegen
            //über ein vorbereitetes Statement
            PreparedStatement prepState;
            prepState = verbindung.prepareStatement("insert into gesendet (empfaenger, betreff, inhalt) values (?, ?, ?)");
            prepState.setString(1, empfaenger.getText());
            prepState.setString(2, betreff.getText());
            prepState.setString(3, inhalt.getText());
            //das Statement ausführen
            prepState.executeUpdate();
            verbindung.commit();

            //Verbindung schließen
            prepState.close();
            verbindung.close();
            //und die Datenbank schließen
            MiniDBTools.schliessenDB("jdbc:derby:mailDB");
        }
        catch (Exception e) {
            JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
        }
    }

    }

Irgendwas muss ich noch anpassen, aber ich weiß nicht was. Also Vorlage hatte ich die Klasse zum Verschicken einer neuen Nachricht genommen und ich denke da muss noch was anders. Vielleicht kann mir hierbei nochmal jemand helfen

 

[Robert Zenz]

Gegenfrage: Du uebergibst die Werte an den Konstruktor, zu welchem Zeitpunkt setzt du diese in das Textfeld?

So als Anmerkung: serialVersionUID kannst du weglassen beziehungsweise die Warnung in Eclipse ausschalten es sei denn du willst die Klassen wirklich serialisieren...was du eigentlich nie ueber den Standard-Java Mechanismus willst.

 

[Oneixee5]

Wie du die Datenbankzugriffe handhabst, das geht so nicht. Du musst gewährleisten, dass im Fehlerfall die Ressourcen freigegeben werden. Ein Rollback-Versuch fehlt völlig, so kann die DB-Session in einen inkonsistenten Zustand versetzt werden. Verwende try-with-resource-Pattern. Ich vermute auch, dass du in MiniDBTools immer neue DB-Verbindungen aufbaust. Das kann dein Programm sehr langsam machen. Besser man verwendet eine Datasource mit einen ConnectionPool. Eine Connection im Pool reicht vermutlich aus aber anstatt diese zu schließen, gibt man die immer wieder zurück.

Das ist keine sinnvolle Fehlerbehandlung, so kannst du im Fehlerfall nicht rausfinden was wirklich passiert. Ein Nutzer kann damit auch nichts anfangen. Logge die Fehler inkl. Stacktrace in eine Datei und gib verständliche Fehlermeldungen aus.

} catch (Exception e) {
    JOptionPane.showMessageDialog(this, "Problem: \n" + e.toString());
}

Die Kommentare sind überhaupt nicht sinnvoll:

    //der Konstruktor
    public Weiterleitung(JFrame parent, boolean modal, String iD, String empfaenger2, String betreff2, String inhalt2) {

Jeder sieht -> ein Konstruktor. Wozu der Kommentar?

Die Parameter werden gar nicht verwendet!?

    //der Konstruktor
    public Weiterleitung(JFrame parent, boolean modal, String iD, String empfaenger2, String betreff2, String inhalt2) {
        setTitle("Nachricht weiterleiten");
        //die Oberfläche erstellen
        initGui();

        //Standardoperation setzen
        //hier den Dialog ausblenden und löschen
        setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
    }

Diese Kommentare scheinen einfach nur eine Übersetzung der Programmzeilen ins Deutsche zu sein, völlig unnütz...

            //eine neue Nachricht vom Typ MimeMessage erzeugen
            MimeMessage nachricht = new MimeMessage(sitzung);
            //den Absender setzen
            nachricht.setFrom(new InternetAddress(absender));
            //den Empfänger
            nachricht.setRecipients(Message.RecipientType.TO, InternetAddress.parse(empfaenger.getText()));
            //den Betreff
            nachricht.setSubject(betreff.getText());
            //und den Text
            nachricht.setText(inhalt.getText());
            //die Nachricht verschicken
            Transport.send(nachricht);

Sorry, das sollte gar nicht so unfreundlich sein aber dein Programm ist schon etwas chaotisch.