Java Server Pages und Java Beans programmieren mit Eclipse & Tomcat

Want create site? Find Free WordPress Themes and plugins.

Java Server Pages und Java Beans programmieren mit Eclipse & Tomcat

Ich habe ein kleines Programm mit Jave und JSP erstellt . Diese dienen zur Berechnung von Daten verschiedener Zusammensetzungen und Rechenoperationen. So kann man z.B. den Energiebedarf von unterschiedlichen großen Personenhaushalten und dem dazugehörigen Bedarf an Geräten berechnen. Aber auch andere Leistungen können damit programmiert werden. Denkbar ist Entfernungsmessumg zwischen verschiedenen Städten. Die Logik habe ich in 4 Java Beans(Java Klassen)ausgelagert und die eigentliche Applicationen laufen in JSP.  Bei JSP handelt es sich um eine serverseitige Programmiertechnologie. Die Basis ist die Programmiersprache Java. Der Java Code wird beim Aufruf der als JSP Seite gespeicherten HTML Seite vom Applikationsserver Tomcat ausgeführt. Ein Beispiel kannst Du Dir leider nicht anschauen, da nicht jeder Provider Tomcat anbietet. Aber zum ausprobieren kannst du den Code kopieren und selber ausprobieren.

Berechnung Energiebedarf Haushaltgeraete

Was brauchst Du alles dazu?

1. Einen Applikations Server und Eclipse

Der Applikationsservers  Apache Tomcat  besteht aus • einem Servlet-Container, in dem Webapplikationen als Servlets ausgeführt werden, • Compiler und Laufzeitumgebung für Java Server Pages (JSP) Tomcat ist in Java geschrieben und daher auf diversen Plattformen lauffähig. In Produktionsumgebungen wird Tomcat meist mit dem Apache Webserver so kombiniert, dass statische Inhalte vom Webserver und dynamische Inhalte transparent über das Apache JServ Protocol (AJP) von Tomcat geliefert werden.

Einen Apache Webserver ( nicht zwingend ) und einen Tomcatserver, MySQL Datenbank und Eclipse. Ich benutze zwar den Wampserver ( integriert mit Apache MYSQL DB und PHP) habe aber trotzdem einen seperaten Apache 2.2 installiert. Damit Apache und Tomcat miteinander kommunizieren können, muß das Modul mod_jk.so und eine  workers.propertie in Apache integriert werden sowie in die httpd.conf vom Apache folgender Code integriert werden.

Das mod_jk  ist ein  Tomcat-Apache-Plug-in, dass die Kommunikation zwischen Tomcat und Apache behandelt.

Hier kannst Du die aktuellste Form des Verbindungsmodul  mod_jk.so herunter laden ( in meinem Beispiel Apache 2.2 ) und dieses in Apache/module kopieren:

tomcat-connectors-1.2.40-windows-i386-httpd-2.2.x

Um mit einer Datenbank Verbindung auf zu nehmen brauchst Du noch folgendes Modul. Diese solltest Du in den Tomcatordner „tomcat/lib“ koperen sowie in Eclipse , indem du mit der rechten Maustaste in dein Web Projekt klickst – dann Properties und Java Build Path:

mysql-connector-java-5.1.21

 

Properties eclipse

 

