Die Seiten "gewusst wie" geben Implemenmtierungsbeispiele für
verschiedene Aufgaben in unterschiedlichen Technoligien. Die 
Beispiele sind zumeist wenig dokumentiert. Es soll hier kurz und
knapp die (eine) Umsetzung des Problems nahegelegt werden. Nähere 
Informationen zu den verwendeten Codes finden sich im Netz :)

The "JDK" is the Java Development Kit. I.e., the JDK is bundle of software 
that you can use to develop Java based software. The "JRE" is the Java Runtime 
Environment. I.e., the JRE is an implementation of the Java Virtual Machine 
which actually executes Java programs. 
 
Typically, each JDK contains one (or more) JRE's along with the various 
development tools like the Java source compilers, bundling and deployment 
tools, debuggers, development libraries, etc. 
 
 
 
Yes JRE is Java Run Time Environment. The java programming language adds the 
portability by converting the source code to byte code version which can be 
interpreted by the JRE and gets converted to the platform specific executable 
ones. Thus for different platforms one has corresponding implementation of 
JRE. But JRE has to meet the specification JVM (Java Virtual Machine) Concept 
that serves as a link between the Java libraries and the platform specific 
implementation of JRE. Thus JVM helps in the abstraction of inner implementation 
from the programmers who make use of libraries for their programmes.
The JDK(Java Developmental Tool kit) comes along with java libraries 
and JVM embedded in it. Apart from these it comes along with the utility 
tools for byte code compilation "javac", Executing the byte codes through 
java programmes through "java" and many more utilities found in the binary 
directory of java. Speaking practically JDK is essential for developers, 
which comes along with library packages to develop Software programmes. 
While JRE is minimal set of programmes which executes the java class 
files developed by the software developers. 
 
 
 
 

Java / Java Server Fces/ Java Server Pages

1--> Java, Browser und files aus Java oeffnen

2--> Castings

