# Normales Java Programm in Applet umwandeln



## noxx (20. Jul 2010)

Mahlzeit zusammen,

ich habe ein kleines Problem!  Da ich erste seit einigen Monaten Java mache bin ich noch nicht wirklich vertraut mit dem ganzen Thema. Meine eigentliche Aufgabe war es ein kleines Programm zu schreiben, welches Daten aus einer Excel Tabelle einliest und diese über eine GUI in einer Tabelle ausgibt. Dies funktioniert auch alles soweit ganz gut. Nun besteht jedoch für mich das Problem, dass ich dieses Programm möglichst in eine Website einbetten soll. Dazu brauche ich ja meine jetzige GUI als Applet & dieses umschreiben fällt mir doch sichtlich schwer. Ich bin schon soweit, dass ich weiß das ich eine init()-Funktion brauche, allerdings habe ich wirklich keinen Schimmer, wie is das alles schreiben soll dann. Dies scheint mir hier die letzte Lösung zu sein, hänge an dem Problem schon ca. 2 Wochen fest und komme einfach nicht weiter .... Hier mal meine grundsätzlichen Klassen

DBSearchAndReturn.class:

```
package piv.lenses;

import javax.swing.UIManager;
import piv.lenses.gui.*;


public class DBSearchAndReturn 
{

	public static void main(String[] args)
	{
		
	  try
	  	{ UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); }
	  catch (Exception e)
	  	{ System.out.println("Fehler bei der Anwendung des neuen Look-and-Feel's : "+e); }
	  
	  
	  StartFrame.getInstance().setVisible(true);
	}
}
```

StartFram.class:


```
package piv.lenses.gui;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import piv.lenses.actions.*;


public class StartFrame extends JFrame
{

	  //---------------------------------------------------------------------------
	  //--- instance-variable(s) --------------------------------------------------
	  //---------------------------------------------------------------------------
	  private static 			StartFrame  	   	instance            = null;
	  private        			JLabel            	statusLabel         = new JLabel(" ");
	  public boolean 				  				running		       	= true;
	  private static final long 	   				serialVersionUID	= 1L;
	  private 					String  			columnNames[]		= { "Name","Angegebene Brennweite (in mm)","Reale Brennweite (in mm)", 
			  																"Aufnahmeart","Öffnungsverhältnis","Negativformat",
			  																"Durchmesser (in mm)","Länge (in mm)","Lage der Hauptebene"};
	  private					JTable 				myTable;
	  private					JPanel				mainPanel			= new JPanel(new BorderLayout());
	 	
	  //---------------------------------------------------------------------------
	  //--- constructor(s) --------------------------------------------------------
	  //---------------------------------------------------------------------------
	  public StartFrame()
	  {
	  	super("Objektivauswahl");
	  	
	  	initAction();
	  	initGUI();
	  }

	  //---------------------------------------------------------------------------
	  //--- private/public  method(s) ---------------------------------------------
	  //---------------------------------------------------------------------------
	  public synchronized static StartFrame getInstance()
	  {
	  	if (instance==null)
	  	{
	  		instance = new StartFrame();
	  	}
	  	return instance;
	  }

	  //---------------------------------------------------------------------------
	  public void initAction()
	  {
			this.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
			this.addWindowListener(new WindowAdapter()
			{
				public void windowClosing(WindowEvent event)
				{
					ExitAction.getInstance().actionPerformed(null);
				}
			});

	  }
	  
	  //---------------------------------------------------------------------------
	  public void initGUI()
	  {
	  	JPanel buttonPanel = new JPanel(new FlowLayout());
	  	buttonPanel.add(new JButton(LoadTableAction.getInstance()));
	  	buttonPanel.add(new JButton(NewEntryAction.getInstance()));
	  	buttonPanel.add(new JButton(ExitAction.getInstance()));

	  	JPanel statusPanel = new JPanel(new BorderLayout());
	  	statusPanel.setBorder(BorderFactory.createBevelBorder(40));
	  	statusPanel.add(statusLabel, BorderLayout.CENTER);
	  	
		mainPanel.add(buttonPanel, BorderLayout.NORTH);
		mainPanel.add(statusPanel, BorderLayout.SOUTH);
		
	  	this.setSize(1000, 250);
		this.setLocation(400, 400);
		this.add(mainPanel, BorderLayout.CENTER);
		this.setStatusText("Programm wurde gestartet...");
	  }
	  
	  //---------------------------------------------------------------------------
	  public void setCellData (String data[][])
	  {
		myTable = new JTable(data,columnNames);
		mainPanel.add(new JScrollPane(myTable), BorderLayout.CENTER);
		myTable.setEnabled(false);
		mainPanel.validate();

	  }
	  //---------------------------------------------------------------------------
	  public void setStatusText(String newStatus)
	  {
	  	statusLabel.setText(newStatus);
	  }
}
```

