# JTable aktualisieren



## Nizar1984 (24. Jul 2009)

Folgendes Problem:

Die Klasse Main Panel hat einen JTable, der ein eigenes TableModel (Klasse: AuthorTableModel) verwendet. Dieser JTable ist mit Daten einer Datenbank gefüllt.

Vom Main Panel aus kann man mit der Maus einen Eintrag des JTables auswählen, und diesen dann per Klick auf einen Button bearbeiten. Daraufhin öffnet sich ein neues Fenster, von welchem man aus den Eintrag bearbeiten kann. Drückt man im neuen Fenster auf abspeichern, wird der modifizierte Eintrag in der Datenbank abgelegt.

Nur: wie kann ich eine automatische Änderung im Hauptfenster auslösen, nachdem im Bearbeitungsfenster abgespeichert wurde?

MainPanel:


```
package view;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;
import java.util.Observer;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.TableModel;


public class MainPanel extends JFrame  implements ActionListener
{

	private static final long serialVersionUID = 1L;
	
	  AuthorTableModel atm = new AuthorTableModel();
		
      final JTable at = new JTable(atm);
      
		final Frame owner = this;

      
	
	public MainPanel() throws SQLException, ClassNotFoundException
	{	
				
		
		setTitle("Content Management System");

		JPanel jpMain = new JPanel(new BorderLayout());
				
		
	    JMenuBar menuBar = new JMenuBar();
	    
	    JMenu menuAuthors = new JMenu("Authors");
	    JMenu menuArticles = new JMenu("Articles");
	    
	    JMenuItem insertAuthorItem = new JMenuItem("Insert Author");
	    
	    jpMain.add(menuBar, BorderLayout.NORTH);
	  	    
	    menuBar.add(menuAuthors);
	    menuBar.add(menuArticles);
	       
	    menuAuthors.add(insertAuthorItem);
	    
	    insertAuthorItem.addActionListener(this);
	    insertAuthorItem.setActionCommand("Insert Author");
	    
	    
	  
       
        JPanel controlPanel = new JPanel(new BorderLayout());
                
        final JButton updateButton = new JButton("Update");
        
        JButton deleteButton = new JButton("Delete");
        
        JPanel buttonPanel = new JPanel(new GridLayout(0,1));

        
        buttonPanel.add(updateButton);
        
        updateButton.setEnabled(false);
      
        
        at.getSelectionModel().addListSelectionListener(
				new ListSelectionListener() {
					public void valueChanged(ListSelectionEvent event) {
						
							if (at.getSelectedRow() == -1) {
								updateButton.setEnabled(false);
							}
							else 
								updateButton.setEnabled(true);
						
					}
				}
				);
        
        updateButton.addActionListener(this);
        updateButton.setActionCommand("Update");
        
        buttonPanel.add(deleteButton);
        
        controlPanel.add(buttonPanel, BorderLayout.NORTH);
        
        jpMain.add(controlPanel, BorderLayout.EAST);
        
           
        JScrollPane scrollpane = new JScrollPane(at);
                
        jpMain.add(scrollpane, BorderLayout.CENTER);
        
        
	    
        this.add(jpMain);
        this.setVisible(true);
        this.pack();

	}

	public void actionPerformed(ActionEvent e) 
	{
		if(e.getActionCommand().equals("Insert Author"))
		{
			new InsertAuthorWindow();
		}
		if(e.getActionCommand().equals("Update"))
		{
			UpdateAuthorWindow uAW = new UpdateAuthorWindow(at.getSelectedRow());
			
			
		}
	}
	
	

}
```

Bearbeitungsfenster:


```
package view;

import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observer;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

import model.Author;

import db.AuthorDAO;

public class UpdateAuthorWindow extends JFrame implements ActionListener
{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	JLabel firstNameLabel = new JLabel("First Name: ");
	JTextField firstNameField = new JTextField();
	
	JLabel lastNameLabel = new JLabel("Last Name: ");
	JTextField lastNameField = new JTextField();
	
	JButton saveButton = new JButton("Save");
	JButton cancelButton = new JButton("Cancel");
	
	AuthorDAO aDAO = new AuthorDAO();
	
	Author a;
	Author a2;
	
	int aID;

    
	
	
	public UpdateAuthorWindow(int authorID)
	{
		this.aID = authorID;
		this.a = aDAO.getAuthor(authorID);
		
		setLayout(new GridLayout(0,2));
		add(firstNameLabel);
		add(firstNameField);
		add(lastNameLabel);
		add(lastNameField);
		add(saveButton);
		add(cancelButton);
		setVisible(true);
		this.pack();
		
		saveButton.addActionListener(this);
		saveButton.setActionCommand("Update");
		
		firstNameField.setText(this.a.getFirstName());
		lastNameField.setText(this.a.getLastName());
		
	}

	public void actionPerformed(ActionEvent e) {
		if(e.getActionCommand().equals("Update"))
		{
			a.setFirstName(firstNameField.getText());
			a.setLastName(lastNameField.getText());
			a.setID(aID);
			
			
			aDAO.updateAuthor(firstNameField.getText(), lastNameField.getText(), aID);
		}
		
	}
	
	public Author getAuthor()
	{
		return a;
	}
	
	

}
```