3--> [Datum formatieren

4--> Variablen aus dem Facescontext auslesen

5--> Hashmap mit Iterator durchlaufen und keys und values listen

6--> Hashmap, simples Beispiel

7--> instanceOf ... kurzes Beispiel zur Verwendung

8--> interface implementieren:

9--> int auf integer casten

10--> Quellcode aus Javaklassen generieren, class-files in java-files

11--> Java, String nach Sonderzeichen splitten, Sonderzeichen escapen

12--> Java, Propertyfiles laden

13--> Java Prüfen ob ein Verzeichnis existiert

14--> Java, Datei(en) löschen

15--> Java, InetAddress: IP und Hostname ermitteln

16--> Java Log4J einfach

17--> LRU-Cache in Java

18--> Java, Maven: Dependencies in POM

19--> Java Maven abhängiges Projekt compipieren und als zip bereitstellen, maven-assembly-plugin

20--> Java, Maven: Ressourcen automatisch zu Projekten hinzufügen

21--> Java Server programmieren, java.net.ServerSocket

22--> Java, Beispiel für SimpleDateFormat

23--> Singeltons in Java

24--> Java, Xml via Jdom.saxbuilder appenden

25--> javascript, Elemente ein/ ausblenden

26--> Javascript, aus iframe heraus Text des Hauptframes ausblenden

27--> jsp, Ausgabe einer Arraylist aus Bean in jsp durch forEach - Tag

28--> jsp, Klassen in jsp-files importieren

29--> jsp, Requestparameter auswerten/ ausgeben

30--> jsp: hostname und ip

31--> JSP, Formularbutton mit Werten aus Messagefile beschriften

32--> JSP, Messagebundles

33--> voneinander abhängige selectboxen

34--> Map iterieren, Key Value Paare auslesen

35--> mehrere Servlets in einer Web Applikation handeln

36--> runden auf exakt 2 Nachkommastellen

37--> Variablen aus Sessionmap auslesen

38--> Sonderzeichen (ü,ä,ö,ß...) für propertyfiles messages.de / messages.en

39--> Switch / Case Anweisung

40--> typisiertes Array anhand der aktuellen belegung eines Typ-Properties sortieren

41--> Variablen-Initialisierung mit variabler sowie fest vorgeschriebener Reihenfolge

42--> Xml via JDom schreiben, einfaches Beispiel

43--> Namespace- Deklaration in XML einfügen, JDom

44--> XML-Datei schreiben mittels JDOM

Am Beispiel aus einer jsp:

<%@page import="java.awt.Desktop" %>
<%@page import="java.io.File" %>
<%@page import="java.io.IOException" %>
<%@page import="java.net.URI" %>
 
...
 
 
// ab java 6:
  try 
  { 
    Desktop.getDesktop().browse( new URI("http://www.schlumsch.eu/") ); 
    Desktop.getDesktop().open( new File("c:/1.pdf") ); 
  } 
  catch ( Exception /* IOException, URISyntaxException */ e ) 
  { 
    e.printStackTrace(); 
  }  
 
// vor java 6:
 
  String url = "http://www.google.de/"; 
  new ProcessBuilder( "rundll32", "url.dll,FileProtocolHandler", url ).start();
 



____________________________666Seitenanfang666_____________________________

INT TO STRING:
String requestIdString = 
Integer.toString(this.requestId);



Java - Converting int to string

String myString = Integer.toString(my int value)
*or*
String str = "" + i

 


Java - Converting String to int

int i = Integer.parseInt(str);
*or*
int i = Integer.valueOf(str).intValue();

 
 

*/double/**/ to String :/** *

String str = Double.toString(i);

 

*/long/**/ to String :/** *

String str = Long.toString(l);

 

 

*/float/**/ to String :/** *

String str = Float.toString(f);

 

 

*/String to double :/*

double d = Double.valueOf(str).doubleValue();

 

*/String to long :/** *

long l = Long.valueOf(str).longValue();

*or*

long l = Long.parseLong(str);

 

*/String to float :/** *

float f = Float.valueOf(str).floatValue();


*/decimal/**/ to binary :/** *

int i = 42;
String binstr = Integer.toBinaryString(i);


*/decimal/**/ to hexadecimal :/** *

int i = 42;
String hexstr = Integer.toString(i, 16);
*or*
String hexstr = Integer.toHexString(i);
*or** (with leading zeroes and uppercase)*



*/hexadecimal/**/ (String) to integer :/** *

int i = Integer.valueOf("B8DA3", 16).intValue();
*or*
int i = Integer.parseInt("B8DA3", 16);    



*/ASCII code to String/** *

int i = 64;
String aChar = new Character((char)i).toString();


*/integer/**/ to ASCII code (byte)/** *

char c = 'A';
int i = (int) c; // i will have the value 65 decimal



*/integer/**/ to boolean/** *
b = (i != 0);

 

*/boolean/**/ to integer/** *
i = (b)?1:0;




____________________________666Seitenanfang666_____________________________

public String getModifiedStartTime
(Date oStartTime) {
String result = "";
java.text.SimpleDateFormat sdfTo = new 
java.text.SimpleDateFormat("HH:mm");
result = sdfTo.format(oStartTime);
return result;
}






____________________________666Seitenanfang666_____________________________

BEAN:
public String testmethod() {

        String a = "";
        ExternalContext extCont =
        FacesContext.getCurrentInstance().getExternalContext();
        Object b = FacesContext.getCurrentInstance().getExternalContext()
                  .getRequestParameterMap().get("editId");
        String meineId =
        FacesContext.getCurrentInstance().getExternalContext()
                .getRequestParameterMap().get("editId").toString();
        System.out.println(meineId);
        return a;
    }


IN JSF:

<a4j:commandButton value="Testmethode(a)"
action="#{planingResults.testmethod}" style="width:170px;">
                  <f:param name="editId" id="editId"
value="uebergabewert in da hause"/>
</a4j:commandButton>




HINWEIS:
h:commandButton just not supports f:param. h:commandLink and any of
a4j:command supports.


____________________________666Seitenanfang666_____________________________

                Map<String, String> ding = new HashMap<String, String>();
                ding.put("Identifikator1", "Wert1");
                ding.put("Identifikator2", "Wert2");
                ding.put("Identifikator3", "Wert3");
                ding.put("Identifikator4", "Wert4");
                Set set = ding.entrySet(); 
                Iterator i = set.iterator(); 
                while(i.hasNext()) {
                        Map.Entry me = (Map.Entry)i.next();
                        System.out.print(me.getKey() + ": ");
                        System.out.println(me.getValue());
                        } 



____________________________666Seitenanfang666_____________________________

INHALT
	HashMap<String,Object> result = new HashMap<String, Object>();
	result.put("a", 1);
	result.put("b", true);
	result.put("c", "ddd");
	result.get("a");



____________________________666Seitenanfang666_____________________________

INHALT
	Object s = "Hello";
	if (s instanceof java.lang.String) {
	  
	} else if  (s instanceof java.lang.Integer) {
		 
	} else if  (s instanceof java.lang.Boolean) {
		 
	}
  }



____________________________666Seitenanfang666_____________________________

BEAN:


public class BigBean {
...
public DeathCertificateInterface getDeathCertificateInterface() {
return deathCertificate;
}
...
}

public class DeathCertificate implements DeathCertificateInterface{
...
public void addCauseOfDeath(boolean usePropertyfile, String causeOfDeath) {
...
}
...
}

public interface DeathCertificateInterface {
...
public void addCauseOfDeath(boolean useMessageInPropertyfiile, String
causeOfDeath);
....
}

In irgendeiner Javaklasse:

...
bigBean.getDeathCertificateInterface().addCauseOfDeath([parameters]));
...




____________________________666Seitenanfang666_____________________________

INHALT
        public int intToInteger(Integer i) {
                int result;
                result = i.intValue();
                return result;
        }
        
        public Integer integerToInt(int i) {
                Integer result;
                result = new Integer( i );
                return result;
        }



____________________________666Seitenanfang666_____________________________

Um aus kompilierten Java-Klassen (.class) den Quellcode zu generieren (.java)
kann man einen Java-Dekompilierer verwenden. Eine Freeware-Lösung findet sich 
beispielsweise unter 
http://java.decompiler.free.fr/?q=jdgui. Allerdings ist das dekompilieren immer ein
wenig mit Vorsicht zu geniessen. Bei mir hat der generierte Javacode an einigen Stellen
Fehler aufgewiesen. Vor allem beim Exceptionghandling der einzelnen Klassenmethoden
haben sich öfters Fehler eingeschlichen.

____________________________666Seitenanfang666_____________________________

 
 
String t1 = "tttt.ffff.zzz";
String[]t2 = t1.split("\.");
 



____________________________666Seitenanfang666_____________________________

Um Konfigurationsdaten der Applikation zu Verwalten bieten
sich Prpoertyfiles an. Diese haben den Vorteil, das man das
Verhalten der Applikation schnell und einfach durch die Einträge
eines solchen Propertyfiles, eines simplen Textfiles, steuern kann. 
Es ist somit nicht notwendig den Javacode anzupassen.
private static void testGetProperties() {
	java.util.Properties property = null;
	// Dateiname:
	String propFile = "properties.property";
	FileInputStream fis;
	try {
			fis = new FileInputStream(propFile);
			property =new Properties();
			property.load(fis);
			// getting file name from properties
			String wert = property.getProperty("ATTRIBUT1");
			String wert2 = property.getProperty("ATTRIBUT2");       
	} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
	} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
	}

}
 



____________________________666Seitenanfang666_____________________________

Eine Javaanwendung mit einem Aufrufparameter (ein Verzeichnisname) starten und
prüfen ob dieses Verzeichnis existiert.

		z.B. in der Main Methode der Application:
		...
         directory = new File(args[0]);
         if ( ! directory.exists() ) {
            System.out.println("Specified directory does not exist.");
            return;
         }


____________________________666Seitenanfang666_____________________________

Eine Datei via Java löschen:

import java.io.File;

public class Test {

  public static void main(String[] args) {
    File datei = new File("c:/bla.txt");
	// oder Dateiname aus den Aufrufparametern: File datei = new File(args[0]);
    if (datei.exists()) {
      datei.delete();
      System.out.println("Datei gelöscht!");
    }
  }
}


Alle Dateien mit einer spezifischen Dateiendung löschen:

import java.io.File;

public class Test {

  public static void main(String[] args) {
    // Verzeichnis der Dateien:
	File path = new File("C:/temp/");
    for (File file : path.listFiles()) {
	// Dateiendung zum Löschen:
      if (file.toString().endsWith(".txt")) {
        file.delete();
      }
    }
  }
}

____________________________666Seitenanfang666_____________________________

IP und Hostname ermitteln

package mypackage;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Machine implements ClientTreeNode 
{

  public String host        = null;

  private String ip = null;
  private String hostName = null;
  private String fullHostName = null;
  
  /** getter for ip */
  public String getIP(){
    if (host == null) return null;
    if (ip != null) return ip;
    calcHostIP();
    return ip;
  }
  
  /** getter for hostname  */
  public String getHostName(){
    if (host == null) return null;
    if (hostName != null) return hostName;
    calcHostIP();
    return hostName;
  }
  
  /** getter for hostname  */
  public String getFullHostName(){
    if (host == null) return null;
    if (fullHostName != null) return fullHostName;
    calcHostIP();
    return fullHostName;
  }
  
  /** getter for hostname  */
  public String getUniqueHostName(){
    if (getFullHostName() != null){
      return getFullHostName();
    }
    else{
      return getHostName();
    }
  }
  
  /** equals */
  @Override
  public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Machine)) return false;
    final Machine other = (Machine)obj;
    //compare the hostnames
    if (this.getFullHostName() != null && other.getFullHostName() != null){
      return this.getFullHostName().equals(other.getFullHostName());
    }
    if (this.getHostName() != null){
      return this.getHostName().equals(other.getHostName());
    }
    return false;
  }
  
  
  
  /** pattern for IP */
  private Pattern pattern_ip = Pattern.compile("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$");
  
  /** gets the ip */
  private void calcHostIP(){
    
    //no information -> nothing to do
    if (host == null) return;
    
    //parse host (it can be ip, hostname, or full qualified hostname
    host = host.trim();
    final Matcher m = pattern_ip.matcher(host);
    if (m.find()){
      //it is the ip
      ip = host;
    }
    else{
      //full qualified or not
      final int pos = host.indexOf('.');
      if (pos > 0){
        hostName = host.substring(0, pos);
        fullHostName = host;
      }
      else{
        hostName = host;
        fullHostName = null;
      }
    }
    
    //get hostname by ip
    if (ip != null && hostName == null){
      try {
        final InetAddress address = InetAddress.getByAddress(buildIPBytes(ip));
        if (address != null){
          ip = buildIP(address.getAddress());
          fullHostName = address.getCanonicalHostName();
          hostName = fullHostName;
          final int pos = hostName.indexOf('.');
          if (pos > 0){
            hostName = hostName.substring(0, pos);
          }
        }
      }
      catch (UnknownHostException e) {
        System.out.println("WARN: could not find address for "" + ip + ""!");
      } 
    }
    //get ip by hostname
    else if (hostName != null && ip == null){
      try {
        final InetAddress address = InetAddress.getByName(fullHostName != null ? fullHostName : hostName);
        if (address != null){
          ip = buildIP(address.getAddress());
          fullHostName = address.getCanonicalHostName();
          hostName = fullHostName;
          final int pos = host.indexOf('.');
          if (pos > 0){
            hostName = host.substring(0, pos);
          }
        }
      }
      catch (UnknownHostException e) {
        System.out.println("WARN: could not find address for "" + hostName + ""!");
      } 
    }
    
  }

  
  /**
   * builds the ip string
   * @param bytes
   * @return ip
   */
  private String buildIP(byte[] bytes){
    final StringBuilder sb = new StringBuilder();
    for (int i = 0; i < bytes.length; i++){
      if (i > 0) sb.append(".");
      sb.append(Integer.toString(bytes[i] > 0 ? bytes[i] : 256 + bytes[i]));
    }
    return sb.toString();
  }
  
  /**
   * builds the ip string
   * @param bytes
   * @return ip
   */
  private byte[] buildIPBytes(final String ip){
    final StringTokenizer st = new StringTokenizer(ip, ".", false);
    final byte[] bytes = new byte[4];
    bytes[0] = new Integer(st.nextToken()).byteValue();
    bytes[1] = new Integer(st.nextToken()).byteValue();
    bytes[2] = new Integer(st.nextToken()).byteValue();
    bytes[3] = new Integer(st.nextToken()).byteValue();
    return bytes;
  }
  
}