Soweit der Quelltext, vielleicht bin ich auch wirklich zu doof nur. Wäre aber klasse wenn mir jemand auf die Sprünge helfen könnte.
Vielen Dank im Voraus!

noxx


----------



## Marcinek (20. Jul 2010)

Hallo,

statt von JFrame, muss das Applet von Applet oder JApplet erben.

DAnn musst du statt main() eine init Methode implementieren, in der Klasse, die von dem Browser dann geladen werden soll.

Gruß

Martin


----------



## noxx (20. Jul 2010)

Das ist mir soweit schon klar alles, diese Infos hab ich auch noch selbst zusammen suchen können mit Hilfe von Google. Nur leider hab ich keine Ahnung was genau ich da jetzt umschreiben muss... kannst du mir evtl. mal ein Beispiel schreiben anhand meines Quellcodes ?

Gruß
noxx


----------



## L-ectron-X (20. Jul 2010)

Soll das Applet direkt in eine Webseite eingebaut werden, oder soll das Applet deinen Frame über dem Browser-Fenster öffnen?


----------



## noxx (20. Jul 2010)

Am besten wäre natürlich die Einbindung direkt in die Webseite, allerdings können auch neue Einträge in die Excel-Tabelle vorgenommen werden über einen JDialog und ich weiß nicht wie sich das bei Applets verhält. Daher würde eine Öffnung über dem Browser-Fenster sich eher anbieten denke ich...

gruß


----------



## L-ectron-X (20. Jul 2010)

Es geht beides, du müsstest dich aber für eine Variante entscheiden.


----------



## noxx (20. Jul 2010)

Okay, dann würde ich die Möglichkeit mit der Frame über dem Browser-Fenster bevorzugen 

Gruß


----------



## L-ectron-X (20. Jul 2010)

Dann hier ein entsprechendes Beispiel, wie man es machen könnte:
Ein Fenster für eine Applikation. Abhängig vom benutzten Konstruktor "erkennt" das Fenster, wie es aufgerufen wurde.

```
import javax.swing.*;

public class MyFrame extends JFrame {
  public MyFrame(String title) {
    super(title);
    setSize(800, 600);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
  
  public MyFrame(MyApplet applet) {
    super("MyFrame-Appletcation");
    setSize(800, 600);
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  }
  
  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new MyFrame("MyFrame-Application").setVisible(true);
      }
    });
  }
}
```

Das Applet:
Es ruft nur das Fenster auf.

```
import javax.swing.*;

public class MyApplet extends JApplet {
  public void init() {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new MyFrame(MyApplet.this).setVisible(true);
      }
    });
  }
}
```
Du brauchst dafür also gar nicht so viel ändern. Etwas umfangreicher wird es dann, wenn du bspw. Bilder laden möchtest.


----------



## noxx (21. Jul 2010)

Danke für das Beispiel soweit funktionert es auch alles. Habe es hinbekommen, dass das Applet das Fram erzeugt. Die Buttons im Frame werden auch angezeigt, allerdings wird die Exceltabelle nicht mehr in der JTable ausgegeben, jedoch aber geladen, was mir die Konsole sagt. Woran könnte dies liegen ?

[JAVA=85]
      public void setCellData (String data[][])
      {
        myTable = new JTable(data,columnNames);
        mainPanel.add(new JScrollPane(myTable), BorderLayout.CENTER);
        myTable.setEnabled(false);
        mainPanel.validate();

      }
[/code]

Dieser Teil wird dann meiner Meinung nach nicht mehr ausgeführt. Aber warum ?! 
*
Edit:* in die Exceltabelle schreiben funktioniert ebenfalls noch. Lediglich die Statuszeile im JFrame gibt dabei keine veränderten Informationen an, wie z.B. "Tabelle wurde gespeichtert" oder so...

Gruß


----------



## L-ectron-X (22. Jul 2010)

Guck mal in die Java-Konsole, wenn dein Applet läuft. Gibts da Fehlermeldungen?


----------



## noxx (22. Jul 2010)

Nein keine Fehlermeldung, die Tabelle wird auch ordnungsgemäß geladen. Die Einträge stimmen auch die geladen werden, lediglich die Tabelle im Frame fehlt danach. Kann es evtl sein, das dies etwas mit den Instancen zu tun hat, oder verändert sich da im Gegensatz zu einer normalen Application nichts ?

gruß


----------



## L-ectron-X (22. Jul 2010)

Nein da ändert sich nichts. Ich denke auch nicht, dass das was mit dem Applet zu tun hat. Es öffnet ja auch einfach nur den JFrame, ähnlich wie die main()-Methode einer Applikation.
Möglicherweise stimmt der Zeitpunkt für das Anzeigen nicht. U.U. noch ein validate() / revalidate() am Ende einfügen. Lässt sich ohne Code nicht pauschal sagen...


----------



## noxx (22. Jul 2010)

Okay, ich werde selbst nochmal nach schaune genau. Hier sonst nochmal kurz der Code, vllt sieht jemand anders den Fehler eher als ich:

MyApplet.class

```
package piv.lenses;

import javax.swing.*;
import piv.lenses.gui.*;


public class MyApplet extends JApplet 
{

	private static final long serialVersionUID = 1L;

	public void init()
	{
		SwingUtilities.invokeLater(new Runnable()
		{
			public void run()
			{
				new StartFrame(MyApplet.this).setVisible(true);
			}
		});
	}
}
```

StartFrame.class

```
package piv.lenses.gui;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
//import java.awt.event.*;
import javax.swing.*;

import piv.lenses.MyApplet;
import piv.lenses.actions.*;



public class StartFrame extends JFrame
{

	  //---------------------------------------------------------------------------
	  //--- instance-variable(s) --------------------------------------------------
	  //---------------------------------------------------------------------------
	  private static 			StartFrame  	   	instance            = null;
	  private        			JLabel            	statusLabel         = new JLabel(" ");
	  public boolean 				  				running		       	= true;
	  private static final long 	   				serialVersionUID	= 1L;
	  private 					String  			columnNames[]		= { "Name","Angegebene Brennweite (in mm)","Reale Brennweite (in mm)", 
			  																"Aufnahmeart","Öffnungsverhältnis","Negativformat",
			  																"Durchmesser (in mm)","Länge (in mm)","Lage der Hauptebene"};
	  private					JTable 				myTable;
	  private					JPanel				mainPanel			= new JPanel(new BorderLayout());
	 	
	  //---------------------------------------------------------------------------
	  //--- constructor(s) --------------------------------------------------------
	  //---------------------------------------------------------------------------
	  public StartFrame()
	  {
	  	super("Objektive");
	  	
//	  	initAction();
//	  	initGUI();
	  	setSize(1000,250);
	  	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  }
	  
	  public StartFrame(MyApplet applet)
	  {
		  super("StartFrame-Appletaction");
		  setSize(1000, 250);
		  setLocation(200, 200);
		  initAction();
		  initGUI();
		  setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);		  
	  }
	  
	  public static void main(String[] args)
	  {
		  SwingUtilities.invokeLater(new Runnable()
		  {
			  public void run()
			  {
				  new StartFrame().setVisible(true);
			  }  
		  });
	  }
	  //---------------------------------------------------------------------------
	  //--- private/public  method(s) ---------------------------------------------
	  //---------------------------------------------------------------------------
	  public synchronized static StartFrame getInstance()
	  {
	  	if (instance==null)
	  	{
	  		instance = new StartFrame();
	  	}
	  	return instance;
	  }

	  //---------------------------------------------------------------------------
	  public void initAction()
	  {
			this.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
			this.addWindowListener(new WindowAdapter()
			{
				public void windowClosing(WindowEvent event)
				{
					ExitAction.getInstance().actionPerformed(null);
				}
			});

	  }
	  
	  //---------------------------------------------------------------------------
	  public void initGUI()
	  {
	  	JPanel buttonPanel = new JPanel(new FlowLayout());
	  	buttonPanel.add(new JButton(LoadTableAction.getInstance()));
	  	buttonPanel.add(new JButton(NewEntryAction.getInstance()));
	  	buttonPanel.add(new JButton(ExitAction.getInstance()));

	  	JPanel statusPanel = new JPanel(new BorderLayout());
	  	statusPanel.setBorder(BorderFactory.createBevelBorder(40));
	  	statusPanel.add(statusLabel, BorderLayout.CENTER);
	  	
		mainPanel.add(buttonPanel, BorderLayout.NORTH);
		mainPanel.add(statusPanel, BorderLayout.SOUTH);
		
//	  	this.setSize(1000, 250);
//		this.setLocation(400, 400);
		this.add(mainPanel, BorderLayout.CENTER);
		this.setStatusText("Programm wurde gestartet...");
	  }
	  
	  //---------------------------------------------------------------------------
	  public void setCellData (String data[][])
	  {
		myTable = new JTable(data,columnNames);
		mainPanel.add(new JScrollPane(myTable), BorderLayout.CENTER);
		myTable.setEnabled(false);
		mainPanel.validate();
		mainPanel.revalidate();

	  }
	  //---------------------------------------------------------------------------
	  public void setStatusText(String newStatus)
	  {
	  	statusLabel.setText(newStatus);
	  }
}
```

