Es stellt sich also folgende Frage:

• Session unterdrücken in Tomcat / JSP
• Tomcat keine Sessions
• JSP / Tomcat ohne Sessions

Im Prinzip ist die Lösung sehr einfach. Man muss nur zwei einfache Regeln befolgen.

1. Mache nur nur request.getSession() calls wenn Du wirklich eine neue oder die bestehende Session brauchst (Login, etc.). Überlege Dir auch, ob nicht request.getSession(false) reicht (= nur eine bereits bestehende Session zurückgeben, aber keine neue Anlegen falls noch keine existiert).
2. Setze in allen JSPs die Direktive <%@ page session="false" %> um das automatische Erzeugen einer Session im JSP-Code zu unterbinden. Wenn Du die Session doch in einer JSP brauchen solltest, erstelle sie vorher in einem Controller.

1. BufferedReader verbessert die Lesegeschwindigkeit aus anderen Readern (z.B. FileReader um von der Festplatte zu lesen) drastisch,
2. BufferedReader hat praktischer Weise eine readLine() Methode, mit deren Hilfe man ganze Zeilen lesen kann.

In Prinzip ist der BufferedReader auch nur ein Reader. Das heisst er hat die typischen read(…) Methoden. Intern aber, arbeitet der BufferedReader auf einem Speicherbereich (dem Buffer), den er erst füllt, bevor seine read(…) Methoden darauf arbeiten können. Das heisst, dass der BufferedReader größere Datenblöcke auf einmal lesen kann und die dann nach und nach an den äußeren Reader weiterleiten kann. Das ist insbesondere sinnvoll bei Readern die von wiederum von Low-Level Readern lesen, die jeweils bei größeren Datenblöcken performant sind, wie typischer Weise von der Festplatte oder vom Socket.

Ein typischer Gebrauch eines BufferedReaders sieht so aus:

InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream (textFile), encoding );
BufferedReader bufferedReader = new BufferedReader (inputStreamReader);

Uebrigens, JDK heisst Java Development Kit, und SDK Software Development Kit. Es nimmt sich aber defacto nichts.

Ist man nun bei SUN gelandet, gibt es drei Varianten zum downloaden.

• Java SE: steht fuer Standard Edition ist ziemlich sicher das was Du suchst wenn Du das klassische Javapaket fuer den Deskop runterladen willst (JRE und JDK)
• Java ME: steht fuer Mobile Edition und beinhaltet eine auf fuer Handies zugeschnittene Java Plattform (mit Compiler) mit reduzierten Bibliotheken
• Java EE: steht fuer Enterprise Edition und ist deutlich umfangreicher als die Standard Edition und enthaelt zusaetzliche, business nahe Tools wie den Glassfish Application Server

Ich hoffe das hilft.

• Maven tests ausschalten
• mvn ignoriere test fehler

Wenn man trotzdem seinen maven snapshot bauen möchte, müssen aber die tests failures ignoriert werden. Das wird mittels einer Property direkt auf der Kommandezeile bewerkstelligt. Da ich dieses Property andauernd vergesse, möchte ich es mir hier selbst und der Allgemeinheit nochmals vor Augen führen:

mvn -Dmaven.test.failure.ignore=true install

Hope that helps…

Insgesammt ist das Spiel sehr ähnlich wie WoW. Es gib Charakerklassen innerhalb einer Reihe von Spezies die sich wieder zu Verbänden zusammengeschlossen haben. Neu ist allerdings, dass man im Weltraum, wie auch auf Bodenmissionen tätig werden kann. Dabei wird man tatkräftig von drei Bodenoffizieren unterstützt die einem zur Seite stehen.

After extracting Cassandra to some folder (on my Windows box I placed it directly in D:\cassandra), the only file you need to edit is conf/storage-conf.xml. While Cassandra is engineered to run on a large number of machines in a network, we start it here as a single node with the default parameter set, so that most of the settings are ok for now.

If your are not on a Unix-like system, you need to update the folders where Cassandra is supposed to store the data. If your using Windows (like me), then find the following lines in conf/storage-conf.xml and change the paths to something sensible