____________________________666Seitenanfang666_____________________________

Ein einfaches Beispiel zur Nutzung von Log4J (Logging)
Weitere Informationen findet man unter folgender url:

http://www.torsten-horn.de/techdocs/java-log4j.htm


import org.apache.log4j.*;
...
protected static Logger logger = Logger
.getLogger(meinKlassenname.class);
...
        public static void main(String[] args) {
                HTMLLayout layout = new HTMLLayout();
              //PatternLayout
              //HTMLLayout
              //XMLLayout
              //SimpleLayout
              FileAppender fileAppender;
                try {
                       
                        fileAppender = new FileAppender( layout, "logs/MeineLogDatei.log", true );
        // true = logfile wird appended
        // false = logfile wird neu geschrieben
                        logger.addAppender( fileAppender );
                        // ALL | DEBUG | INFO | WARN | ERROR | FATAL | OFF:
                      logger.setLevel( Level.WARN );
 
                          logger.debug( "Meine Debug-Meldung" );
                            logger.info(  "Meine Info-Meldung"  );
                            logger.warn(  "Meine Warn-Meldung"  );
                            logger.error( "Meine Error-Meldung" );
                     logger.fatal( "Meine Fatal-Meldung" );
...


____________________________666Seitenanfang666_____________________________

Caches dienen in der Informatik als Methode, Zugriffe auf bestimmte Daten zu beschleunigen, 
in dem diese vorgelagert/gepuffert werden. Sie sind in verschiedensten Bereichen zu finden, 
unter anderem auf Prozessoren, in Festplatten, aber auch in Technologien wie dem Web. 
Verschiedene Verdrängungsstrategien ermöglichen es, die beschränkte Kapazität eines Caches 
zu berücksichtigen, so dass nur wichtige Werte im Cache gelagert werden. Least Recently Used 
(LRU), ist eine solche Strategie, die häufig angewandt wird. Sie sortiert die Werte im Cache 
nach der letzten Nutzung. Wird auf ein Element über einen längeren Zeitraum nicht mehr 
zugegriffen, so wird es aus dem Cache verdrängt.

In Java lässt sich ein solcher LRU-Cache besonders einfach implementieren, da die Klasse 
java.util.LinkedHashMap bereits die wesentlichen Mechanismen unterstützt. Eine HashMap ist 
eine Hash-Tabelle, die Zugriffe auf Werte über ihre Schlüssel regelt. Zusätzlich verkettet 
die LinkedHashMap aber die Werte noch in einer Liste, womit auch eine Traversierung in 
Einfügereihenfolge ermöglicht wird. Mithilfe eines Flags in einem der Konstruktoren kann 
dieses Verhalten geändert werden, so dass bei jedem Zugriff das angesprochene Element neu 
in diese Liste eingereiht wird. Damit verwaltet die Liste die Zugriffe und ist Basis für 
die LRU-Strategie.

Die Methode removeEldestEntry() der LinkedHashMap wird bei jedem Schreibezugriff auf die 
Map, also nach Einfügeoperationen über put() oder putAll() automatisch aufgerufen und bietet 
die Möglichkeit, durch Überschreiben der Methode die Verdrängungsstrategie zu implementieren. 
Diese Methode gibt ein boolean zurück, ob der älteste Eintrag gelöscht werden soll. Es ist 
auch möglich, innerhalb der Methode selbst die Liste zu manipulieren, dann sollte 
allerdings die Methode immer false zurückgeben. Für den LRU-Cache reicht es aus, die Größe 
der Map mit dem gewünschten Maximum zu vergleichen. Ist der Inhalt der Map zu groß, so 
soll das letzte Element gelöscht werden.

Im Folgenden nun der Code dazu. Zu beachten ist noch, dass es sich um eine threadsichere 
Klasse handelt, da die Map explizit synchronisiert wird. 
INHALT
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A thread-safe LRU cache implementation based on internal LinkedHashMap.
 *
 * @author Benjamin Erb
 *
 * @param <K> Entry Key Type
 * @param <V> Entry Value Type
 */
public class LRUCache<K, V>
{
	public static final int DEFAULT_MAX_SIZE = 1000;

	private final Map<K, V> internalMap;

	public LRUCache()
	{
		this(DEFAULT_MAX_SIZE);
	}

	public LRUCache(final int maxSize)
	{
		this.internalMap = (Map<K, V>) Collections.synchronizedMap(new LinkedHashMap<K, V>(maxSize + 1, .75F, true)
		{
			private static final long serialVersionUID = 5369285290965670135L;

			@Override
			protected boolean removeEldestEntry(Map.Entry<K, V> eldest)
			{
				return size() > maxSize;
			}
		});
	}

	public V put(K key, V value)
	{
		return internalMap.put(key, value);
	}

	public V get(K key)
	{
		return internalMap.get(key);
	}

}



____________________________666Seitenanfang666_____________________________

Denpendencies in der Pom deklarieren:

JSTL Dependency
Taglibs Dependency 

<dependency>
POM:
...
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <scope>runtime</scope>
  <version>1.1.2</version>
</dependency>
 
<dependency>
  <groupId>taglibs</groupId>
  <artifactId>standard</artifactId>
  <scope>runtime</scope>
  <version>1.1.2</version>
</dependency>
...


____________________________666Seitenanfang666_____________________________

Maven: Alle Bibliotheken eines projektes in zip packen.

Ausgangspunkt sind 2 Maven Projekte, wobei das Projekt 1 
von Projekt 2 verwendet wird. Somit ist in die pom.xml 
von Projekt 2 das Projekt 1 als Dependency anzugeben.

Nun soll Projekt 2 compiliert werden und alle benötigten Bibliotheken in einem
Archiv zur Verfügung stehen. Dieses Archiv soll natürlich ebenfalls die Bibliotheken
von Projekt 1 beinhalten, da ja Projekt 1 von Projekt 2 verwendet wird.

Pom.xml Projekt 1:
----------------------
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>project1</groupId>
        <artifactId>project1</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>project1Name</name>
        <description>project1Desc</description>
 
        <dependencies>
.....
</project>


Pom Projekt 2:
--------------------
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>project2</groupId>
        <artifactId>project2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>project2 name</name>
        <description>project2 desc</description>
        <dependencies>
                <dependency>
                        <groupId>project1</groupId>
                        <artifactId>project1</artifactId>
                        <version>0.0.1-SNAPSHOT</version>
                </dependency>
...
</project>



Um die Abhängigkeiten der Projekte zu erreichen wird die
Pom des Projektes 2 wie folgt erweitert:

Erweiterung von Pom Projekt 2:
-------------------------------

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>project2</groupId>
        <artifactId>project2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>project2 name</name>
        <description>project2 desc</description>
        <dependencies>
                <dependency>
                        <groupId>project1</groupId>
                        <artifactId>project1</artifactId>
                        <version>0.0.1-SNAPSHOT</version>
                        <!-- <scope>compile</scope> -->
                </dependency>
                <dependency>
                  <groupId>log4j</groupId>
                  <artifactId>log4j</artifactId>
                  <version>1.2.13</version>
                </dependency>          
        </dependencies>
        <build>
                <plugins>
                        <plugin>
                                <groupId>org.apache.maven.plugins</groupId>
                                <artifactId>maven-compiler-plugin</artifactId>
                                <configuration>
                                        <source>1.5</source>
                                        <target>1.5</target>
                                </configuration>
                        </plugin>
                        <plugin>
                                <artifactId>maven-assembly-plugin</artifactId>
                                <configuration>
                                        <descriptors>
                                                <descriptor>
                                                        src/main/assembly/dep.xml
                             </descriptor>
                                        </descriptors>
                                </configuration>
                                <executions>
                                        <execution>
                                                <id>make-assembly</id>
                                                <phase>package</phase>
                                                <goals>
                                                        <goal>attached</goal>
                                                </goals>
                                        </execution>
                                </executions>
                        </plugin>
                </plugins>
        </build>
</project>


Die Konfiguration des zu erstellenden Archivs mit allen Bibliotheken erfolgt 
in dep.xml, welche in der oben angeführten POM eingetragen ist:

src/main/assembly/dep.xml:
----------------------
<?xml version="1.0" encoding="UTF-8"?>
<assembly>
        <id>install</id>
        <formats>
                <format>zip</format>
        </formats>
        <includeBaseDirectory>false</includeBaseDirectory>
        <dependencySets>
                <dependencySet>
                        <outputDirectory>lib</outputDirectory>
                        <unpack>false</unpack>
                        <scope>runtime</scope>
                </dependencySet>
        </dependencySets>
</assembly>
</project>



____________________________666Seitenanfang666_____________________________

Ressourcen definieren, die beim Kompilieren automaisch mit
in das Projekt (jar, whatever) eingefügt werden sollen. Hierfür
muss lediglich in der POM ein entsprechender eintrag unter ressources
getätigt werden.
POM:
...	
<resources>
	<resource>
		<directory>src/main/java</directory>
		<filtering>true</filtering>
	</resource>
	<resource>
			<directory>src/main/resources</directory>
			<filtering>true</filtering>
		</resource>
	<resource>
			<directory>src/main/messages</directory>
			<filtering>true</filtering>
	</resource> 
</resources>
...


____________________________666Seitenanfang666_____________________________

Im Eclipse: neues Java-Projekt anlegen und dann unter „src“ die Server.java kopieren.
Anschließend einfach aus dem Eclipse als Java-Anwendung starten.
Den Port kann man im Quelltext konfigurieren.
SERVER.JAVA:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server
{
  private static int port = 4444;

  public static void main(String[] args) throws Exception
  {
    ServerSocket serverSocket = null;
    try
    {
      System.out.println("Listening on port " + port + " ...");
      serverSocket = new ServerSocket(port);
    }
    catch (IOException ex)
    {
      System.err.println("Could not listen on port: " + port + ": " + ex);
      System.exit(1);
    }

    Socket clientSocket = null;
    try
    {
      clientSocket = serverSocket.accept();
      System.out.println("Accepted connection...");
    }
    catch (IOException e)
    {
      System.err.println("Accept failed.");
      System.exit(1);
    }

    PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
    BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket
        .getInputStream()));
    String inputLine;

    while ((inputLine = in.readLine()) != null)
    {
      System.out.println(inputLine);
    }

    System.out.println("Connection closed");

    out.close();
    in.close();
    clientSocket.close();
    serverSocket.close();
  }

}



