IT blogging

Firefox URL autocompletion in der Adressleiste

Simon Michel — Sun, 06 May 2012 16:25:46 +0000

Auch wenn Firefox ein sehr guter und weit verbreiteter Browser mit vielen Features ist, dennoch finde das einige Standardeinstellungen nicht ganz nach meinem Geschmack eingestellt sind. Hierzu gehört unter anderem auch die autocompletion der bereits besuchten Websites. Ist es nicht auf Dauer nervig jedes Mal den Pfeil nach unten in der Vorschlagsbox zu drücken? Bei anderen Browsern wie beispielsweise der Safari oder Chrome ist dies bereits voreingestellt…

Glücklicherweise ermöglicht Firefox über die Einstellungsseite about:config dem User die Möglichkeit, seinen Browser individuell anzupassen.

In der Suche wird nach folgendem Einstellungsnamen gesucht:

browser.urlbar.autoFill

Per Doppelklick auf die autoFill Einstellung wird die Benutzereinstellung aktiviert und der Wert von false auf true gesetzt.

Die autocompletion ist nun aktiviert. Irgendwie sind es doch oft die Kleinigkeiten, die das alltägliche Arbeiten erleichtern.

Spring JdbcInsert Beispiele

Simon Michel — Mon, 16 Apr 2012 07:19:05 +0000

In dem Artikel Spring JdbcTemplate Query Beispiele wurden bereits die verschiedenen Query Möglichkeiten von Spring mit Hilfe der JdbcTemplate Klasse gezeigt. In diesem Artikel möchte ich nun die unterschiedlichen Varianten eines INSERT SQL-Statements anhand einiger Beispielen präsentieren.
Die Klasse SimpleJdbcInsert dient hauptsächlich dem Zweck Informationen in die Datenbank zu pushen. Alternativ bietet die JdbcTemplate Klasse eine Möglichkeit INSERT SQL-Statements abzusetzen.

Auf die Generierung einer DataSource werde ich in diesem Artikel nicht näher eingehen. Weitere Informationen zu diesem Thema gibt es in dem Artikel Spring MySQL (JDBC) Tutorial .

SimpleJdbcInsert konfigurieren

Während der Initialisierung des SimpleJdbcInsert Objektes werden grundlegende Informationen wie der Tabellenname, der Primärschlüssel und die verwendeten Spaltennamen gesetzt. Die Zuweisung kann über zwei verschiedene Varianten umgesetzt werden.

Variante 1:

DataSource dataSource = … //
SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(dataSource);
jdbcInsert.withTableName("customer");
jdbcInsert.usingGeneratedKeyColumns("customer_id");
jdbcInsert.usingColumns("first_name", "last_name", "email");

Variante 2:

DataSource dataSource = … //
SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(dataSource)
                                      	.withTableName("customer")
                                      	.usingGeneratedKeyColumns("customer_id")
                                      	.usingColumns("first_name", "last_name", "email");

Map

Map parameterSource = new HashMap();
parameterSource.put("first_name", "Simon");
parameterSource.put("last_name", "Michel");
parameterSource.put("email", "info@itblogging.de");

int rowsEffected = simpleJdbcInsert.execute(parameterSource);
System.out.println("Anzahl betroffener Datensätze: " + rowsEffected);

MapSqlParameterSource

SqlParameterSource parameters = new MapSqlParameterSource();
parameters.addValue("first_Name", "Simon");
parameters.addValue("last_Name", "Michel");
parameters.addValue("email", "info@itblogging.de");

Number primaryKey = jdbcInsert.executeAndReturnKey(parameters);
System.out.println("Primärschlüssel des neuen Datensatzes: " + primaryKey);

BeanPropertySqlParameterSource

Hinweis: Die getter Methoden der Bean Klasse müssen gleichnamig zu den Tabellenspaltennamen sein, benötigen jedoch keine Unterstriche. Heißt die Tabellenspalte wie in unserem Beispiel first_name, kann die getter Methode getFirstName() heißen.

Customer customer = … //
SqlParameterSource customer = new BeanPropertySqlParameterSource(customer);
// Alternativ: executeAndReturnKeyHolder(customer)
int rowsEffected = simpleJdbcInsert.execute(customer);