<CommitLogDirectory>/var/lib/cassandra/commitlog</CommitLogDirectory>
<DataFileDirectories>
      <DataFileDirectory>/var/lib/cassandra/data</DataFileDirectory>
</DataFileDirectories>
<CalloutLocation>/var/lib/cassandra/callouts</CalloutLocation>
<BootstrapFileDirectory>/var/lib/cassandra/bootstrap</BootstrapFileDirectory>
<StagingFileDirectory>/var/lib/cassandra/staging</StagingFileDirectory>

like for example my settings:

<CommitLogDirectory>D:/cassandra/data/commitlog</CommitLogDirectory>
<DataFileDirectories>
       <DataFileDirectory>D:/cassandra/data/data</DataFileDirectory>
</DataFileDirectories>
<CalloutLocation>D:/cassandra/data/callouts</CalloutLocation>
<BootstrapFileDirectory>D:/cassandra/data/bootstrap</BootstrapFileDirectory>
<StagingFileDirectory>D:/cassandra/data/staging</StagingFileDirectory>

Let’s take Cassandra for a spin and check if she starts up correctly. For Mac OS, Linux, etc. users, simply change to the bin directory of Cassandra and run ./cassandra. As an aside for the impatient, I start Cassanda with sudo to avoid trouble with the Cassandras system.log.

Windows users, however, that use the command line (meaning not Cygwin) cannot start it just like that. The cassandra.bat didnt work for me on my Vista box if executed with bin being the current working directory (probably due to the CASSANDRA_HOME environment variable that get’s incorrectly set in the batch file). BUT it works perfect if you call bin\cassandra.bat from Cassandra’s main directory above bin. So if you are on Windows, change to the directory where you extracted Cassandra and execute bin\cassandra.bat.

Cassandras output on startup will look similar to this (here on Mac OS):

Schabbys-MacBook-Pro:bin johannes$ sudo ./cassandra
Schabbys-MacBook-Pro:bin johannes$ Listening for transport dt_socket at address: 8888
DEBUG - Loading settings from ./../conf/storage-conf.xml
DEBUG - Syncing log with a period of 1000
DEBUG - opening keyspace Keyspace1
DEBUG - adding Super1 as 0
DEBUG - adding Standard2 as 1
DEBUG - adding Standard1 as 2
DEBUG - adding StandardByUUID1 as 3
DEBUG - adding LocationInfo as 4
DEBUG - adding HintsColumnFamily as 5
DEBUG - opening keyspace system
DEBUG - INDEX LOAD TIME for /Users/johannes/cassandra/data/system/LocationInfo-1-Data.db: 0 ms.
DEBUG - INDEX LOAD TIME for /Users/johannes/cassandra/data/system/LocationInfo-2-Data.db: 0 ms.
DEBUG - INDEX LOAD TIME for /Users/johannes/cassandra/data/system/LocationInfo-3-Data.db: 0 ms.
INFO - Replaying /Users/johannes/cassandra/commitlog/CommitLog-1257980407451.log
DEBUG - Replaying /Users/johannes/cassandra/commitlog/CommitLog-1257980407451.log starting at 117
DEBUG - Reading mutation at 117
DEBUG - replaying mutation for system.L: {ColumnFamily(LocationInfo [Generation,])}
INFO - Flushing Memtable(LocationInfo)@228828460
DEBUG - Submitting LocationInfo for compaction
INFO - Completed flushing Memtable(LocationInfo)@228828460
INFO - Compacting [/Users/johannes/cassandra/data/system/LocationInfo-1-Data.db,/Users/johannes/cassandra/data/system/LocationInfo-2-Data.db,/Users/johannes/cassandra/data/system/LocationInfo-3-Data.db,/Users/johannes/cassandra/data/system/LocationInfo-4-Data.db]
DEBUG - index size for bloom filter calc for file  : /Users/johannes/cassandra/data/system/LocationInfo-1-Data.db   : 256
DEBUG - index size for bloom filter calc for file  : /Users/johannes/cassandra/data/system/LocationInfo-2-Data.db   : 512
DEBUG - index size for bloom filter calc for file  : /Users/johannes/cassandra/data/system/LocationInfo-3-Data.db   : 768
DEBUG - index size for bloom filter calc for file  : /Users/johannes/cassandra/data/system/LocationInfo-4-Data.db   : 1024
DEBUG - Expected bloom filter size : 1024
INFO - Compacted to /Users/johannes/cassandra/data/system/LocationInfo-5-Data.db.  0/255 bytes for 0/1 keys read/written.  Time: 150ms.
DEBUG - collecting Generation:false:4@3
DEBUG - collecting Token:false:16@0
INFO - Saved Token found: 160533723849634883377008460059010504450
DEBUG - Starting to listen on 127.0.0.1:7001
DEBUG - Binding thrift service to localhost:9160

I think that’s it. Leave a comment if you run in trouble or check the nice If Something Goes Wrong page in the Cassandra Wiki.

I have been toying around with Cassandra for quite some time now. From all NOSQL databases I have seen (and there are quite a few already as Michael pointed out to me earlier), Cassandra seems to be the most promising one to me for reasons that are definitely worth discussing, but are here be beyond the scope of this post.

Data Model

Cassandras data model has been described more than once. In contrast to the descriptions above, I will try to follow a more javaish view which I find easiest and most powerful to work with. I thereby start describing Cassandras data model as nested hash maps.

The way in which data get’s stored in key/value based databases like Cassandra strongly resembles the use of ordinary hash maps. To recall, hash maps store data for a (unique) key. The key is also later used to retrieve the data from the hash map. For example, in order to map string keys to byte arrays you would write in Java

Map<String, byte[]> map = new HashMap<String, byte[]>();

This principle stays the same with Cassandra. However, in Cassandra you do not have a single hash map but up to three layers of nested hash maps! What does the mean? Imagine you dont store your values in a single byte array for each key, but again in a hash map, like

Map<String, Map<byte[], byte[]>> map = new HashMap<String, Map<byte[], byte[]>>();

This way you would partition the data you want to store as key/value pairs that are first filled in the data hash map. The data hash map then gets inserted in the higher-order hash map for a given key string. Similarly, to retrieve a value, you would provide the key string and get the data hash map from which you would extract the value you are interested in.

Let us further assume that we dont want to store the key/value pairs as two individual values, but coupled in a class called “Column” so that our data model would look like this:

Map<String, Map<byte[], Column>> map = new HashMap<String, Map<byte[], Column>>();

Where Column is defined as:

class Column {
    byte[] name;
    byte[] value;
    long timestamp;
 
    public Column(byte[] name, byte[] value) {
         this.name = name;
         this.value = value;
         this.timestamp = System.currentMillis();
    }
}

This is already pretty close to what is called a Column Family in Cassandra. You need to restrain yourself from deriving something from the name “Column”. Also ignore timestamp which is used by Cassandra to avoid data inconsistency and which shall not bother us here.

Before we go on, let us have a look on a concrete example on how you would need to work with this kind of data structure. Let us assume we want to store the profile data of a single user for some imaginary social networking website.

/* data model to store user profiles */
Map<String, Map<byte[], Column>> user = new HashMap<String, Map<byte[], Column>>();
 
/* create a user 'schabby' */
user.put("schabby", new HashMap<byte[], Column>());
 
/* fill in some profile data for user 'schabby' */
Column age = new Column("age".toBytes(), new byte[]{ 27b });
user.get("schabby").put(age.name, age);
 
Column realName = new Column("real name".toBytes(), "Johannes Schaback".toBytes());
user.get("schabby").put(realName.name, realName);
 
Column nationality = new Column("nationality".toBytes(), "German".toBytes());
user.get("schabby").put(nationality.name, nationality);

Again, do not get confused by the use of the byte arrays where normal string would make more sense. This is to resemble the Cassandra data model as close as possible. You will later realize that it’s actually quite nifty to keep the inner hash map byte based for the price of manually converting everything to byte arrays.

If we want to retrieve values from our data structure, we would need to do as follows:

byte age = user.get("schabby").get("age".toBytes()).value[0];
String realName  = new String(user.get("schabby").get("real name".toBytes()).value);
String nationality= new String(user.get("schabby").get("nationality".toBytes()).value);

And this is it. There is not much more conceptual stuff to understand in order to use Cassandra. So we are now ready to project this structure to Cassanda terminology.