#Testumgebung : httpd alt mit Eclipse 3.1 und Tomcat 5.5
# Mod_jk settings
#JkWorkersFile „conf/workers.properties“
JkLogFile „logs/mod_jk.log“JkLogLevel errorJkMount /jsp-examples default
JkMount /jsp-examples/* default
JkMount /ordner der Daten default
JkMount /ordner/* default
JkMount /servlets-examples default
JkMount /servlets-examples/* default
JkMount /Tomcat default
JkMount /Tomcat/* default

 

Wenn Tomcat mit einem beliebigen Web-Server zusammenarbeitet, muss ein „Agent“ sich in dem Web-Server befinden um Servlet-Anfragen zu beantworten und zu senden. Dies ist die Web-Server-Plug-in mod_jk.  das in den Web-Server integriert werden muss.  Ein Arbeiter ( worker ) ist ein Tomcat-Instanz, die Servlet-Anfragen aus dem Web-Server bekommt und diese beanwortet.

Die Datei workers.properties muß in den Conf Ordner von Apache.  Zudem muß noch eine Modul ( mod_jk.so ) in den Modulordner des Apache Webserver.Die Datei workers.properties ist wie folgt aufgebaut:

 

workers.tomcat_home=C:Tomcat55
workers.java_home=$JAVA_HOME
ps=/
worker.list=defaultworker.default.port=8009
worker.default.host=localhost
worker.default.type=ajp13
worker.default.lbfactor=1

 

Aktuell habe ich meine Testumgebung mit Tomcat 9.0, Apache 2.2 und Eclipse Neon ausgestattet. In diesem Fall sieht die

workers.properties wie folgt aus :

 

workers.tomcat_home=C:Tomcat9
workers.java_home=$JAVA_HOME
worker.list=jk-status
worker.jk-status.type=status
worker.jk-status.read_only=trueworker.list=jk-manager
worker.list=worker1
worker.jk-manager.type=statusworker.list=balancer
worker.balancer.type=lb
worker.balancer.max_reply_timeouts=10worker.balancer.balance_workers=worker1
worker.worker1.reference=worker.template
worker.worker1.host=localhost
worker.worker1.port=8009
worker.worker1.activation=A
worker.template.type=ajp13
worker.template.socket_keepalive=true
worker.template.connection_pool_minsize=0
worker.template.connection_pool_timeout=600
worker.template.reply_timeout=300000
worker.template.recovery_options=3
Die httpd.conf :#
LoadModule jk_module modules/mod_jk.so # Mod_jk settings
#JkWorkersFile „conf/workers.properties“
JkLogFile „logs/mod_jk.log“# JkLogLevel errorJkMount /jsp-examples worker1
JkMount /jsp-examples/* worker1JkMount /servlets-examples worker1
JkMount /servlets-examples/* worker1
JkMount /Webb worker1
JkMount /Webb/* worker1

 

2. In Eclipse werden dann die Java Klassen und Beans programmiert.

  1. Profildaten.java :Das ersten Bean ist eine Zuordnung zur Datenbank. Entsprechend der Anzahl der Attribute oder Spalten in der Datenbank werden Properties erstellt. Die Klasse Profildaten.java ist zu diesem Zweck erstellt worden. Die Methoden sind sogenannte Setter und Getter Methoden.
  2. MysqlConnect.java : Natürlich mußt Du eine Verbindung zur Datenbank erstellen. Das wird in der zweiten Bean vorgenommen. Da ich vorwiegend mit MYSQL arbeite, ist der Name MsqlConnect.java gewählt.Der Vorteil dieser Variante: wenn Du viele Bean sschreibst, brauchst Du nur auf diesen Connect verweisen.
  3. InitHaushalt :In der Bean laufen die eigentlichen Datenbankabfragen ab. Ich habe diese deshalb InitHaushalt.java genannt. Und schließlich wird die Berechnungroutine in eine eigene Bean gepackt-
  4. Berechnen.java. Alle Beans mit Quellcode kannst Du dir anschauen. Ich verwende Eclipse 3.1 mit dem notwendigen Plugin von Tomcat 5.5. Dieses Plugin „com.sysdeo.eclipse.tomcat_.3.1.0“ muß in den Ordner Eclipse/plugins kopiert werden. Ansonsten funktioniert das Zusammenspiel mit Tomcat nicht. Außerdem müssen noch die Umgebungsvariablen angepasst werden. In Arbeitsplatz- Umgebungsvariablen usw. Im Eclipse SDK sollten dann noch andere Einstellungen vorgenommen werden.wie z.B. Windows-Preferences- Benutzervorgaben- Tomcat Version …. Zielpfad usw. Wenn ein neues Tomcat Projekt erstellt wird- sollten dann im Projekt in „Jave Erstellungpfad“-Bibliotheken- eventuell JARs hinzugefügt werden.

 

1. Profildaten.java;

package ICM_Haushalt;

/**
* @author Günther
*
*/
public class Profildaten {
public String Geraetebezeichnung = „“;
public int Haushalt1 = 0;
public int Haushalt2 = 0;
public int Haushalt3 = 0;
public int Haushalt4 = 0;
public int GeraeteID = 0;
public int getGeraeteID() {
return GeraeteID;

}
public void setGeraeteID(int geraeteID) {
GeraeteID = geraeteID;

}
public String getGeraetebezeichnung() {
return Geraetebezeichnung;

}
public void setGeraetebezeichnung(String geraetebezeichnung) {
Geraetebezeichnung = geraetebezeichnung;

}

public int getHaushalt1() {
return Haushalt1;

}
public void setHaushalt1(int haushalt1) {
Haushalt1 = haushalt1;

}
public int getHaushalt2() {
return Haushalt2;

}
public void setHaushalt2(int haushalt2) {
Haushalt2 = haushalt2;

}
public int getHaushalt3() {
return Haushalt3;

}

public void setHaushalt3(int haushalt3) {
Haushalt3 = haushalt3;
}

public int getHaushalt4() {
return Haushalt4;
}

public void setHaushalt4(int haushalt4) {
Haushalt4 = haushalt4;
}
}

 