System.out.println("Anzahl betroffener Datensätze: " + rowsEffected);

Alternative JdbcTemplate

Nicht nur mit Hilfe der SimpleJdbcInsert Klasse können Informationen in der Datenbank persistiert werden, auch das JdbcTemplate bietet die Möglichkeit INSERT SQL-Statements abzusetzen.

Einfaches Update

DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "INSERT INTO Customer(first_name, last_name, email) VALUES(?, ?, ?)";
String firstName = "Simon";
String lastName = "Michel";
String email = "info@itblogging.de";
jdbcTemplate.update(sql, firstName, lastName, email);

PreparedStatementSetter

DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

final Customer customer =  … //
PreparedStatementSetter pss = new PreparedStatementSetter()
{
  @Override
  public void setValues(PreparedStatement ps) throws SQLException
  {
    ps.setString(1, customer.getFirstName());
    ps.setString(2, customer.getLastName());
    ps.setString(3, customer.getEmail());
  }
};
String sql = "INSERT INTO Customer(first_name, last_name, email) VALUES(?, ?, ?)";
int rowsEffected = jdbcTemplate.update(sql, pss);
System.out.println("Anzahl betroffener Datensätze: "  + rowsEffected);

PreparedStatementCreator

Bei der Verwendung des JdbcTemplates muss der Primärschlüssel (hier: customer_id) als Parameter des PreparedStatements übergeben werden. Der Key wird anschließend in dem KeyHolder gespeichert.

KeyHolder keyHolder = new GeneratedKeyHolder();
jdbcTemplate.update(new PreparedStatementCreator()
{
  @Override
  public PreparedStatement createPreparedStatement(Connection con) throws SQLException
  {
    String sql = "INSERT INTO Customer(first_name, last_name, email) VALUES(?, ?, ?)";
    // customer_id = Primärschlüssel
    PreparedStatement ps =
          con.prepareStatement(sql, new String[] {"customer_id"});
          ps.setString(1, "Simon");
          ps.setString(2, "Michel");
          ps.setString(3, "info@itblogging.de");

          return ps;
  }
}, keyHolder);
System.out.println("Primärschlüssel: " + keyHolder.getKey());

Das war’s. Viel Spaß.

Android ICS (4.0.3) über KIES für T-Mobile Kunden erhältlich

Simon Michel — Tue, 10 Apr 2012 21:39:31 +0000

Als ich eben seit langer langer Zeit mein Samsung Galaxy S2 mal wieder an KIES angeschlossen hatte, erwartete mich völlig überraschend das lang ersehnte Ice Cream Sandwich Update.
Wenn ich mich nicht täusche, müsste die Deutsche Telekom dann heute mit der Einspeisung von ICS begonnen haben. Denn ursprünglich wollte ich eigentlich bereits gestern das Galaxy updaten, doch da teilte mir KIES lediglich mit das ein Update auf die Version 2.3.4 verfügbar sei. Da es mir dann doch zeitlich etwas zu spät für das Update war, entschied ich mich es heute durchzuführen.

Umso überraschter war ich anschließend als mein Screen doch etwas anders als gewohnt aussah. Schließlich sollte das Update von 2.3.2 auf 2.3.4 lediglich Kleinigkeiten wie Google Talk aktualisieren und ein paar BugFixes durchführen. Nachdem ich dann Neugierig in den Einstellungen nach der installierten Version schaute, musste ich feststellen das die Telekom endlich das Roll Out von ICS begonnen hat, nachdem bereits viele Vermutungen in den letzten Wochen durch das Web kursierten.

Und hier nun die Beweise …

Android 4.0.3 Screenshot

KIES Screenshot

JAXB Tutorial

Simon Michel — Mon, 09 Apr 2012 19:53:53 +0000

Mit Hilfe der Java Architecture for XML Binding (JAXB) API können Java Objekte bequem in XML-Dokumente gewandelt werden und umgekehrt. Über Annotations teilen hierbei die Entwickler dem Compiler mit, welcher Klasse oder welches Attribut welche Eigenschaft in dem XML-Dokument übernehmen wird.
Bereits in dem Tutorial Java und XML Tutorial wurde die Bearbeitung von XML-Dokumenten auf Basis eines Literatur Beispiels gezeigt. Dieses Beispiel werde ich nun mit Hilfe von JAXB erneut aufgreifen.

Mehr Informationen über das Thema XML gibt es in dem Blogbeitrag XML – Extensible Markup Language. Zusatztechnologien wie zum Beispiel XPath, XPointer, oder XLink behandelt der Beitrag XML Zusatztechnologien.

Annotations

Eine kleine Übersicht der verwendeten Annoations mit ihren Funktionen.

Annotation	Funktion
@XmlRootElement(namespace = “http://www.itblogging.de/myNameSpace”)	Kennzeichnet das Root Element. Die Angabe des Namensraums ist optional.
@XmlElement(name = “myName”)	Gibt dem XML Element einen alternativen Namen, falls gewünscht.
@XmlType(propOrder = {“title”, “isbn”})	Bestimmt die Reihenfolge der Ausgabe.
@XmlElementWrapper(name = “authorlist”)	Erzeugt einen Wrapper um eine Liste von Objekten.
@XmlSchemaType(name = “dateTime”)	Anhagabe des Typen.

Author.java

Die Author Klasse ist eine ganz normale Bean Klasse. Es werden keine Annotations zur Kennzeichnung besonderer Attribute benötigt.

public class Author
{
  private String firstName;
  private String lastName;

  public String getFirstName()
  {
    return firstName;
  }

  public void setFirstName(String firstName)
  {
    this.firstName = firstName;
  }

  public String getLastName()
  {
    return lastName;
  }

  public void setLastName(String lastName)
  {
    this.lastName = lastName;
  }
}

Edition.java

Hier ein Beispiel der @XmlElement Annotation. Normalerweise würde das XML-Tag nach der Generierung den Namen “editionNo” erhalten. Statt “editionNo” wird das Tag dank der Annotation den Namen “numberOfEdition” erhalten.

import javax.xml.bind.annotation.XmlElement;

public class Edition
{
  private String publisher;
  private int editionNo;
  private int publicationYear;

  public String getPublisher()
  {
    return publisher;
  }

  public void setPublisher(String publisher)
  {
    this.publisher = publisher;
  }

  public int getEditionNo()
  {
    return editionNo;
  }

  @XmlElement(name = "numberOfEdition")
  public void setEditionNo(int editionNo)
  {
    this.editionNo = editionNo;
  }

  public int getPublicationYear()
  {
    return publicationYear;
  }

  public void setPublicationYear(int publicationYear)
  {
    this.publicationYear = publicationYear;
  }
}

Book.java

Über das Attribut propOrder der @XmlType Annotation kann die Reihenfolge der Ausgabe bestimmt werden. Einige Tagnamen werden mit Hilfe der @XmlElement neu vergeben.
Die Annotation @XmlElementWrapper ummantelt alle Autoren mit einem weiteren Tag, dem authorlist Tag.

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlType;

// Property Reihenfolge mit "propOrder" bestimmen
@XmlType(propOrder = {"title", "isbn", "edition", "authors"})
public class Book
{
    private String title;
    private List authors;
    private Edition edition;
    private String isbn;

    public Book()
    {
      this.authors = new ArrayList();
    }

    public String getTitle()
    {
        return title;
    }

    public void setTitle(String title)
    {
        this.title = title;
    }

    public void addAuthor(Author a)
    {
        authors.add(a);
    }

    @XmlElementWrapper(name = "authorlist")
    @XmlElement(name = "author")
    public List getAuthors()
    {
        return authors;
    }

    public void setEdition(Edition edition)
    {
      this.edition = edition;
    }

    @XmlElement(name = "editionInfo")
    public Edition getEdition()
    {
        return edition;
    }

    public String getIsbn()
    {
        return isbn;
    }

    public void setIsbn(String isbn)
    {
        this.isbn = isbn;
    }
}

Literature.java

Die Annotation @XmlRootElement kennzeichnet das Wurzelelement des XML-Dokumentes. Optional kann der Namensraum angegeben werden.

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;

// Angabe des Root Elements. Optional kann der namespace -sofern er vorhanden
// ist- angegeben werden.
@XmlRootElement(namespace = "http://www.itblogging.de/myNameSpace")
@XmlType(propOrder = {"currentTime", "bookList"})
public class Literature
{
  private List bookList;
  private Date currentTime;
  private String version;

  public Literature()
  {
    this.bookList = new ArrayList();
  }

  // Der Wrapper soll "booklist" heißen
  @XmlElementWrapper(name = "booklist")
  // und die einzelnen Elemente jeweils "book"
  @XmlElement(name = "book")
  public List getBookList()
  {
    return bookList;
  }

  // explizite Typenangabe
  @XmlSchemaType(name = "dateTime")
  public Date getCurrentTime()
  {
    return currentTime;
  }

  public void setCurrentTime(Date currentTime)
  {
    this.currentTime = currentTime;
  }

  // Die Version soll ein Attribut des RootElements sein
  @XmlAttribute
  public String getVersion()
  {
    return version;
  }

  public void setVersion(String version)
  {
    this.version = version;
  }
}

XMLCreator.java

Diese Klasse hilft uns ein neues XML-Dokument zu erzeugen, auszugeben, zu speichern und anschließend erneut wieder einzulesen.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Date;

import javax.xml.bind.JAXB;

public class XmlCreator
{
  public static void main(String[] args) throws IOException
  {
    Literature literature = createLiterature();

    // Konsolenausgabe
    JAXB.marshal(literature, System.out);

    // Dateiname (wird in dem Projektverzeichnis hinterlegt)
    String fileName = "literatur.xml";

    // Speicherung in Datei
    Writer fileWriter = new FileWriter(fileName);
    JAXB.marshal(literature, fileWriter);
    fileWriter.close();

    // Aus Datei lesen
    Literature backToObject = JAXB.unmarshal(new File(fileName), Literature.class);

    System.out.println("\nVersion: " + backToObject.getVersion());
    System.out.println("Datum: " + backToObject.getCurrentTime());
    System.out.println("---");
    for(Book book : backToObject.getBookList())
    {
      System.out.println("Titel: " + book.getTitle());
      System.out.println("ISBN: " + book.getIsbn());
      // ....
    }
  }

  // Erzeugt das Literaturverzeichnis
  private static Literature createLiterature()
  {
    Literature literature = new Literature();
    literature.setCurrentTime(new Date());
    literature.setVersion("0.1");

    // Book
    Book book = new Book();
    book.setIsbn("3-89842-488-X");
    book.setTitle("Einstieg in XML");

    // Edition
    Edition edition = new Edition();
    edition.setEditionNo(2);
    edition.setPublicationYear(2004);
    edition.setPublisher("Galileo Computing");
    book.setEdition(edition);

    // Author
    Author author = new Author();
    author.setFirstName("Helmut");
    author.setLastName("Vonhoegen");
    book.getAuthors().add(author);

    // Buch hinzufügen
    literature.getBookList().add(book);

    return literature;
  }
}

Ergebnis

Nachdem die Datei XMLCreator.java ausgeführt wurde, wird zum einen das Ergebnis in der Konsole ausgegeben und zum anderen in der neu angelegten Datei literature.xml gespeichert.
Man beachte, dass die Tagnamen wie vorgeschrieben benannt wurden.



	2012-04-09T20:39:52.364+02:00
	
		
			Einstieg in XML
			3-89842-488-X
			
				2
				2004
				Galileo Computing
			
			
				
					Helmut
					Vonhoegen

Das JAXB Tutorial steht auch als zip-Datei zum Download zur Verfügung.

Oracla Java (JDK) 7 in Ubuntu installieren

Simon Michel — Tue, 03 Apr 2012 20:20:59 +0000

Wer statt dem OpenJDK das Oracle JDK 7 in Ubuntu installieren möchte, kann dies in wenigen Schritten mit dem Hinzufügen eines PPA’s (Personal Package Archive) nachholen.
Aufgrund der neuen Java Lizenzen ist das Oracle JDK7 selbst nicht im offiziellen Repository enthalten.

Oracle Java 7 installieren

Das Team webupd8 stellt ein PPA zur Verfügung, mit Hilfe dessen Java 7 in wenigen Schritten installiert werden kann. Hierbei wird von der offiziellen Oracle Website der aktuellste Stand herunter geladen und auf der Workstation installiert.

Bitte beachtet, das es sich hierbei nicht um ein offizielles PPA des Herstellers handelt. Die Installation erfolgt auf eigene Gefahr.

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

Aktuelle Java Version prüfen

Die aktuell auf der Plattform installierte Version kann wie folgt geprüft werden:

java -help

Vorher

Das Ergebnis betrifft natürlich meinen lokalen Rechner und kann bei jedem anders aussehen.

java version "1.6.0_23"
OpenJDK Runtime Environment (IcedTea6 1.11pre) (6b23~pre11-0ubuntu1.11.10.2)
OpenJDK Server VM (build 20.0-b11, mixed mode)

Nachher

Nach der Durchführung ist die Java Version 7 installiert.

java version "1.7.0_03"
Java(TM) SE Runtime Environment (build 1.7.0_03-b04)
Java HotSpot(TM) Server VM (build 22.1-b02, mixed mode)

Oracle Java 7 deinstallieren

Für den Fall das die Version 7 wieder deinstalliert werden soll, reicht folgendes Kommando.

sudo apt-get remove oracle-java7-installer

Spring JdbcTemplate Query Beispiele

Simon Michel — Mon, 02 Apr 2012 21:03:40 +0000

Spring bietet mit Hilfe des JdbcTemplates verschiedene Möglichkeiten, Daten aus der Datenbank zu lesen. Im Nachfolgenden sollen hierzu verschiedene Wege anhand einiger Beispiele aufgeführt werden.
Da ich an dieser Stelle nicht im Detail darauf eingehen möchte wie ein JdbcTemplate erstellt wird, hilft allen Unwissenden das Tutorial Spring MySQL (JDBC) Tutorial weiter. Als Datenbank wird sakila verwendet. Was sakila ist, woher es kommt und wie sie importiert wird, zeigt der Blogbeitrag MySQL Server installieren unter dem Punkt Testdatenbank Sakila installieren.

Sollen Daten nicht nur abgerufen, sondern auch in die Datenbank gepusht werden, geschieht dies in der Regel mit dem JdbcInsert. Anwendungsbespiele gibt es im Artikel Spring JdbcInsert Beispiele.

Single Value Abfragen

Count Abfrage

Die queryForInt() Abfrage kann beispielsweise gut dafür genutzt werden, um die Anzahl von Ergebnissen aus einer Gruppe abzurufen.
Die verwendete COUNT() Abfrage liefert natürlich immer ein Ergebnis, auch dann wenn die Suchabfrage kein Ergebnis liefert ; – )