____________________________666Seitenanfang666_____________________________

Schnell & einfach Datum mit SimpleDateFormat erzeugen
				SimpleDateFormat formatter = new SimpleDateFormat ("dd.MM.yyyy'_'HH:mm:ss'_(Tag.Monat.Jahr_h:min:sec)'");
                Date currentTime = new Date(); 
                String xxx = formatter.format(currentTime).toString();


____________________________666Seitenanfang666_____________________________

Umsetzung des DesignPatterns Singelton in Java.
/**

*

 */

package de.schlumsch.Neger.Cardset;

 

/**

* @author schlumsch4

*

 *         SINGELTON

*/

public class Cardset {

                private static Cardset instance = null;

 

                /**

                * Konstruktor, privat da er nciht von aussen aufgerufen werden darf!

                */

                private Cardset() {

 

                               // do something

 

                }

 

                /**

                * "Aufruf" des Singeltons von aussen

                *

                 * @return

                */

                public static Cardset getInstance() {

 

                               if (instance == null) {

 

                                               instance = new Cardset();

 

                               }

 

                               return instance;

 

                }

 

}


____________________________666Seitenanfang666_____________________________

INHALT

                
                
                /**
                * Test append xml file
                * @throws Exception
                */
            public static void testAppend() throws Exception {
                SAXBuilder builder = new SAXBuilder();
                Document doc = builder.build("./src/test/java/testJdom.xml");
                StringBuffer output = new StringBuffer();
                // 2 Werte fuer ein Element setzen:
                 Element newElementElement1 = new Element("documentId");
                 newElementElement1.addContent("dvfsdsdc");
                 Element newElementElement2 = new Element("Adresszeile3");
                 newElementElement2.addContent("sdfsdffwffwef");         
                 // beide Werte in das neue Element:
                 Element e = new Element("ElementName");
                 e.addContent(newElementElement1);
                 e.addContent(newElementElement2);
                 // neues Element in das Rootelement einfuegen:
                doc.getRootElement().addContent(e);
                
                Format format = Format.getPrettyFormat();
                format.setEncoding("iso-8859-1");
                XMLOutputter xmlOut = new XMLOutputter(format); 
                xmlOut.output(doc, new FileOutputStream("./src/test/java/testJdom.xml"));
//              
//
//				Elemente des XML nacheinander durchgehen:
//
//              Iterator itr = doc.getRootElement().getChildren().iterator();
//              
//              Element elem = null;
//              List<Element> myChilds = null;
//              while (itr.hasNext()) {
//                  elem = (Element) itr.next();
//                  myChilds = elem.getChildren();            
//                  String v = elem.getChildText("documentId");
//                  String w = elem.getChildText("Adresszeile3");
//              }
            }