LoadTableAction.class


```
package piv.lenses.actions;



import java.awt.event.*;
import javax.swing.*;


import org.apache.poi.hssf.usermodel.*;

import piv.lenses.gui.StartFrame;



import java.io.*;



public class LoadTableAction extends AbstractAction implements Runnable
{

	  //---------------------------------------------------------------------------
	  //--- instance-variable(s) --------------------------------------------------
	  //---------------------------------------------------------------------------
	  private static			LoadTableAction  	instance  			= null;
	  private static final long  					serialVersionUID  	= 1L;

	  //---------------------------------------------------------------------------
	  //--- constructor(s) --------------------------------------------------------
	  //---------------------------------------------------------------------------
	  private LoadTableAction()
	  {
	  	super("Tabelle laden");
	  
	  }

	  //---------------------------------------------------------------------------
	  //--- private/public  method(s) ---------------------------------------------
	  //---------------------------------------------------------------------------
	  public synchronized static LoadTableAction getInstance()
	  {
	  	if (instance==null)
	  	{
	  		instance = new LoadTableAction();
	  	}
	  	return instance;
	  }

	  //---------------------------------------------------------------------------
	  //--- overwritten from 'Runnable' -------------------------------------------
	  //---------------------------------------------------------------------------
	  
	  
	  public void run()
	  { 
		  int rowcounter = 1;
		  
		  try
		  {	
			
			File excelFile = new File("C:/Programmierung/JAVA/DLR-AS-EV/src/piv/lenses/Objektive.xls");		//Für Testzwecke beim Programmieren
//			File excelFile = new File("Objektive.xls");														//Diese Zeile funktioniert nur in einer Jar-File
			FileInputStream fs = new FileInputStream(excelFile);
			
			System.out.println("Datei wurde gefunden");

			HSSFWorkbook workbook = new HSSFWorkbook(fs);
			HSSFSheet sheet = workbook.getSheetAt(0);

			String data[][] = new String[100][100];
			data[0][0] = "bla";
			int row	= 0;
			int j = 0;
			while(data != null && sheet.getRow(rowcounter) != null)
			{
				for(j = 0; j < sheet.getRow(rowcounter).getPhysicalNumberOfCells(); j++)
				{
					if(sheet.getRow(rowcounter).getCell(j) !=  null)
					{
						data[row][j] = sheet.getRow(rowcounter).getCell(j).toString();	
						System.out.println(data[row][j]);		
					}
				}
				rowcounter++;
				row++;
				StartFrame.getInstance().setCellData(data);	
			}


			fs.close();
			StartFrame.getInstance().setStatusText("Tabelle wurde erfolgreich geladen.");
		  } 
		  catch (Exception e) 
		  {
			e.printStackTrace();
			StartFrame.getInstance().setStatusText("Tabelle konnte nicht gefunden werden.");
		  }	  
		  
	  }
	
	  //---------------------------------------------------------------------------
	  //--- overwritten from 'AbstractAction' -------------------------------------
	  //---------------------------------------------------------------------------
	  public void actionPerformed(ActionEvent e)
	  {
		  Thread countThread = new Thread(this);
		  countThread.start();
	  }
}
```