String searchName = "Simon";
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT COUNT(*) FROM  customer WHERE first_Name LIKE '%?%'";
int resCount = jdbcTemplate.queryForInt(sql, searchName);
System.out.println("Anzahl gefundener Datensätze: " + resCount);

Single Row Query

Einzelne Werte bestimmter Datentypen können mit Hilfe von queryForObject() abgerufen werden. Wichtig bei dieser Abfrage ist, dass das Ergebnis genau einen Wert zurück gibt:

String

Der zweite Parameter String.class der queryForObject() Methode gibt den Rückgabetypen an.

int customerId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT first_Name FROM customer WHERE customer_id = ?";
String firstName = jdbcTemplate.queryForObject(sql, String.class, customerId);
System.out.println(firstName);

Integer

Analog zu der String Abfrage, klappt dies natürlich auch für Integer Werte.

int customerId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT store_id FROM customer WHERE customer_id = ?";
int storeId = jdbcTemplate.queryForObject(sql, Integer.class, customerId);

Bei Integer Rrückgabetypen gibt es noch die Alternative queryForInt():

String sql = "SELECT store_id FROM customer WHERE customer_id = ?";
int storeId = jdbcTemplate.queryForInt(sql, customerId);

Date

Auch die Abfrage nach einem Datum ist möglich:

int customerId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT create_date FROM customer WHERE customer_id = ?";
int storeId = jdbcTemplate.queryForObject(sql, java.util.Date.class, customerId);

Single Map Query

Die Single Map Abfrage erwartet ebenfalls genau ein Ergebnis. Der Key der Map entspricht dem Spaltennamen der Tabelle.

int customerId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT * FROM customer WHERE customer_id = ?";
Map singleMap = jdbcTemplate.queryForMap(sql, customerId);
for(Entry entry : singleMap.entrySet())
{
  System.out.println(entry.getKey() + " / " + entry.getValue());
}

List Querys

Wenn bereits vor der Abfrage klar ist, dass die Ergebnismenge größer eins sein kann, hilft die Methode queryForList() weiter.

String List

int storeId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT first_Name FROM customer WHERE store_id =  ?";
List firstNameList = jdbcTemplate.queryForList(sql, String.class, storeId);
System.out.println(firstNameList.size());

Integer List, Long List, Date List

Analog zu der String List, kann queryForList() natürlich auch für andere Datentypen genutzt werden.

List of Maps Query

Ein Beispiel wie eine Tabelle mit allen Tabellenspalten ausgelesen werden kann.

int storeId = 1;
DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT * FROM customer WHERE store_id = ?";
List> mapList = jdbcTemplate.queryForList(sql, storeId);