Damit Eclipse auf die DB zugreifen kann, muß ebenfalls ein Modul für den Zugriff auf die Datenbank( MySQL )integriert werden (org.gjt.mm.mysql.Driver).

Für dieses Projekt reicht eine DB und eine  Tabelle aus, es sind die Daten, die in der InitHaushalt.java abgefragt werden:

Beispieldatenbank

2. MysqlConnect.java;

package ICM_Haushalt;
import java.sql.*;
import java.util.*;

/**
* @author guenther
*
*/
public class mysqlConnect {
static String driver = „org.gjt.mm.mysql.Driver“;
static String url = „jdbc:mysql://localhost:3306/haushalt“;
static String user = „guenther“;
static String password = „passwort“;
static
{
try
{
Class.forName(driver);
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
}
public static Connection getConnection() throws SQLException
{
Connection connection = DriverManager.getConnection (url,user,password);
return connection;
}
}

 

anzeigeindexdatei eclipse

3. InitHaushalt.java;

package ICM_Haushalt;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Vector;
import javax.servlet.http.*;

/**
* @author guenther
*

*/
public class InitHaushalt {

private Vector hausdaten = new Vector();
// Klasse checkparameter entnommen
//neues Objekt berechnen erstellen mit dem Namen myBerechner

private berechnen myBerechner = new berechnen();

public void funktionberechnen (HttpServletRequest request)
{
myBerechner.funktionberechnen(request, hausdaten);
}
public void getAllHaushalt()throws Exception{
Connection cn = mysqlConnect.getConnection();
try
{
hausdaten = new Vector();
Statement statement = cn.createStatement();
String query = „Select * from haushalt“;
ResultSet result = statement.executeQuery(query);
while(result.next())
{
Profildaten tempart = new Profildaten();
tempart.setGeraetebezeichnung(result.getString(„NameGeraet“));
tempart.setGeraeteID(Integer.parseInt(result.getString(„id“)));
tempart.setHaushalt1(Integer.parseInt(result.getString(„Nam_1P“)));
tempart.setHaushalt2(Integer.parseInt(result.getString(„Nam_2P“)));
tempart.setHaushalt3(Integer.parseInt(result.getString(„Nam_3P“)));
tempart.setHaushalt4(Integer.parseInt(result.getString(„Nam_4P“)));
getHausdaten().add(tempart);
}
//return ;
}
finally
{
cn.close();
}
}
/**
*
*/
public Vector getHausdaten() {
return hausdaten;
}

public void setHausdaten(Vector hausdaten) {
this.hausdaten = hausdaten;
}

public berechnen getMyBerechner() {
return myBerechner;
}

public void setMyBerechner(berechnen myBerechner) {
this.myBerechner = myBerechner;
}
}

So sieht das Ergebnis  im  Applikationserver Tomcat aus, wenn über den Webbrowser die Seite aufgerufen wird.

tomcatbrowseranzeige

4. Berechnen.java;

package ICM_Haushalt;

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

/**
* @author Günther
*

*/
public class berechnen {

public int Ergebniss = 0;

public int getErgebniss() {
return Ergebniss;
}

public void setErgebniss(int ergebniss) {
Ergebniss = ergebniss;
}
public void funktionberechnen(HttpServletRequest request,Vector hausdaten){
Ergebniss = 0;
int radio = 0;
//HTTP Servletanfrage Haushalt ist nicht null
//Response ist HTTP Antwort
if(request.getParameter(„Haushalt“)!= null)
{
radio = Integer.parseInt(request.getParameter(„Haushalt“));
for(int i=0;i <hausdaten.size();i++)
{ //Klasse Profildaten und Vektor hausdaten werden hochgezählt
//bis daten im Vektor auf Null gesetzt sind
Profildaten tempGeraet = (Profildaten)hausdaten.get(i);

if(request.getParameter(„“+tempGeraet.getGeraeteID())!=null)
{
switch(radio)
{
case 1: Ergebniss+=tempGeraet.getHaushalt1();break;
case 2: Ergebniss+=tempGeraet.getHaushalt2();break;
case 3: Ergebniss+=tempGeraet.getHaushalt3();break;
case 4: Ergebniss+=tempGeraet.getHaushalt4();break;
}
}
}
}
}
}

So sieht das Ergebnis aus, wenn der Webserver und der Applikationserver zusammen arbeiten. Der Webserver gibt die JSP weiter an Tomcat und der beantwortet diese indem er an den Webserver zurückgibt.

webbrowseranzeige

Ausgabe im Tomcat mit index.jsp

 

<%@ page language=“java“ contentType=“text/html; charset=ISO-8859-1″
pageEncoding=“ISO-8859-1″%>
<!DOCTYPE html PUBLIC „-//W3C//DTD HTML 4.01 Transitional//EN“ „http://www.w3.org/TR/html4/loose.dtd“>
<html>
<head>
<meta http-equiv=“Content-Type“ content=“text/html; charset=ISO-8859-1″>
<title>Insert title here</title>
</head>
<body>
<!– Die Direktive “ page import“ gibt an welche Klassen durch die jsp importiert werden sollen –>
<%@page import=“java.sql.*, IRM_Haushalt.*, java.util.*“ %><!– Die JSP-Aktion “ jsp:useBean“ macht in der JSP eine JavaBean-Instanz verfügbar,
die über einen EL-Ausdruck oder über ein Scriptlet verwendet werden kann:
„id:“ Gibt den Namen der Bean an. Der Name muss ein gültiger Java-Bezeichnername sein,
die Aktion führt zu einer lokalen Variablen im Servlet, auf die ein Scriptlet zugreifen kann.
class: Identifiziert mit dem voll qualifizierten Klassennamen die JavaBean.
class: ist die zu instanziierte Klasse–>
<jsp:useBean id=“GPH“ scope=“session“
class=“IRM_Haushalt.InitHaushalt“ /><%GPH.getAllHaushalt();%><HTML>
<link rel=“stylesheet“ href=“css/screen.css“ media=“screen“ type=“text/css“ />
<link rel=“stylesheet“ href=“css/Nav.css“ media=“screen“ type=“text/css“ />
<link rel=“stylesheet“ href=“css/radio.css“ media=“screen“ type=“text/css“ /><BODY>
<div id=“cbox“><h1 class=“c3″>Profilrechner</h1>
</div>
<div id=“cbox“><td class=“txt1″>Suchen Sie den effektivsten Verbrauch in KWh in meiner Datenbank.</td>
</div>
<!–BEGINN–><form method=“post“ action=“ergebniss.jsp“>
<div class=“radio“>
<td><input type=“submit“ name=““ value=“Berechnen“>
<table><tr>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td><input type=“radio“ name=“Haushalt“ value=“1″></td>
<td><input type=“radio“ name=“Haushalt“ value=“2″></td>
<td><input type=“radio“ name=“Haushalt“ value=“3″></td>
<td><input type=“radio“ name=“Haushalt“ value=“4″></td>
<td>&nbsp;</td>
</tr>
<tr>
<td width=“32″>&nbsp;</td><td width=“222″><div class =“go2″>
<div id=“cbox“><a>Geraeteliste</a></td></div>

<td width=“114″><div class =“go2″>
<div id=“cbox“>1.Pers</td>
<td width=“114″><div class =“go2″>
<div id=“cbox“><a>2.Pers</td>
<td width=“114″><div class =“go2″>
<div id=“cbox“><a>3.Pers</td>
<td width=“114″><div class =“go2″>
<div id=“cbox“><a>4.Pers</a></td>
<td width=“116″>&nbsp;</td>
</tr>
</div>

<%GPH.getHausdaten().size();%>
<%for (int i = 0; i < GPH.getHausdaten().size(); i++)
{
Profildaten tempGeraet =
(Profildaten) GPH.getHausdaten().get (i);
%>
<tr><td><input type=“checkbox“ name=“<%=tempGeraet.getGeraeteID()%>“ value=“Type1″>
<td><div class =“go3″>
<div id=“rand“><%=tempGeraet.getGeraetebezeichnung()%></td>
<td><div class =“go3″>
<div id=“rand“><%=tempGeraet.getHaushalt1()%></td>
<td><div class =“go3″>
<div id=“rand“><%=tempGeraet.getHaushalt2()%></td>
<td><div class =“go3″>
<div id=“rand“><%=tempGeraet.getHaushalt3()%></td>
<td><div class =“go3″>
<div id=“rand“><%=tempGeraet.getHaushalt4()%></td>

</tr>
<%}%>
</table>
<td><input type=“submit“ name=““ value=“Berechnen“>
</form>
</div>
<div class=“story“>
<h3>Verschiedenes</h3>
<p>&nbsp;
</p>
<p>&nbsp;
</p>
</div>
<div class=“story“>
<h3>Beispiel Code JSP </h3>
<p>&nbsp;
</p>
<p>&nbsp;
</p>
</div>
</div>
<!–end content –>
<div id=“siteInfo“>
</div>
<br>
<!–Beispieldaten –>

<!– Ende –></body>
</html>


Did you find apk for android? You can find new Free Android Games and apps.

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...
verlinken
Url zu diesem Artikel: