Der Blog von Benny Neugebauer » Code Snippets http://www.bennyn.de Alles über die Informatik & Co. Mon, 06 Feb 2012 11:49:34 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Java XML SAX Parser http://www.bennyn.de/programmierung/java/java-xml-sax-parser.html http://www.bennyn.de/programmierung/java/java-xml-sax-parser.html#comments Fri, 04 Feb 2011 06:02:30 +0000 bennyn http://www.bennyn.de/?p=2296 Um mit Java eine XML Datei zu parsen, empfehle ich einen SAX Parser, da dieser schneller ist als ein DOM Parser. Die Implementierung eines SAX Parsers in Java ist einfach. Man muss nur eine routinemäßige Initialisierung vornehmen und einen eigenen Handler schreiben. Wie das funktioniert, zeigt mein nachfolgendes Code-Beispiel. Ich erkläre ebenfalls, wie man den SAX Parser in Google Android verwenden kann!

XML-Datei

Ich möchte gerne alle Apfelsorten aus der Datei apples.xml auslesen:

apples.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<?xml version="1.0" encoding="UTF-8"?>
<root>
	<cultivar>
		<name>Golden Delicious</name>
	</cultivar>
	<cultivar>
		<name>Granny Smith</name>
	</cultivar>	
	<cultivar>
		<name>Idared</name>
	</cultivar>	
		<name>Fuji</name>
	<cultivar>
		<name>Ginger Gold</name>
	</cultivar>
	<cultivar>
		<name>McIntosh</name>
	</cultivar>
	<cultivar>
		<name>Northern Spy</name>
	</cultivar>
	<cultivar>
		<name>Pink Pearl</name>
	</cultivar>
	<cultivar>
		<name>Pinova</name>
	</cultivar>
	<cultivar>
		<name>Red Delicious</name>
	</cultivar>
	<cultivar>
		<name>Spitzenberg</name>
	</cultivar>		
	<cultivar>
		<name>Summerfree</name>
	</cultivar>
	<cultivar>
		<name>SweeTango</name>
	</cultivar>
</root>

Um mein Ziel zu erreichen, muss mein SAX-Parser immer dann, wenn ein öffnendes name-Tag gefunden wird, anfangen alle nachfolgenden Zeichen zu puffern. Die Pufferung muss beendet werden, sobald ein schließendes name-Tag gefunden wird. Der Inhalt des Puffers ist dann mein Ergebnis, welches ich in einer ArrayList aufbewahren möchte.

Code:

Main.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package myjaxparser;
 
import java.io.File;
import java.util.ArrayList;
 
public class Main
{
 
  public static void main(String[] args)
  {
    ArrayList<String> appleCultivars = null;
    File file = new File("apples.xml");
    // Parse apples.xml
    try
    {
      MySaxParser parser = new MySaxParser(file);
      parser.parse();
      appleCultivars = parser.getAppleCultivars();
      // Print results
      for (int i = 0; i < appleCultivars.size(); i++)
      {
        System.out.println(appleCultivars.get(i));
      }
    }
    catch (Exception ex)
    {
      System.out.println("Another exciting error occured: " + ex.getLocalizedMessage());
    }
  }
}

MySaxParser.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

package myjaxparser;
 
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
 
public class MySaxParser
{
  private URL url;
  private ArrayList<String> appleCultivars;
 
  public MySaxParser()
  {
    super();
  }
 
  public MySaxParser(File file) throws MalformedURLException
  {
    this.url = file.toURI().toURL();
  }
 
  public void parse() throws ParserConfigurationException, SAXException, IOException
  {
    // Initialize SAX Parser:
    SAXParserFactory factory = SAXParserFactory.newInstance();
    SAXParser parser = factory.newSAXParser();
    XMLReader reader = parser.getXMLReader();
    // Create SAX Handler:
    MySaxHandler handler = new MySaxHandler();
    reader.setContentHandler(handler);
    // Parse XML file:
    InputSource input = new InputSource(url.openStream());
    reader.parse(input);
    // Get the result:
    this.appleCultivars = handler.getAppleCultivars();
  }
 
  public ArrayList<String> getAppleCultivars()
  {
    return this.appleCultivars;
  }
}

MySaxHandler.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package myjaxparser;
 
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
public class MySaxHandler extends DefaultHandler
{
 
  private StringBuffer buffer;
  private boolean buffering;
  private ArrayList<String> appleCultivars;
 
  public MySaxHandler()
  {
    this.buffer = null;
    this.buffering = false;
    appleCultivars = new ArrayList<String>();
  }
 
  @Override
  public void startDocument() throws SAXException
  {
    this.buffer = new StringBuffer("");
  }
 
  @Override
  public void startElement(String namespaceURI, String localName, String tagName, Attributes attributes) throws SAXException
  {
    String tag = tagName;
    if (tag.equals("name"))
    {
      this.buffering = true;
    }
  }
 
  @Override
  public void endElement(String namespaceURI, String localName, String tagName) throws SAXException
  {
    String tag = tagName;
    String tagValue = null;
 
    if (tag.equals("name"))
    {
      tagValue = this.buffer.toString();
      this.buffering = false;
      this.buffer = new StringBuffer();
    }
 
    parseValue(tagValue);
  }
 
  @Override
  public void characters(char chars[], int start, int length)
  {
    if (this.buffering)
    {
      this.buffer = this.buffer.append(chars, start, length);
    }
  }
 
  private void parseValue(String value)
  {
    if (value != null)
    {
      this.appleCultivars.add(value);
    }
  }
 
  public ArrayList<String> getAppleCultivars()
  {
    return this.appleCultivars;
  }
}

Achtung Android!
Für den Einsatz von MySaxHandler.java in Android muss man String tag = tagName; gegen String tag = localName; austauschen. Das ist zwar ziemlich unlogisch, jedoch hat das Code-Beispiel nur so bei mir funktioniert (getestet mit Google Android 2.1).

]]> http://www.bennyn.de/programmierung/java/java-xml-sax-parser.html/feed 0 Andere JSPs in Scriptlets einfügen http://www.bennyn.de/programmierung/java/andere-jsps-in-scriptlets-einfugen.html http://www.bennyn.de/programmierung/java/andere-jsps-in-scriptlets-einfugen.html#comments Sun, 26 Sep 2010 00:44:28 +0000 bennyn http://www.bennyn.de/?p=1961 Wie man andere JavaServer Pages in einer JavaServer Page einfügen kann, zeigt das folgende Code-Stückchen. Es handelt sich dabei um ein Scriptlet, das bei Vorhandensein eines User-Objektes ein Logout-Formular anzeigt.

scriptlet.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<%@page import="util.SecurityUtil, persistence.User" %>
<%
	SecurityUtil security = SecurityUtil.getInstance();
	User user = security.getUser();
	if(user != null)
	{
%>
	<%@include file="form-logout.jsp" %>
<%
	}
	else
	{
%>
	<%@include file="form-login.jsp" %>
<%
	}
%>
]]> http://www.bennyn.de/programmierung/java/andere-jsps-in-scriptlets-einfugen.html/feed 0 Datei zeilenweise auslesen in PHP http://www.bennyn.de/programmierung/php/datei-zeilenweise-auslesen-in-php.html http://www.bennyn.de/programmierung/php/datei-zeilenweise-auslesen-in-php.html#comments Wed, 15 Sep 2010 10:26:40 +0000 bennyn http://www.bennyn.de/?p=1819 Mit diesem Code kann man mit PHP eine Textdatei zeilenweise auslesen und anzeigen:

1
2
3
4
5
6
7

<?php
	$file = fopen("namensliste.txt","r");
	while($row = fgets($file, 4096))
	{
		echo $row."<br/>";
	}	
?>

Möchte man eine zufällige Zeile auslesen, so geht das wie folgt:

1
2
3
4
5
6
7
8
9
10

<?php
	$file = fopen("namensliste.txt","r");
	while($row = fgets($file, 4096))
	{
		$rows[] = $row;
	}	
 
	$randomRow = mt_rand(0, count($rows)-1);
	echo $rows[$randomRow];
?>
]]> http://www.bennyn.de/programmierung/php/datei-zeilenweise-auslesen-in-php.html/feed 0 Zufallszahlen in Java http://www.bennyn.de/programmierung/java/zufallszahlen-in-java.html http://www.bennyn.de/programmierung/java/zufallszahlen-in-java.html#comments Sun, 14 Mar 2010 22:19:39 +0000 bennyn http://www.bennyn.de/programmierung/java/zufallszahlen-in-java.html Um Zufallszahlen in Java zu erstellen, kann man die Bibliothek java.util.Random verwenden. Die Zufalls-Klasse von Java ist sehr vielseitig und bietet unter anderem die Möglichkeit, Zufallszahlen in einem bestimmten Bereich zu definieren. An dieser Stelle folgt ein kleiner Beispiel-Code, welcher 20 Zufallszahlen im Bereich von 0 bis 72 ausgibt:

1
2
3
4
5
6
7
8
9
10

    public void erstelleZufallsZahl()
    {
        Random zufallsgenerator = new Random();
 
        for(int i=0; i<20; i++)
        {
            int zahl = zufallsgenerator.nextInt(72);
            System.out.println(zahl);
        }
    }

Etwas ausführlicher:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import java.util.Random;
 
public class JavaApplication1
{
 
  public static void main(String[] args)
  {
    erstelleZufallsZahl();
  }
 
  public static void erstelleZufallsZahl()
  {
    Random zufallsgenerator = new Random();
 
    for (int i = 0; i < 20; i++)
    {
      int zahl = zufallsgenerator.nextInt(72);
      System.out.println(zahl);
    }
  }
}
]]> http://www.bennyn.de/programmierung/java/zufallszahlen-in-java.html/feed 2 Java Server Pages – Beispiel http://www.bennyn.de/aktuelles/java-server-pages-beispiel.html http://www.bennyn.de/aktuelles/java-server-pages-beispiel.html#comments Thu, 11 Mar 2010 14:07:01 +0000 bennyn http://www.bennyn.de/?p=840 Es folgt ein Beispiel zur Erstellung einer Java Server Page (kurz JSP).

Die Java Server Page wird durch ein Servlet (im Beispiel NewServlet.java) aufgerufen. Daher muss im Webbrowser auch die Adresse des Servlets eingegeben werden. Als Parameter wird dabei das gewünschte Command mit einer dazugehörigen Action ausgeführt.

Im Beispielaufruf heißt das Command “cmd” und die Action “actionman”:

http://localhost:8080/Projekt/servlet?do=actionman

Quellcode:

Projektname > “Source Packages” > controller.web > NewServlet.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package controller.web;
 
import java.util.HashMap;
 
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
 
@WebServlet(name="NewServlet", urlPatterns={"/servlet"})
public class NewServlet extends HttpServletControllerBase
{
    public void init(ServletConfig conf) throws ServletException
    {
        HttpRequestActionBase action = null;
        actions = new HashMap();
 
        // Action: Möglicher Wert (Value) für einen Steuerbefehl (Command)
        action = new MyAction();
        actions.put("actionman", action);
 
        // Weitere "action" erstellen und "actions" hinzufügen...
    }
 
    protected String getOperation(HttpServletRequest req)
    {
        // Command: Steuerbefehl
        return req.getParameter("do");
    }
}

Projektname > “Source Packages” > controller.web > MyAction.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package controller.web;
 
import java.io.IOException;
import javax.servlet.RequestDispatcher;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class MyAction extends HttpRequestActionBase
{
    public void perform(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException
    {
        try
        {
            String strTemp = "Willkommen auf der JSP-Seite.";
            req.setAttribute("willkommen", strTemp);
            RequestDispatcher reqDisp = req.getRequestDispatcher("showaction.jsp");
            reqDisp.forward(req, resp);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

Projektname > “Web Pages” > showaction.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!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=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <!-- Variante 1 -->
        <h1><%=request.getAttribute("willkommen")%></h1>
        <!-- Variante 2 -->
        <h1>${hallo}</h1>
    </body>
</html>

Benötigte Ressourcen:
Projektname > “Source Packages” > controller.web > HttpServletControllerBase.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package controller.web;
 
import java.io.IOException;
import java.util.HashMap;
 
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public abstract class HttpServletControllerBase extends HttpServlet
{
	protected HashMap actions;
 
	public void init(ServletConfig conf) throws ServletException
        {
            HttpRequestActionBase action = null;
            actions = new HashMap();
	}
 
	public void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws IOException, ServletException
        {
	    String op = getOperation(req);
	    HttpRequestActionBase action = (HttpRequestActionBase)actions.get(op);
	    action.perform(req, resp);
	}
 
	public void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws IOException, ServletException
        {
 
	    // Zunaechst wird die URL analysiert,
            // um die Operation, die ausgefueht werden soll zu bestimmen
	    String op = getOperation(req);
	    // dann wird die entsprechende Aktion aus der Map geholt ...
	    HttpRequestActionBase action = (HttpRequestActionBase)actions.get(op);
	    // ... und angestossen
	    action.perform(req, resp);
	}
 
	/** Methode muss noch definiert werden, um die Kennung der
	  * Operation aus der URL zu lesen
	  * @param req Http-Request
	  * @return Name der Aktion, die ausgefuehrt werden soll
	  */
	protected abstract String getOperation(HttpServletRequest req);
}

Projektname > “Source Packages” > controller.web > HttpRequestActionBase.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package controller.web;
 
import java.io.IOException;
 
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public abstract class HttpRequestActionBase
{
    public abstract void perform(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException;
 
    protected void forward(HttpServletRequest req, HttpServletResponse resp, String forwardName)
    throws ServletException, IOException
    {
        RequestDispatcher reqDis = req.getRequestDispatcher(forwardName);
        reqDis.forward(req, resp);
    }
}
]]> http://www.bennyn.de/aktuelles/java-server-pages-beispiel.html/feed 0