for(Map entryMap : mapList)
{
  for(Entry entry : entryMap.entrySet())
  {
    // Spaltenname = Key; Spalteninhalt = Value
    System.out.println(entry.getKey() + " / " + entry.getValue());
  }
  System.out.println("---");
}

SqlRowSet

Der Rückgabetyp RowSet ist natürlich auch möglich:

DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT * FROM customer";
SqlRowSet rowSet = jdbcTemplate.queryForRowSet(sql);

while(rowSet.next())
{
  String firstName = rowSet.getString("first_name");
  String lastName = rowSet.getString("last_name");
  System.out.println("Vorname: " + firstName);
  System.out.println("Nachname: " + lastName);
  System.out.println("---”);
}

RowMapper

Datenbankabfragen sollen meist in Java Objekte umgewandelt werden. Um nicht bei jeder Abfrage das Ergebnis des SQL-Statements erneut einlesen zu müssen, verschaffen die RowMapper Abhilfe.

Ausgelagerte Rowmapper

Die Klasse muss das Interface RowMapper implementieren und die Methode mapRow überschreiben.

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class CustomerRowMapper implements RowMapper
{
  @Override
  public Customer mapRow(ResultSet rs, int rowNum) throws SQLException
  {
	Customer customer = new Customer();
	customer.setFirstName(rs.getString("first_Name"));
	customer.setLastName(rs.getString("first_Name"));
	customer.setEmail(rs.getString("email"));

	return customer;
  }
}

RowMapper Query

DataSource dataSource = ... //
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String sql = "SELECT * FROM customer";
List customerList = jdbcTemplate.query(sql, new CustomerRowMapper());

Alternative kann der RowMapper natürlich auch als anonyme innere Klasse implementiert werden.

String sql = "SELECT * FROM customer";
List customerList = jdbcTemplate.query(sql, new RowMapper(){

  @Override
  public Customer mapRow(ResultSet rs, int rowNum) throws SQLException
  {
    Customer customer = new Customer();
    customer.setFirstName(rs.getString("first_Name"));
    customer.setLastName(rs.getString("first_Name"));
    customer.setEmail(rs.getString("email"));

    return customer;
  }

});

Das war’s. Viel Spaß beim Abfragen.

XSD Datei aus XML Datei generieren

Simon Michel — Sun, 01 Apr 2012 16:30:10 +0000

Normalerweise ist es so, das mir als Entwickler im WebService Bereich WSDL-Dateien oder XSD-Dateien vorliegen. Aus beiden Dateiformaten lassen sich zur späteren Verarbeitung wunderbar Java Klassen generieren. Vor einiger Zeit hatte ich jedoch das Problem, das mir ein Unternehmen lediglich eine XML-Datei zur Verfügung stellen konnte. Dies ist zugegebenermaßen eine Ausnahme und wohl nur der Versuch eine Art WebService zur Verfügung zu stellen.

Dennoch stand ich vor der Schwierigkeit, die XML-Datei mit Java verarbeiten zu müssen. Natürlich kann an dieser Stelle mühselig ein eigener Wrapper manuell erstellt werden. Effektiv ist aber was anderes …
Auf der Suche nach einer angemesseneren Lösung bin ich über das Kommandozeilen-Tool jing-trang gestolpert.

Ziemlich einfach, ziemlich effektiv.

Anhand eines kleinem Beispiels werde ich das Tool nun demonstrieren. Verwendet wird die Version trang-20091111.zip (aktueller Stand zum Zeitpunkt der Veröffentlichung dieses Beitrages).

Vorbereitung

Im ersten Schritt wird die aktuelle Jing-Trang Version im Download Bereich heruntergeladen und in ein beliebiges Verzeichnis entpackt. Entpackt habe ich die Datei trang-20091111.zip in folgenden Ordner: ~/Desktop/xsd2xml.
In dem entpacktem Ordner befinden sich vier Dateien, wobei die wichtigste wohl das Tool mit dem Namen trang.jar ist.

XML-Datei

Als Vorlage verwende ich die XML-Datei aus dem Java und XML Tutorial. Einziger Unterschied: Die Verlinkung auf die DTD Datei (< !DOCTYPE literature SYSTEM "literature.dtd">) wurde entfernt.

Die Datei befindet sich in dem Verzeichnis ~/Desktop/xsd2xml.

Hierzu ein kleiner Auszug aus der Datei.




  
    
      
        Helmut
        Vonhoegen
      
    
    Einstieg in XML
    
      Galileo Computing
      2
      2004
    
    3-89842-488-X
  
  
  ...

XSD-Datei generieren

Zur Generierung der XSD-Datei wird das Tool mit zwei Parametern aufgerufen. Der erste Parameter (literatur.xml) gibt die Quelldatei an, der zweite (literatur.xsd) die Zieldatei.

java -jar ~/Desktop/xsd2xml/trang-20091111/trang.jar literatur.xml literatur.xsd

Ergebnis

Erstellt wurde wie erwartet die Datei literatur.xsd in dem Verzeichnis ~/Desktop/xsd2xml/.

Ein kleiner Tipp: Wenn das Tool öfter Verwendung findet könnte darüber nachgedacht werden den Link auf die trang.jar Datei in die bashrc als alias zu schreiben, um nicht jedes Mal den vollqualifizierten Pfad angeben zu müssen. Konkret könnte dies so aussehen:

alias xml2xsd='java -jar ~/Desktop/xsd2xml/trang-20091111/trang.jar'

Die Generierung einer Datei wird dann wie folgt aufgerufen:

xml2xsd literatur.xml literatur.xsd

Das Beispiel kann mit allen vollständigen Dateien als ZIP Datei heruntergeladen werden.

Viel Spaß

Verlosung: BitDefender Internet Security 2012

Simon Michel — Sun, 18 Mar 2012 22:17:06 +0000

Als langjähriger BitDefender Kunde habe ich nun fünf kostenlose BitDefender-Lizenzschlüssel für das Produkt Bitdefender Total Security 2012 erhalten.
Die Aufforderung die Lizenzschlüssel an Freunde weiter zu reichen, nutze ich um die treuen (Windows) Leser von itblogging.de zu erfreuen.
Daher werde ich die Lizenzen unter allen Teilnehmern verlosen. Also: Mitmachen, weiter sagen und gewinnen.

Teilnahme

Es nimmt jeder Leser teil, der diesen Blogeintrag kommentiert. Für die Verlosung ist eine gültige E-Mail Adresse erforderlich. Jeder Teilnehmer hat die gleichen Chancen.

Dauer der Verlosung

Es nehmen alles Leser teil, die bis Mittwoch den 21.03.2012 um 19:00 Uhr einen Kommentar mit einer gültigen E-Mail Adresse verfassen.

Auslosung

Die Auslosung werde ich durch ein Zufallsprinzip vornehmen und die Gewinner am Mittwoch den 21.03.2012 ab 20 Uhr an dieser Stelle veröffentlichen.

Produktinformationen

Die Lizenz gilt für folgendes Produkt: BitDefender Internet Security 2012. Die Lizenz ist gültig für einen PC mit eine Dauer von einem Jahr. Wert einer Lizenz: 49,95 EURO.

Informationen von BitDefender:

Bitdefender Internet Security 2012 kombiniert Virenschutz, Spam-Schutz, Phishing-Schutz, Firewall, Kindersicherung und Sicherheit in sozialen Netzwerken in einer Lösung, die idealen Hintergrundschutz für Familien mit Internet-Anschluss bietet.

Noch ein Hinweis: Da die BitDefender Lizenzen am Mittwoch ablaufen, müssen die Gewinner noch am gleichen Abend die Lizenzschlüssel bei BitDefender aktivieren. Gut möglich das dies auch noch Tage später klappt, dies kann ich jedoch nicht garantieren.

Ich übernehme keine Garantie für die Gültigkeit der Lizenzschlüssel. Diese habe ich von BitDefender per E-Mail erhalten und möchte sie an dieser Stelle lediglich an meine Leser weiterreichen.

Noch etwas: Ich freue mich über jeden RSS-Feed Abonnierer, Follower auf twitter oder auf Google+.

Viel Glück

Firefox und Thunderbird 9 auf Ubuntu 11.10

Simon Michel — Thu, 29 Dec 2011 21:05:04 +0000

Ubuntu 11.10 Nutzer wundern sich wahrscheinlich, warum seit längerer Zeit der neue Firefox sowie Thunderbird in der Version 9 auf dem Markt ist, jedoch keiner der beiden Softwareanwendungen sich automatisch aktualisiert.
Das Hinzufügen eines Personal Package Archive (ppa) bringt die Lösung.

Einfach die folgenden drei Linux Befehle in die Konsole kopieren, Firefox und Thunderbird neustarten, fertig.

sudo apt-add-repository ppa:ubuntu-mozilla-security/ppa
sudo apt-get update
sudo apt-get dist-upgrade

Update: Das Hinzufügen des Repositories aktualisiert Firefox und Thunderbird stets auf die aktuellsten Versionen (Aktuell: Firefox 10, Thunderbird 10). Durch den Updatechannel werden stets die neusten Versionen über die Aktualisierungsverwaltung zeitnah nach der Veröffentlichung durch Mozilla aktualisiert.

Personalisierte Starter auf dem Unity Desktop und im Startmenü anlegen

Simon Michel — Thu, 22 Dec 2011 22:36:56 +0000

Durch die endgültige Umstellung auf den Unity Desktop in der Ubuntu Version 11.10, muss sich wohl jeder der sich dazu entschieden hat Ubuntu treu zu bleiben, nun doch gezwungenermaßen mit dem neuen Desktop auseinandersetzen. Mich persönlich konnte bis heute der Unity Desktop noch nicht überzeugen, wo doch einige ganz simple Funktionen ohne jedes Verständnis weggefallen sind. Allein die Tatsache wie schwer es dem Anwender gemacht wird, das Startmenü nach belieben zu modifizieren oder aber einen Starter auf den Desktop zu erstellen, ist für mich nicht nachvollziehbar. Inzwischen habe ich für dieses “Problem” eine Lösung gefunden, die ich nicht für mich behalten möchte.

Zunächst einmal habe ich mir ein eigenen Ordner für die personalisierten Starter in meinem Home Verzeichnis angelegt.

/home/simon/starter

Anschließend wird die Firefox Desktop Konfigurationsdatei (dies klappt natürlich auch mit jeder anderen Desktop Konfigurationsdatei) aus dem Applications Ordner in meinen “starter” Ordner kopiert.

/usr/share/applications

Einmal in den Terminal gewechselt werden neue Rechte vergeben und der Eigentümer gewechselt:

sudo chown simon:simon firefox.desktop

sudo chmod 744 firefox.desktop

Zum Schluss noch die Starterkonfiguration mit einem Link zu der Anwendung füllen, einen neuen Namen und eine Beschreibung geben, fertig.
Der folgende Screenshot zeigt beispielsweise mein Starter zu der Eclipse IDE.

Eine Kopie dieses Starters kann nun beliebig auf den Desktop oder aber auch in das Startmenü gezogen werden.