TableModel:


```
package view;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;


import model.Author;

import db.AuthorDAO;

public class AuthorTableModel implements TableModel
{
	

	static String[] COLUMN_NAMES = { "ID", "First Name", "Last Name"};
	
	private List<Author> authors = new ArrayList<Author>();
	
	private List<TableModelListener> listeners = new ArrayList<TableModelListener>();


    AuthorDAO aDAO = new AuthorDAO();
    
    public AuthorTableModel()
    {
    	try {
			updateTableData();
			System.out.println("done");
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
	
    public void updateAuthor(String firstName, String lastName, int ID)
    {
    	aDAO.updateAuthor(firstName, lastName, ID);
    	try {
			updateTableData();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(firstName + lastName+ ID);
    }
	
 public void updateTableData() throws SQLException, 
	ClassNotFoundException 
	{
         authors = aDAO.getAuthors();
         
         for (TableModelListener l : listeners) {
 			l.tableChanged(new TableModelEvent(this));
 		}
         
    }


	public void addTableModelListener(TableModelListener l) {
		listeners.add(l);
		
	}

	public Class<?> getColumnClass(int columnIndex) {
		// TODO Auto-generated method stub
		return String.class;
	}

	public int getColumnCount() {
		return COLUMN_NAMES.length;
	}

	public String getColumnName(int columnIndex) {
		// TODO Auto-generated method stub
		return COLUMN_NAMES[columnIndex].toString();
	}

	public int getRowCount() 
	{
		return authors.size();
	}

	public Object getValueAt(int rowIndex, int columnIndex) 
	{
	
		Author a = authors.get(rowIndex);
	
		switch (columnIndex) 
		{
		case 0:
			return a.getID();
		case 1:
			return a.getFirstName();

		case 2:
			return a.getLastName();
		}
		System.out.println("done");
		return "";
		
	}
		
	

	public boolean isCellEditable(int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
		return false;
	}

	public void removeTableModelListener(TableModelListener l) {

		listeners.remove(l);

	}

	public void setValueAt(Object value, int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
		
	}
	

	
	 
}
```


----------



## Ebenius (24. Jul 2009)

Mach Dir für den Editor-Teil ein Modell, welches das Tabellenmodell aktualisiert und das Speichern zur Datenbank auslöst. Oder Mach ein Modell welches in die Datenbank speichert und einen Event verschickt auf den das Tabellenmodell hört und sich aktualisiert.

Ebenius


----------



## Nizar1984 (25. Jul 2009)

Ich habs jetzt im Prinzip mit 2 zusätzlichen Zeilen Code gelöst, aber ich weiß nicht ob das so elegant ist.

Also, wenn ich im MainPanel den Konstruktor des Bearbeitungsfensters aufrufe, schreibe ich in dessen Argumentliste noch das TableModel dazu. 


  //atm = TableModel für den JTable im MainPanel 
  UpdateAuthorWindow uAW = new UpdateAuthorWindow(at.getSelectedRow(), atm);

Ich passe dann den Konstruktor des Bearbeitungsfensters an indem ich seine Parameterliste dementsprechend erweitere. 

Ich übergebe also dasselbe TableModel ins andere Fenster, und rufe von dort aus dann die Methode des TableModels auf, welche die Tabellendaten aktualisiert. 


```
public void actionPerformed(ActionEvent e) {
		if(e.getActionCommand().equals("Update"))
		{
			a.setFirstName(firstNameField.getText());
			a.setLastName(lastNameField.getText());
			a.setID(aID);
			
			
                         //Modifiziere den Eintrag in der Datenbank
			aDAO.updateAuthor(firstNameField.getText(), lastNameField.getText(), aID);
			
                        //Aktualisiere das TableModel
                      try {
				atm.updateTableData();
			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			} catch (ClassNotFoundException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
		
	}
```


Es funktionert.


----------