Column Family

Cassandra structures its data model in keyspaces, Column Families (CF), Columns and SuperColumns.

A keyspace is a namespace to group Column Families and can be compared to a schema or single database in the SQL world. A keyspace contains one or more Column Families.

A Column Family can be seen as a multidimensional hash map like the one in our example above. In the SQL analogy, you may see a Column Family as a single table that belongs to a schema, however this comparison will not take you far. It is really more a dynamically growing and shrinking hash map rather than a table with fixed columns. Still, in Cassandras terminology you speak of rows when you refer to the hash map that you get for a key string.

Rows are accessed by string keys and each row – which can be seen as a “data hash map” – has several columns. Each column within a row is a bundled pair of a byte array key (a.k.a name) and its byte array data field (a.k.a. value) very similar to our example.

Depending on your configuration, you can let Cassandra apply a sorting scheme to impose an order over your columns in a row. This enables to query ranges over columns. For example, imagine a telephone book from which you want to retrieve all names starting with “Smi”. In Java terms, this could be compared to using SortedMap instead of Map. But we sticked to Map for simplicity here.

SuperColumns

The cool thing about Cassandra is its support for an additional hash map layer. This additional layer is added to the Column layer and enables you to store and access your data as a hash map in a hash map in a hash map, or in other words, as a three dimensional hash map. This additional hash map is called a SuperColumn (SC)

In our Java-like example, a Column Family with SuperColumns look like

Map<String, Map<byte[], SuperColumn>> superColumn 
     = new HashMap<String, Map<byte[], SuperColumn>>();

where SuperColumn is again a hash map over columns like

class SuperColumn extends HashMap<byte[], Column>
{
}

Again, I want to point out that the actual SuperColumn definition in Cassandra is different and that this explanatory definition is not too accurate, but nicely serves the illustration purpose.

Similar to normal Columns, the values within a SuperColumn are also stored in an order depending on your configuration, enabling to cut out slices from your SuperColumns.

To continue our social networking site example, let us have a look on how SuperColumns are used to store the friend and relations of the user ’schabby’.

/* create ColumnFamily with SuperColumns */
Map<String, Map<byte[], SuperColumn>> columnFamily = new HashMap<String, Map<byte[], SuperColumn>>();
 
/* prepare a SuperColumn for 'schabby' */
columnFamily.put("schabby", new HashMap<byte[], SuperColumn>());
 
/* create SC to store friend info */
SuperColumn friends = new SuperColumn();
 
/* fill in some friends */
Column friend1 = new Column("friend_1".toBytes(), "Merry".toBytes());
friends.put(friend1.name, friend1);
 
Column friend2 = new Column("friend_2".toBytes(), "Robert".toBytes());
friends.put(friend2.name, friend2);
 
Column friend3 = new Column("friend_3".toBytes(), "Susan".toBytes());
friends.put(friend3.name, friend3);
 
/* finally store SC in Colunm Family */
columnFamily.get("schabby").put("friends".toBytes(), friends);

We are free to create another SuperColumn in the same Column Family to store other list-like data for ’schabby’, for example his inbox.

/* ... continued example */
 
SuperColumn inbox = new SuperColumn();
 
/* add two mails to inbox */
Column mail1 = new Column("Hi Schabby".toBytes(), "I hope you are well! Cheers, Nick".toBytes());
inbox.put(mail1.name, mail1);
 
Column mail2 = new Column("Welcome".toBytes(), "some message body".toBytes());
inbox.put(mail2.name, mail2);
 
columnFamily.get("schabby").put("inbox".toBytes(), inbox);

Retrieving the mails from the inbox is straight forward:

/* continued example */
 
SuperColumn inbox = columnFamily.get("schabby").get("inbox".toBytes());
 
for(byte[] subject: inbox.keySet())
{
   String body = inbox.get(subject);
   // do something with subject/body
}

And this is it. I hope this enlightened your understanding of Cassandras data model. It’s not that difficult all in all, especially when you start using it.

Please leave some comments for corrections and feedback.

The updated API got more coherent and consistent. Its changes mainly address the new authentication model and the application store in which you can feature your own applications based on Zanox data.

Now for the purpose of this post, I sum up how to connect to Zanox SOAP API using Java. There are several steps to do, mostly administrative in nature.

Get the keys

Zanox implements a shared key authentication model. Therefore, you need to get yourself the right keys (public and private) to get started. Here’s the page that describes how to get them. Once you created your own application, you will receive the following keys that are necessary prerequisites for your code

• zanox Application ID
• Connect ID
• Public key
• zanox secret key (aka. private key)

Generate Zanox SOAP Beans From WSDL

Once you have the keys, you need to generate the classes from the WSDL. For the purpose of this post, we used the (currently latest) WSDL on

http://api.zanox.com/wsdl/2009-07-01

with the endpoint at

http://api.zanox.com/soap/2009-07-01

We used wsimport to generate the classes as follows

wsimport -d bin -s src -p com.zanox.api.namespace._2009_07_01 http://api.zanox.com/wsdl/2009-07-01

This should generate you a bunch of class in in the src folder.

Example Code to Connect to Zanox SOAP API

In order to run our example code, you need to setup your classpath with the following libraries (actually I am not sure if they are really all necessary)

• XmlSchema-1.4.3.jar
• asm-2.2.3.jar
• cxf-2.1.4.jar
• geronimo-activation_1.1_spec-1.0.2.jar
• geronimo-annotation_1.0_spec-1.1.1.jar
• geronimo-jaxws_2.1_spec-1.0.jar
• geronimo-stax-api_1.0_spec-1.0.1.jar
• geronimo-ws-metadata_2.0_spec-1.1.2.jar
• jaxb-api-2.1.jar
• jaxb-impl-2.1.9.jar
• jaxb-xjc-2.1.9.jar
• saaj-api-1.3.jar
• saaj-impl-1.3.2.jar
• wsdl4j-1.6.2.jar
• wstx-asl-3.2.6.jar
• xml-resolver-1.2.jar

Alrighty, we got all we need to fill in the last bricks. The example code conncets to the API and retrieves the sales of the specified date. The API holds far more methods for different purposes, but they are quit similar in use and once you got the sale-example working (even though you might not generate any sales yet) you can easily infere the correct usage and parameter sets for all other methods.

Create two classes: ZanoxAuthenticationDto and SoapZanoxFacade. The first DTO is just to hold the authentication data and looks like this:

public class ZanoxAuthenticationDto
{
	private String applicationId;
	private String connectId;
	private String sharedKey;
	private String privateKey;
 
 // ... according getter and setter methods
 //  are left out for simplicity reasons
}

In the SoapZanoxFacade class we do the actual work and contain all following code snippets.

We first define a couple of helper methods. The most important one is certainly the one to compute the correct signature that is sent to Zanox for every request.

    public static String createSoapSignature(final String serviceName, final String serviceMethod, final String timestamp, String nonce, String secreyKey) 
    {
        final String HMAC_SHA1_ALGORITHM = "HmacSHA1";
 
        // Acquire an HMAC/SHA1 from the raw key bytes.
        SecretKeySpec signingKey = new SecretKeySpec(secreyKey.getBytes(), HMAC_SHA1_ALGORITHM);
 
        // Acquire the MAC instance and initialize with the signing key.
        Mac mac = null;
        try 
        {
            mac = Mac.getInstance(HMAC_SHA1_ALGORITHM);
            mac.init(signingKey);
        } 
        catch (Exception e) 
        {
            throw new RuntimeException("trouble while initiating/signing", e);
        }
 
        String input = serviceName.toLowerCase() + serviceMethod.toLowerCase() + timestamp + nonce;
 
        // Compute the HMAC on the digest, and set it.
        String signature = new BASE64Encoder().encode(mac.doFinal(input.getBytes()));
        return signature;
    }

Another one to format the timestamp

    public static String createSoapTimestamp() 
    {
        String fmt = "yyyy-MM-dd'T'HH:mm:ss.000'Z'";
        SimpleDateFormat df = new SimpleDateFormat(fmt, Locale.US);
        df.setTimeZone(TimeZone.getTimeZone("UTC"));
        String date = df.format(new Date());
        return date;
    }