Vielen Dank sonst schonmal


----------



## L-ectron-X (22. Jul 2010)

In der gegenwärtigen Version holst du dir gar nicht den JFrame, den du erzeugt hast, sondern einen ganz anderen. Du müsstest den Code dahingehend anpassen, dass du statt new StartFrame() etc. die getInstance()-Methode benutzt, um den JFrame zu erzeugen.


----------



## noxx (23. Jul 2010)

Guten morgen!

Ich weiß ich stelle ziemlich viele nachfragen, aber wie darf ich mir das denn vorstellen dann? Statt instance = new StartFrame() muss ich dann was genau schreiben? Mein Problem ist einfach, dass ich die Sachen anwenden kann, die unser Prof. uns beigebracht hat, aber danach stehe ich irgendwie immer ziemlich auf dem Schlauch, gerade auch wenn Googel nicht helfen kann oder andere Beiträge hier im Forum... wäre sensationell wenn du mir das noch ein bisschen genauer erklären könntest


----------



## L-ectron-X (23. Jul 2010)

noxx hat gesagt.:


> Ich weiß ich stelle ziemlich viele nachfragen


Das geht schon in Ordnung.

Im Applet erzeugst du eine namenlose Instanz deines JFrames und zeigst ihn an.
In deinem JFrame arbeitest du aber mit einer Instanzvariable namens instance. Wenn die null ist, wird eine Instanz erzeugt und dieser Variable zugewiesen. Innerhalb deines JFrames greifst du nur auf diese Instanz zu, wenn du mit deinem JFrame etwas anstellen möchtest.
Das bedeutet, du hast zwei unabhängig von einander existierende Instanzen deines JFrames.

Du kannst also mein obiges Beispiel nicht 1:1 übernehmen. Stelle deine main()-Methode wieder her, passe deinen Konstruktor für den Start des Fensters über das Applet an und sorge dafür, dass du immer mit der gleichen Instanz (instance) arbeitest.

validate() und revalidate() kannst du wieder entfernen.


----------



## JanHH (25. Jul 2010)

Irgendwie kommt mir das ziemlich wirr vor. "Applet" und "Excel-Tabelle" widersprechen sich doch irgendwie. Wo liegt denn die Excel-Tabelle? Ein Applet sollte ja nun eher nicht auf Dateien auf dem lokalen Rechner zugreifen, und eine Excel-Tabelle, die auf einem Server liegt, erscheint mir sinnlos. Ich würde mich der Problemstellung eher von der Fragestellung, was eigentlich gemacht werden soll, nähern. Wenn ein serverseitiger Datenbestand über das Web bearbeitet werden soll, gibt es viele Möglichkeiten, aber ein Applet, welches auf eine Excel-Tabelle zugreift, erscheint mir da eher seltsam..


----------



## noxx (5. Aug 2010)

Im Grunde macht das alles auch nicht wirklich Sinn mit Applet und Excel-Tabelle. Nur so wirklich Einfluss hat man da nicht wirklich drauf, wenn man eine Aufgabe bekommt und der Betreuer nicht so fit in dem Gebiet ist. Im Grunde sollte es ne offline Website mit Applet sein und das alles liegt dann auf einem interen Server incl Tabelle die einfache bestimmte Informationen enthalten soll.

Egal ist alles geklärt. Vielen Dank nochmal!

Gruß
noxx


----------