____________________________666Seitenanfang666_____________________________

Javascriptfunktion:
 
function setTableVisibilities(){
        document.getElementById("meineid").style.display='block';
        // oder
        document.getElementById("meineid").style.display='none';
}
 
 
In der Seite (Html, php, ...)
<table id="meineid" ......>



____________________________666Seitenanfang666_____________________________

Im der HauptJsp einen link auf eine Datei 
close.jsp einbauen.
(Sollte dies, wie bei mir, nicht funktionieren 
kann man einfach eine
jsp zum forwarden dazwischenhängen, welche dann 
die close.jsp
anzeigt.


<b>Hauptjsp</b>
...
<table id="meineId" .....>
...
 
 
<b>closeForward.jsp:</b>
<html>
  <head>
    <title>Finishing AdHoc Editing</title>
 
  </head>
                                                                                                                                        
  <body bgcolor="#676767">
        <jsp:forward page="close.jsp"/> 
 
  </body>
</html>
 
 
<b>close.jsp:</b>
 
function doit()
{
top.document.getElementById("meineId").style.display='none';
}
</script>
  </head>                                                                                                                                       
  <body onload="doit()" bgcolor="#676767">
...
 



____________________________666Seitenanfang666_____________________________

JSP:
 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 
 
<html>
<body>
<h1>Tests</h1>
<h2>jstl & select & daten aus bean</h2>
    <%
    packagename.TestBean tb = new packagename.TestBean();
      out.println( "<p>" + tb.getTestString() + "</p>" );
    %>
 
 
<jsp:useBean id = "testBean" class= "packagename.TestBean"/>
<jsp:getProperty name = "testBean" property = "testStringFuerGetProperty"/>
<jsp:getProperty name = "testBean" property = "documentIdentifiers"/>
 
 
 
      <c:forEach items="${testBean.documentIdentifiers}" var="current">
        <tr>
          <td><c:out value="dferwerq + ${current}" /><td>
 
        </tr>
      </c:forEach>
 
</body>
</html>
 
 
BEAN:
 
public class TestBean extends HttpServlet {
        private static final long serialVersionUID = 1L;
        private ArrayList<String> documentIdentifiers = setupDocumentIdentifiers();
 
...
 
 
        
        private ArrayList<String> setupDocumentIdentifiers() {
                ArrayList<String> tmpList = new ArrayList<String>();
                tmpList.add("a");
                tmpList.add("b");
                tmpList.add("c");
                tmpList.add("d");
                tmpList.add("e");               
                
                return tmpList;
        }
 
        public ArrayList<String> getDocumentIdentifiers() {
                return documentIdentifiers;
        }
 
        public void setDocumentIdentifiers(ArrayList<String> documentIdentifiers) {
                this.documentIdentifiers = documentIdentifiers;
        }




____________________________666Seitenanfang666_____________________________

<%@page import="packageName.klassenname"%> // Bsp1: eigene Klasse
<%@page import="packageName.klassenname2"%>    // Bsp2: eigene Klasse
<%@page import="java.util.ArrayList"%>  // Bsp3: java Klasse



____________________________666Seitenanfang666_____________________________

Requestparameter (Aufrufparameter) einer jsp anzeigen und auswerten:

JSP
 
...
<% boolean withRequestParameter = true; %>
...



<%
if (request.getParameter("parametername").equals("")) {
        withRequestParameter = false;
        out.println("kein perameter angegeben");
        %>
		HTML-Code
        <%
} else {
        out.println("perameter angegeben");
        %>
		HMPL-Code    
        <%
}
%>





____________________________666Seitenanfang666_____________________________

  <%
 
  String host_name =request.getRemoteHost(); //ip
  String hostName=request.getServerName();   //hostname
 
  %>
  getRemoteHost: <%= host_name%><br>getServerName: <%= hostName%>



____________________________666Seitenanfang666_____________________________

Buttons in Formularen mit Werten aus einem Messagefile beschriften.

Hierzu muss ein Messages-File im Projekt angelegt werden.
(Howto: siehe entsprechendes Topic)
Im Beispiel würde das Messagefile wie folgt aussehen:
	...
	START_TITLE=MeinTitel
	SUBMIT_BUTTON_CAPTION=MeinSubmitButton
	...
	
Daraufhin kann aus der jsp heraus wie folgt auf die Werte zugegriffen werden:
ANY.JSP:


<%@ taglib uri='http://java.sun.com/jstl/fmt' prefix='fmt'%>
....
 
<fmt:setLocale value='de'/>
<fmt:setBundle basename='messages'/>
...
...
<html>
  <head>
    <title>
         <fmt:message key='START_TITLE'/>
    </title>
...
...
<input type="submit" id="save" name="_eventId_save" value="<fmt:message key="SUBMIT_BUTTON_CAPTION"/>"
...







____________________________666Seitenanfang666_____________________________

Datei messages_de.properties / messages_en.properties im Projektordner src/main/java ablegen
Bzw. da wo die java-sourcen liegen.

HINWEIS: Legt man die Dateien in einem seperaten Ordner ab, bsp. src/main/java/messages muss
                  bei Verwendung von MAVEN folgender Eintrag in die POM getan werden


<resources>
	...
	<resource>
		<directory>src/main/messages</directory>
		<filtering>true</filtering>
	</resource> 
	...
</resources>


Die Datei in folgender Art aufbauen:
	  KEY=VALUE

Beispiel eines Eintrages:	  
      MYMESSAGE=Message aus Messages_de-properties

	  
Einbindung in die jsp:
     <%@ taglib uri='http://java.sun.com/jstl/fmt' prefix='fmt'%>
    <fmt:setLocale value='de'/>
    <fmt:setBundle basename='messages'/>
 
// Ausgabe des textes in der jsp:
    <fmt:message key='MYMESSAGE'/>


____________________________666Seitenanfang666_____________________________

Zwei voneinander abhängige Selectboxen programmieren.

Wählt man einen Eintrag in der einen Selectbox ändert sich die
Auswahl der anderen Selectbox.
<html>

    <head>

        <script language="javascript" type="text/javascript">
        function synchronisieren(Selectbox1, Selectbox2) {
            Selectbox2.selectedIndex = Selectbox1.selectedIndex;
        }
        </script>

    </head>

    <body>

        <form name="form1">

            <select name="selects1">
                <option>1</option>
                <option>2</option>
                <option>3</option>
            </select>

            <input type="button" value="Synchronisieren" onclick="synchronisieren(document.form1.selects1, document.form2.selects2)" />

        </form>

        <form name="form2">

            <select name="selects2">
                <option>1</option>
                <option>2</option>
                <option>3</option>
            </select>

            <input type="button" value="Synchronisieren" onclick="synchronisieren(document.form2.selects2, document.form1.selects1)" />

        </form>
    </body>

</html>

Hier noch ein beispiel wie man die Aufgabe mit einer JSP und einem JS File lösen kann.
Die Datei option.js beinhaltet alle Javascriptfunktionen und wird am Anfang der JSP
deklariert.

OPTION.JS:

var selectedList;
var availableList;
function createListObjects(){
    availableList = document.getElementById("availableOptions");
    selectedList = document.getElementById("selectedOptions");
}

function delAttribute(){
   var selIndex = selectedList.selectedIndex;
   if(selIndex < 0)
      return;
   availableList.appendChild(
      selectedList.options.item(selIndex))
   selectNone(selectedList,availableList);
   setSize(availableList,selectedList);
}
function addAttribute(){
   var addIndex = availableList.selectedIndex;
   if(addIndex < 0)
      return;
   selectedList.appendChild( 
      availableList.options.item(addIndex));
   selectNone(selectedList,availableList);
   setSize(selectedList,availableList);
}

function setTop(top){
	document.getElementById
      ('someLayer').style.top = top;
}
function setLayerTop(lyr,top){
	lyr.style.top = top;
}
function setSize(list1,list2){
    list1.size = getSize(list1);
    list2.size = getSize(list2);
}

function selectNone(list1,list2){
    list1.selectedIndex = -1;
    list2.selectedIndex = -1;
    addIndex = -1;
    selIndex = -1;
}
function getSize(list){
    /* Mozilla ignores whitespace, 
       IE doesn't - count the elements 
       in the list */
    var len = list.childNodes.length;
    var nsLen = 0;
    //nodeType returns 1 for elements
    for(i=0; i<len; i++){
        if(list.childNodes.item(i).nodeType==1)
            nsLen++;
    }
    if(nsLen<2)
        return 2;
    else
        return nsLen;
}
function delAll(){
    var len = selectedList.length -1;
    for(i=len; i>=0; i--){
        availableList.appendChild(selectedList.item(i));
    }
    selectNone(selectedList,availableList);
    setSize(selectedList,availableList);
    
}

function addAll(){
    var len = availableList.length -1;
    for(i=len; i>=0; i--){
        selectedList.appendChid(availableList.item(i));
    }
    selectNone(selectedList,availableList);
    setSize(selectedList,availableList);
    
}
function showSelected(){
    var optionList = 
       document.getElementById
      ("selectedOptions").options;
    var data = '';
    var len = optionList.length;
    for(i=0; i>=len;i++) {
            data += ',';
        data += optionList.item(i).value;
    }
    alert(data);
}





JS_TEST:JSP:

<html>
  <head>
    <title>List Box Demo</title>
<script type="text/javascript" src="option.js">
</script>
  </head>

  <body onload="createListObjects()">
    <table border="0">
      <tr>
        <td><select size="4" 
          id="availableOptions" 
          name="availableOptions">
          <option value="option1">
            option1
          </option>

          <option value="option3">
            option3
          </option>

          <option value="option5">
            option5
          </option>

          <option value="option7">
            option7
          </option>
        </select> </td>

        <td valign="top"><button 
           onclick="addAll()">>>></button> 
        <br>
         <button onclick="addAttribute()">
            ></button> 
        <br>
         
        <br>
         <button onclick="delAttribute()">
            <</button> 
        <br>
         <button onclick="delAll()">
            <<<</button> </td>

        <td><select size="4" 
           id="selectedOptions" 
           name="selectedOptions">
          <option value="option2">
            option2
          </option>

          <option value="option4">
            option4
          </option>

          <option value="option6">
            option6
          </option>

          <option value="option8">
            option8
          </option>
        </select> </td>
      </tr>

      <tr>
        <td colspan="2"><button 
           onclick="showSelected()">
           Submit</button> </td>
      </tr>
    </table>
  </body>
</html>




____________________________666Seitenanfang666_____________________________

Original @: 
http://hanuska.blogspot.com/2006/08/improved-map-iteration_13.html





private Collection myStuff = ...

public int calculateSize() {
   int count = 0;
   for (Iterator it = myStuff.iterator(); 
        it.hasNext(); it.next()) {
       count++;
   }
   return count;
}

This can be easily fixed by

public int calculateSize() {
   return myStuff.size();
}

Another, more frequent example of bad performance is a condition 
where one wants to know if there are any objects in the collection, 
but does not really care how many there are.

if (myStuff.size() == 0) {
   // do something
}

Remember size() method may possibly calculate the 
size and therefore generally is slower than a call 
to isEmpty() method. Therefore the fix is obvious.

if (myStuff.isEmpty()) {
   // do something
}

Could you imagine that I once worked for a company 
where the senior developers did not know about 
Iterators? So instead of

for (Iterator it = myStuff.iterator(); it.hasNext();) {
   Object item = it.next();
   // do something with the item
}

they had

for (int i = 0; i < myStuff.size(); i++) {
   Object item = myStuff.get(i);
   // do something with the item
}

and on top of that myStuff was a Vector, 
which is synchronized. Very sloooow code!

Nevertheless my point is: Know your collections!

Now back to the topic of improving the Map iteration. 
Well, it really depends what we need to do at 
each step of our iteration.

If you need to iterate over the keys of the Map do this

for (Iterator it = myMap.keySet().iterator(); it.hasNext();) {
   Object key = it.next();
   // do something with the key
}

And if you need to iterate over the values of the Map do this

for (Iterator it = myMap.values().iterator(); it.hasNext();) {
   Object value = it.next();
   // do something with the value
}

But what if we need both the key and the value? 
The usual approach and very bad approach is to get 
the set of keys, iterate over them and get the 
value for each key.

for (Iterator it = myMap.keySet().iterator(); it.hasNext();) {
   Object key = it.next();
   Object value = myMap.get(key);
   // do something with the key and the value
}

What is wrong about this? Nothing! You can do it 
this way and it's perfectly fine. It is just very 
inefficient as at each iteration a map needs to look 
up the value for a given key. It is better to iterate 
over map entries. There is a special interface Map.Entry 
that can be used to retrieve the key and the value of each 
entry in the map. So the previous example can be transformed into

for (Iterator it = myMap.entrySet().iterator(); it.hasNext();) {
   Map.Entry entry = (Map.Entry) it.next();
   Object key = entry.getKey();
   Object value = entry.getValue();
   // do something with the key and the value
}




____________________________666Seitenanfang666_____________________________

In der web.xml können mehrere Beans einer Webapplikation definiert werden.

web.xml:
 
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>anzeigenameImBowser</display-name>
  <servlet>
    <servlet-name>TestServlet</servlet-name>
    <servlet-class>packagename.TestBean</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>TestServlet2</servlet-name>
    <servlet-class>packagename.TestBean2</servlet-class>
    <load-on-startup>2</load-on-startup>
  </servlet>
 
        <servlet-mapping>
                <servlet-name>TestServlet</servlet-name>
                <url-pattern>/urlFuerTestServletImBrowser</url-pattern>
        </servlet-mapping>
        <servlet-mapping>
                <servlet-name>TestServlet2</servlet-name>
                <url-pattern>/urlFuerTestServlet2ImBrowser</url-pattern>
        </servlet-mapping>
        <welcome-file-list>
                <welcome-file>index.html</welcome-file>
        </welcome-file-list>
</web-app>
 


____________________________666Seitenanfang666_____________________________

BEAN:


/**
* does exactly what his name tells *g*
* @param digit
* @return
*/
public double roundOn2AfterKomma(double digit) {
int stellen = 2;
double factor = Math.pow(10, stellen);
double rounded = Math.round(digit * factor) / factor;
return rounded;
}





____________________________666Seitenanfang666_____________________________

BEAN:


//        ____________________________________________________
// einfuegen facescontext:
    int wert = 0;

FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
.put("rId",wert);



//____________________________________________________
// auslesen facescontext

        String xxx = FacesContext.getCurrentInstance().getExternalContext()
                .getSessionMap().get("rId").toString();
        System.out

.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
        System.out.println(xxx);
        System.out

.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
        int xxxInt = 0;
        try {
            xxxInt = Integer.parseInt(xxx);
        } catch (Exception e) {
            // TODO: handle exception
        }
        this.rId = xxxInt;
        this.dataAccessor = new DataAccess(this.rId);

----------666-------------
IN JSF:

normaler a4j- oder h- link mit jeweiligen parametern



____________________________666Seitenanfang666_____________________________

oe=u00F6
ae=u00E4
ss=u00DF
ue=u00FC
OE=u00D6
AE=u00C4
UE=u00DC
hochgestellte zwei: u00B2
tiefgestellte zwei: u2082




____________________________666Seitenanfang666_____________________________

    public boolean moreStopsAllowed() {
        boolean returnValue = false;

        switch (getAccountType().intValue()) {
        case 0:
            if (displayTour.size() < 1) {
                returnValue = true;
                break;
            }
        case 1:
            if (displayTour.size() < 2) {
                returnValue = true;
                break;
            }
        default:
            if (displayTour.size() < 3)
                returnValue = true;
        }
        return returnValue;
    }


____________________________666Seitenanfang666_____________________________

BEAN:

(Am Beispiel des Typs BarPlotEntry)


der Aufruf:

BarPlotEntry[] array = new BarPlotEntry[] {
new BarPlotEntry(msg
.getString("TourBean.COSTBARPLOT_CAPTIONY1"),
costsCheapStrategy),
new BarPlotEntry(msg
.getString("TourBean.COSTBARPLOT_CAPTIONY2"),
costsComfortStrategy),
new BarPlotEntry(msg
.getString("TourBean.COSTBARPLOT_CAPTIONY3"),
costsEcoStrategy),
new BarPlotEntry(msg
.getString("TourBean.COSTBARPLOT_CAPTIONY4"),
costsFastStrategy), };
java.util.Arrays.sort(array);
return array;


Die Klasse Barplotentry:

public class BarPlotEntry implements 
Comparable{
private double value;
private String name;

public BarPlotEntry( String name, 
		double value ){
this.name = name;
this.value = value;
}

// Die Methode wird durch Comparable vorgeschrieben.
// Wenn "this < argument" dann muss die Methode 
// irgendetwas < 0 zurückgeben
// Wenn "this = argument" dann muss die Methode 
// 0 (irgendetwas = 0)
zurückgeben
// Wenn "this > argument" dann muss die Methode 
// irgendetwas > 0 zurückgeben
public int compareTo( BarPlotEntry argument ) {
if( value < argument.value )
return -1;
if( value > argument.value )
return 1;

return 0;
}

// @Override
// public String toString() {
// return name + " (" + value + " Lumen)";
// }

public double getValue() {
return value;
}

public void setValue(double value) {
this.value = value;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}



}


____________________________666Seitenanfang666_____________________________

BEAN:
static variablen definieren wobei reihenfolge der initialisierung
unbekannt ist:
public class PlanningResultsBean implements PlanningResultsInterface {
static int a = 6;
static int b = 6;
static int c = 7;
...

static variablen definieren wobei reihenfolge der initialisierung
festgeschrieben ist:
public class PlanningResultsBean implements PlanningResultsInterface {
    static {
        a = 6;
        b= 6;
        c= 7;
    }



____________________________666Seitenanfang666_____________________________

Voraussetzungen:
jdom herunterladen unter http://www.jdom.org/dist/binary 
entpacken
jdom.jar in build in die Bibliotheken einbinden
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Text;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
 
...
private static void writeXml() {
          Document doc = new Document();
          Element documentRoot = new Element("dbContent");
          Element relation = new Element("relation");
 
              relation.setAttribute("id", "5");
              Element column = new Element("Spaltenname");
              column.addContent("Spalteninhalt");
              relation.addContent(column);
              documentRoot.addContent(relation);
          doc.setRootElement(documentRoot);
          Format format = Format.getPrettyFormat();
          //format.setEncoding("iso-8859-1");
          format.setEncoding("utf-8");
          XMLOutputter xmlOut = new XMLOutputter(format);
          try {
              String saveTo = "testJdom.xml";
              xmlOut.output(doc, new FileOutputStream(saveTo));
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }
 
 
  }




____________________________666Seitenanfang666_____________________________

  private static void writeXml() {
          Document doc = new Document();
          Element documentRoot = new Element("dbContent");
		  ...
          Namespace xsi = Namespace.getNamespace("xsi", 
          "http://www.w3.org/2001/XMLSchema-instance");          
          documentRoot.addNamespaceDeclaration(xsi);
		  ...
   }



____________________________666Seitenanfang666_____________________________

import java.io.FileNotFoundException;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.*;
import java.util.ArrayList;
import java.util.Vector;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Text;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

  
    
    /*
     * insert Db values 2 xml-file
     */
    private static void writeXml(Vector dataVector, ArrayList columnNames, String currentTable) {
        int colCount =     0;
        boolean dataStructuresOk = false;
        //int singleRowColumns = columnNames.size() * 2;
        

        if (dataVector.size() % columnNames.size() == 0) {
            dataStructuresOk = true;
        } else {
            System.out.println("DataStructures not valid, no xml will be created!");
            System.out.println("dataVector.size() : " + dataVector.size());
            System.out.println("columnNames.size(): " + columnNames.size());
            System.out.println("modulo != 0");
        }
        if (dataStructuresOk) {
            int currentRow = 0;
            Document doc = new Document();
            Element documentRoot = new Element("dbContent");
            
            int currentColumnNameIndex = 0;        
            Element relation = new Element("relation");
            for (int currentDataFieldIndex = 1; currentDataFieldIndex < dataVector.size(); 
			     currentDataFieldIndex = currentDataFieldIndex + 2) {            
                // Relation-ID:
                String iString = abnormalizer.intToString(currentRow);
                relation.setAttribute("id", iString);
                // Column-name:
                String colName = columnNames.get(currentColumnNameIndex);
                Element column = new Element(colName);
                // Column-Content:
                String colContent = dataVector.get(currentDataFieldIndex);
                if (colContent != null && colContent.length() > 0 && colContent.indexOf("u0007") > -1) {
                    int x = colContent.indexOf("u0007");
                    String vor = "";
                    String nach = "";
                    if (x > 0) {
                        vor = colContent.substring(0, x);
                        nach = colContent.substring(x+1);    
                    }
                    else{
                        vor = "";
                        nach = colContent.substring(x+1);
                    }
                    colContent = vor + nach;
                }
                column.addContent(new Text(colContent));
                relation.addContent(column);
                // id nach durchlauf aller Datensätze einer relation ++
                if (currentColumnNameIndex >= (columnNames.size()-1)) {
                    currentColumnNameIndex = 0;
                    currentRow++;
                    documentRoot.addContent(relation);
                    relation = new Element("relation");
                } else {
                    currentColumnNameIndex++;    
                }

            }
            doc.setRootElement(documentRoot);
            Format format = Format.getPrettyFormat();
            //format.setEncoding("iso-8859-1");
            format.setEncoding("utf-8");
            XMLOutputter xmlOut = new XMLOutputter(format);
            try {
                String saveTo = destinationDir + currentTable + ".xml";
                xmlOut.output(doc, new FileOutputStream(saveTo));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
    }
    
}




____________________________666Seitenanfang666_____________________________