one to converte java.util.Calendar to XmlGregorianCalendar

    public static XMLGregorianCalendar toXmlGregorianCalendar(Calendar c)
    {
    	if( !(c instanceof GregorianCalendar) )
    	{
    		throw new ZanoxWsException("Calendar instance must be of type GregorianCalendar");
    	}
 
    	try
		{
			return DatatypeFactory.newInstance().newXMLGregorianCalendar((GregorianCalendar)c);
		} 
    	catch (DatatypeConfigurationException e)
		{
    		throw new ZanoxWsException(e);
		}    	
    }

and the last one to generate a random string of specified length (aka. nonce)

    public static String createNonce(int length)
    {
    	final String CHARS = "01234567890abcdefghijkmlmnopqrstuvwxyz";
    	StringBuilder sb = new StringBuilder();
    	for(int i=0; i < length; i++)
    		sb.append(CHARS.charAt((int)(Math.random()*CHARS.length())));
 
    	return sb.toString();
    }

The final code snipped finally retrieves the sales:

	/**
	 * Retrieve the first 10K sales for day <code>calTime</code>. 
	 * Paging is hard-wired to first page (in other words: no paging)
	 */
    public void getSales(Calendar calTime, ZanoxAuthenticationDto auth)  
    {
        String timestamp = createSoapTimestamp();
        String nonce     = createNonce(20);
        String signature = createSoapSignature("PublisherService", "GetSales", timestamp, nonce, auth.getPrivateKey());
        XMLGregorianCalendar date = toXmlGregorianCalendar(calTime);
 
        GetSalesRequest getSalesRequest = new GetSalesRequest();
        getSalesRequest.setConnectId(auth.getConnectId());
        getSalesRequest.setDate(date);
        getSalesRequest.setTimestamp(timestamp);
        getSalesRequest.setPage(0);
        getSalesRequest.setItems(10000);
        getSalesRequest.setSignature(signature);
        getSalesRequest.setNonce(nonce);
 
        GetSalesResponse response = null;
 
        try 
        {
            response = getPublisher().getSales(getSalesRequest);
        } 
        catch (Exception e)
        {
            throw new ZanoxWsException("error while fetching sales from Zanox SOAP API", e);
        } 
 
        // TODO: do something sensible with the data...
        for( SaleItem item: response.getSaleItems().getSaleItem())
        {
        	System.out.println(item.getProgram().getValue()+"\t "+item.getSubPublisher().getId()+"\t"+item.getClickId()+" "+item.getAmount()+" "+item.getLptId()+" "+item.getCommission());
        }
    }
 
    private PublisherSoapPortType getPublisher() 
    {
        final PublisherService pubs = new PublisherService();
        return pubs.getPublisherSoapPort();
    }

To run the code, create a main methode where you set up you authentication data and call getSales on SoapZanoxFacade.

    public static void main(String[] args) 
    {
    	ZanoxAuthenticationDto dto = new ZanoxAuthenticationDto();
    	dto.setConnectId("ASL22DKAS223SKD55KAgD");
    	dto.setSharedKey("JY89AFLLA(RKJZZ");
    	dto.setPrivateKey("asdkljah893qisdnfsyniweoi8ynw893nw");
    	dto.setApplicationId("sdfs4w9p4uao8oadf9fusm9d");
 
    	Calendar c = Calendar.getInstance();
    	c.set(2009, 9, 2);
    	SoapZanoxFacade l = new SoapZanoxFacade();
    	l.getSales(c, dto);
    }

This should get you going with the API. All other SOAP requests are built in a similar fashion.

• kann der Zielhost angepingt werden? (Befehl ping auf Kommandozeile)
• Stimmt der angesprochene Port?
• läuft der angesprochene Serverdienst? Gerne blockieren sich zwei Dienste auf dem selben Port (z.B. Tomcat)
• Sind Firewalls installiert, die ein Ansprechen des Zielhostes verhindern?

Google hat ja bekanntlich das nette Feature, zu großen Ereignissen oder wichtigen Feiertagen das Logo auf der Startseite abzuwanden. Das abgeänderte Logo wird Google Doodle genannt. Zur Bundestagswahl 2009 hat Google auch ein Doodle gemalt, das wie folgt aussieht:

Google Doodle Bundestagswahl 2009