• Beispiele und Erklärung der For- und ForEach Schleife
• Was ist mit For bzw. ForEach Loop gemeint?
• Was sind Java Laufvariablen und wie benutze ich sie?

Es werden erst die klassische For-Schleifen besprochen, bevor wir uns den moderneren For-Each Schleifen widmen.

Einführung und Definition

Die For-Schleife dient zum wiederholten ausführen eines Code-Blocks, wobei in jeder Iteration ein Schritt-Operation (zB. Hochzählen einer Variable) ausgeführt wird. Etwas weniger allgemein formuliert kann man sagen, dass sie zum Hoch- oder Runterzählen von Variablen verwendet werden kann. Der englische Begriffe der Schleife ist Loop, daher sind beide Begriffe synonym zu verstehen.

Das folgende Beispiel zählt die variable i von 5 bis 10 hoch:

int i; // die Laufvariable
for(i = 5; i <= 10; i = i + 1)
{
    // ausgeführter Code der die Laufvariable i verwenden kann, zB.
    System.out.println("i = "+i);
}

Wir sehen, dass in dem eingeklammerten Teil vor dem for etwas kryptisches stehts, was offensichtlich zum Verwenden der For-Schleife nötig ist. Dieser Teil läßt sich in drei Teile zerlegen, die jeweils mit einem Semmikolon getrennt sind:

for( Start ; Ende ; In-/Dekrementieren )

Im obigen Beispiel ist besteht der erste Teil (Start) aus dem setzen des Startwertes i = 5, also dass die Schleife bei 5 anfangen soll zu zählen. Häufig wird an dieser Stelle die Deklaration der Variable Der zweite Teil ist das Abbruchkriterium, nämlich i <= 10, was so viel heißt wie, dass i solange hochgezählt wird, bis i kleiner-gleich 10 ist. Der dritte Teil besagt was nach jeder Iteration passieren soll. In diesem Fall wird i um 1 erhöht. Eine häufige Notation die man an dieser Stelle sieht ist i++, was einfach nur eine Kurzform von i = i + 1 ist. Entsprechend ist übrigens i-- nur die Kurzform von i = i - 1. Ein weiteres Beispiel einer For-Schleife sie wie folgt aus:

for(int i = 10; i >= 5; i--)
{
    // ausgeführter Code der die Laufvariable i verwenden kann, zB.
    System.out.println("i = "+i);
}

Diese Schleife zählt ganz offensichtlich runter von 10 auf 5. In diesem Beispiel deklarieren wir i “inline” gleich mit in der Start-Definition der For-Schleife. Das spart uns eine Zeile vorher und es ist klar, dass i nur im Scope des Schleifen-Blocks liegt. Die Definition der Abbruchbedingung ist entsprechend abgewandelt zum ersten Beispiel. Der letzte Teil ist die dekrementierung von i.

Generell kann man also den eingeklammerten Teil der Schleifendefinition wie folgt lesen:

for( Starte bei i=10 und führe ; solange wie i>=5 gilt, ; den Code i-- aus )

Der Unterschied zu einer while-Schleife liegt also darin, dass im eingeklammerten Teil nicht nur die Abbruchbedingung festgelegt wird.

Schleifen können auch verschachtelt werden und so ist es nicht unüblich, dass man zum iterieren über Bilder oder Matrizen zwei For-Schleifen anwendet um mit zwei Laufvariablen einen 2-Dimensionalen Raum abzuwandern. Im folgenden Beispiel iterieren wir über das Google Logo und geben dabei Pixelweise die Farbe aus:

// lade Google Logo
BufferedImage image = ImageIO.read(new URL("http://www.google.de/images/srpr/logo3w.png"));
 
// x iteriert über die Breite des Bildes
for( int x = 0; x < image.getWidth(); x++ )
{
	// y iteriert über die Höhe des Bildes
	for( int y = 0; y < image.getHeight(); y++ )
	{
		// Gib Pixelfarben als Red, Green, Blue, alpha Komponenten auf der Konsole aus.
		int red   = image.getColorModel().getRed(image.getRGB(x, y));
		int green = image.getColorModel().getGreen(image.getRGB(x, y));
		int blue  = image.getColorModel().getBlue(image.getRGB(x, y));
		int alpha = image.getColorModel().getBlue(image.getRGB(x, y));
		System.out.println("Position ("+x+", "+y+"): ["+red+","+green+","+blue+","+alpha+"]");
	}
}

Natürlich können auch andere Werte als Zahlen als Laufvariabe und zur Iteration verwendet werden. So war es früher beispielsweise üblich, dass man Iterator-Objekte verwendete, die den aktuellen Status der Laufvariable wiederspiegelte und mit denen über unterschiedliche Datenstrukturen iteriert werden konnte. Im Prinzip speichern solche Iterator Objekte intern auch nur einen index ab, an welcher Stelle man sich aktuell in der Datenstruktur befindet. Ein Beispiel macht deutlich, was gemeint ist:

// dynamische Liste, so wie sie früher häufig verwendet wurde
Vector<String> vector = new Vector<String>();
 
// wir hängen ein paar Namen an die Liste an
vector.add("Peter");
vector.add("Klaus");
vector.add("Frieda");
vector.add("Manfred");
 
// Vector.iterator() gibt ein Objekt vom Type Iterator zurück
for( Iterator<String> it = vector.iterator(); it.hasNext(); )
{
	// it.next() holt den nächsten Wert aus dem Vector ab
	System.out.println(it.next());
}

Die Ausgabe ist erwartungsgemäß:

Peter
Klaus
Frieda
Manfred

Das interessant an diesem Beispiel ist, dass der letzte Part des in Klammern eingeschlossenen Teils leer bleibt. Das heißt es gibt keinen Iterationsteil. Dieser wird nämlich im For-Block selbst ausgeführt (it.next()).

So weit, so gut. Wollen wir nun zum nächsten Level vordringen.

ForEach Schleifen mit Beispielen

For-Each Schleifen funktionieren ganz ähnlich wie die gewöhnlichen For-Schleifen und sind quasi eine Weiterentwicklung. Im Gegensatz zu den normalen, verwenden ForEach Schleifen aber keine nach außen sichtbare Laufvariable oder Iterator-Objekt, sondern gibt in jeder Iteration immer direkt den Wert zurück. Das heißt aber auch, dass immer über eine entsprechende Datenstruktur iteriert werden muss die das ermöglicht. Schauen wir uns ein Beispiel an:

// definition eine Datenstruktur, hier ein Array mit 9 Werten
int[] array = new int[]{4, 8, 4, 2, 2, 1, 1, 5, 9};
 
// ForEach Schleife
for( int k: array )
{
	System.out.println("k = "+k);
}

Die Ausgabe ist

k = 4
k = 8
k = 4
k = 2
k = 2
k = 1
k = 1
k = 5
k = 9

Man sieht also, dass k nicht die Laufvariable hält, sondern den direkten Wert. ForEarch iteriert also über alle Elemente und ruf den Block auf. Daher kann auch der Name abgeleitet werden: For Each element, do this and that. Intern wird dennoch ein Iterator-Objekt gehalten in dem der State der Iteration festgehalten wird. Da man als Entwickler aber quasi nie am Index der Laufvariable interessiert ist, sondern eigentlich nur an den Werten, macht ForEach jede Menge Sinn. Ein paar Beispiele für weitere Verwendungen von ForEach-Schleifen:

Set<String> set = new HashSet<String>();
set.add("Peter");
set.add("Frieda");
set.add("Manfred");
 
for(String name: set) System.out.println(name);

In diesem Beispiel ist die Reihenfolge der Ausgabe nicht definiert, da es sich um eine Menge (Set) handelt und nicht um eine Liste oder andere order-preserving Datenstruktur. Das Gegenbeispiel dazu ist die Verwendung der ArrayList:

List<String> list = new ArrayList<String>();
list.add("Peter");
list.add("Frieda");
list.add("Manfred");
 
for(String name: list) System.out.println(name);

Und das wars Ich denke Ihr habt nun eine sehr gute Vorstellung davon wie diese Schleifen zu verwenden sind. Wenn ich etwas vergessen habe oder einen Fehler eingebaut habt, laßt es mich bitte wissen. Wenn Euch der Post gefallen, dann laßt auch gern einen Kommentar da.

• Java Arrays mit Beispielen
• Arrays in Java in mehreren Dimensionen

Arrays sind die niedrigsts (low-level) aber auch performanteste Datenstruktur in Java. Sie folgen sehr nah der Hardwarefunktionalität im Speicher des Rechners und sind somit eigentlich ein Überbleibsel aus der C/C++ Welt. Dennoch kann man Arrays in vielen Java-Anwendungen heutzutage noch finden.

Grundlagen

Das klassische Array ist eine Folge von Zahlen fester Länge. Diese Folge von Zahlen liegt als Block im Speicher. Schauen wir uns die folgenden zwei Arrays an.

// Definition eines Arrays das 24 Integerwerte halten kann. Zu beginn sind die alle 0.
int[] array = new int[24];
 
// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
// die eckigen Klammern können auch an die Variable geschrieben werden
int someOtherArray[] = new int[4];

Man definiert die Länge des Arrays, also wie viele Zahlen in das Array passen, wenn man das Array erstellt. Dabei wird der benötigte Speicher reserviert. Der Speicherblock kann nicht ohne weiteres wachsen, was wiederum die Länge des Array. Da die Zahlenarten in dem Array immer nur von einem Typ sind, ist zu beginn klar, wieviel Speicher reserviert werden muss. Für int-Arrays müssen zum Beispiel immer 4 bytes pro Wert vorgehalten werden. Das heißt ein int-Array das 24 Werte halten kann, benötigt 24*4=96 bytes. Streng genommen kommen da sogar nochmal 4 Bytes dazu, weil die Länges des Arrays im selben Speicherblock liegt (Backreferenzen für den Garbage Collector werden kurz mal ausgeblendet).

Die Zahl der Werte eines Arrays (oder eben die “Länge” eines Arrays), kann mit der Konstanten length abgefragt werden:

// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
System.out.println(test.length); // Ausgabe: 7

Um auf die Werte des Arrays zuzugreifen, muss lediglich der Speicherindex angegeben werden:

// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
System.out.println(test[5]); // Ausgabe 32
System.out.println(test[4]); // Ausgabe -5
 
// Um Werte zuzuweisen, wird genauso verfahren
test[5] = 78;
test[4] = 98;
 
System.out.println(test[5]); // Ausgabe 78
System.out.println(test[4]); // Ausgabe 98

Als wichtiger Sonderfall sein bemerkt, dass bei jedem Zugriff auf das Array geprüft wird, ob der Index noch innerhalb der Länge des Arrays liegt. Wenn der Index kleiner 0 oder größer als length ist, wird eine IndexOutOfBoundsException geworfen. Siehe zB:

int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
// schmeisst IndexOutOfBoundsExcpetion!!!
System.out.println(test[5423]);

Arrays aus verschiedenen Datentypen

In den Grundlagen haben wir auf Arrays aus natürlichen Zahlen gearbeitet. Prinzipiell sind natürlich auch andere Datentypen möglich. Schauen wir uns als erstes Beispiele mit primitiven Datentypen an.

int[] intArray = new int[]{33,452,6,23,-5,32,5,-1};
float[] floatArray = new float[3];
double[] doubleArray = new double[521];

Es können auch Arrays aus Objekten gebaut werden. Dabei sei zu beachten, dass beim erstellen des Arrays nicht die Objekte selbst erstellt werden, sondern nur die Pointer auf mögliche Objektinstanzen.

// erstelle 10 Pointer auf Object. Die Pointer sind
// erstmal alle NullPointer.
Object[] objectArray = new Object[10];
 
// wir instatitieren ein neues Objekt mit "new" und lassen den Pointer an 
// Index 0 und 3 auf das neue Objekt zeigen.
objectArray[0] = new Object();
objectArray[3] = new Object();
 
// es wird die toString() Methode des gerade instatitierten 
// Objektes ausgegeben
System.out.println(objectArray[0]);
 
// NullPointerException, weil an Index 2 kein valider Pointer
// auf ein Objekt zeigt.
System.out.println(objectArray[2]);

Eine interessante Mischform nimmt dabei wieder der String ein, da er sich wie immer wie ein Objekt verhält, das aber nicht mit new instatiiert werden muss:

String[] stringArray = new String[42];
stringArray[0] = "hallo";
stringArray[1] = "Juhuuu";
stringArray[2] = "Blablalb";
 
System.out.println(stringArray[0]); // Ausgabe: hallo
System.out.println(stringArray[2]); // Ausgabe: Blablalb
 
// NullPointerException!
System.out.println(stringArray[3]);

So viel zu den Basisics über Arrays. Wenn Euch was fehlt oder Ihr den Post gut fandet, laßt es mich gern in Form eines Kommentars wissen.

Picking is the process of finding objects in you scene based on user input. Most commonly, you want to determine what object a user has clicked with his mouse. In this case the 2D mouse coordinates serve as a reference on the view port to identify the projected objected that has been clicked. A similar scenario is a first person shooter, where the gun serves as the picking pointer, however in world space coordinates. If you shoot your gun, the trajectory of the bullet is traced through your scene and collisions are detected.

A screenshot showing a hex map in an LWJGL application with a selected tile as an example for 3D picking

OpenGL Selection Mode vs. Ray Picking

There are two common ways of implementing picking. The first one makes use of a special OpenGL feature in which you render your scene in a so-called “selection mode”. In selection mode, OpenGL does not render to the frame buffer but gathers depths information of the objects with is later read at the point where your picking occurs. The second approach is called “Ray Picking” and is independent from OpenGL and simulates a line that is shot through the scene until it hits an object. I personally prefer the second approach for the following reasons:

• You don’t need an additional render pass. A render pass can take some considerable amount of time and special clipping/culling code is required to only render the small part of the scene which you want to perform the picking on. In addition, you render a less complex scene (omitting textures, lighting, normals, etc) in selection mode if possible which can add a high degree of complexity to your drawing routines (imagine breaking up display lists). Ray picking obviously requires some code to trace the ray through your scene, but this is usually less complex.
• Ray picking can be done independently from the rest of the game code as a simultaneous and “read-only” operation on the scene graph. In some environments such as AWT/JOGL where the input devices are handled by a separate thread, your picking code can run as part of the handler thread and does not impact the performance of the rest of the game. This comes in handy especially in scenarios where you need to perform picking very often (eg. mouse hovering, target laser on the in-game gun).
• In pretty much all Java environments, calling OpenGL takes a considerable amount of time due to JNI. It is therefore beneficial to minimize the number OpenGL calls. Rendering in selection mode would mean additional OpenGL calls that I rather substitute with ray picking.

However, there are scenarios where ray picking is simply inferior or impractical. Consider picking in a scene with a lot of small details (eg. tree with little branches and leaves) or if you need to know the individual polygon/triangle that you picked. I will therefore cover both approaches, starting with ray picking in this post.

Ray Picking

Ray picking is the process of shooting a line (ie. “ray”) from the camera through the 2D viewscreen (where the 3D scene is projected on) into the scene until it hits an object. To do so, we need to know the camera and the point on the viewscreen (eg. mouse cursor position). The first point is trivial, however the second point is a bit more difficult to determine. Let’s say we have a 2D point on the viewscreen (x, y) and now want to map this point into world coordinates. One way would be to make use of the inverted viewing matrix, but inverting a matrix is usually an expensive undertaking. Instead, we compute the position of the plane of the viewscreen in world space and map the 2D point on this plane and from there into world space.

The algorithm in pseudo code follows below. Note that cameraLookAt is the 3D point where the camera looks at (as used on glLookat), cameraPosition is the current position of the camera in world space and cameraUp is the up vector of the camera.

x = getMouseX() // scalar
y = getMouseY() // scalar

view = cameraLookAt - cameraPosition // 3D float vector
normalize view

h = crossProduct( view, cameraUp ) // 3D float vector
normalize h

v = crossProduct( h, view) // 3D float vector
normalize v

ok, so far for h and v. Note that v is actually pointing in the same direction like the camera-up vector, but we compute it via the cross product to illustrate the method.

The vectors h and v are currently normalized to the length of 1. We now need to compute the lengths of h and v in the view port. In my example I assume that you set up your frustum by a field of view angle in degrees (fovy) as commonly the case with glFrustum. Let nearClippingDistance be the distance to the near clipping plane and width/height the ratio of the view port width divided by the viewport heigth.

// convert fovy to radians
rad = fovy * PI / 180
vLength = tan( rad / 2 ) * nearClippingPlaneDistance
hLength = vLength * (width / height)

scale v by vLength
scale h by hLength

The two scalars vLength and hLength in combinaton with v and h help spanning the view port plane extending from the center point. At this point it is worth mentioning that it may make sense to only compute h and v when you update the camera orientation because the normalization involves a square root which is a relatively expensive operation (actually tan may also be avoided).

Now it is time to map the 2D mouse coordinates onto the view port plane.

// translate mouse coordinates so that the origin lies in the center
// of the view port
x -= width / 2
y -= height / 2

// scale mouse coordinates so that half the view port width and height
// becomes 1
y /= (height / 2)
x /= (width / 2)

// linear combination to compute intersection of picking ray with
// view port plane
pos = cameraPos + view + h*x + v*y

// compute direction of picking ray by subtracting intersection point
// with camera position
dir = pos - cameraPos

That's pretty much it. We now got pos as the intersection point of the picking ray in the view port plane and the picking ray direction dir. This describes a line that can now be used to intersect with the individual objects of the scene.

// brute force
for all objects in the scene
  test for intersection and keep closest
end for

So by intersecting the picking ray with all your visible objects in your scene while keeping track of the distance, you determine the object that is hit by your mouse cursor.
Checking all objects in our scene may not be very efficient though. So in a first attempt I recommend to test only objects that lie (partly) within your viewing frustum. Under normal circumstances you got that code already in your scene graph as part of the software culling routine when pumping obects into the render pipeline.

I hope this helped. If you liked the post or if you got questions, ideas hints or found a problem, please leave a comment. I am trying to answer as quickly as possible. Also, if you want me to send you the source code of this example please let me know, I am happy to share the code.

For this tutorial, I am using

• jogl-b633-2012-01-23_20-37-13, and
• gluegen-b480-2012-01-23_16-49-04.

This is how your project setup should look like:

So one you got the binaries, unpack the ZIP file somewhere. You will notice the jar folder with a number of JAR files. All you need is in that jar folder, because the DLL binaries are included in the JARs.

Create a new eclipse project (name doesnt matter) and add the following JARs on the classpath:

• gluegen-rt-natives-windows-amd64.jar
• gluegen-rt.jar
• jogl-all-natives-windows-amd64.jar
• gluegen-rt.jar

These files are the native part of the OpenGL binding and are linked via Java Native Interface (JNI). Since the DLLs are precompiled as part of the JAR files, you are almost ready to go.

Once you got that set up, create a package de.schabby.jogl.helloworld and copypaste the following two classes in the newly created package.

package de.schabby.jogl.helloworld;
 
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
 
public class HelloWorld 
{
    public static void main(String[] args) 
    {
    	// setup OpenGL Version 2
    	GLProfile profile = GLProfile.get(GLProfile.GL2);
    	GLCapabilities capabilities = new GLCapabilities(profile);
 
    	// The canvas is the widget that's drawn in the JFrame
    	GLCanvas glcanvas = new GLCanvas(capabilities);
    	glcanvas.addGLEventListener(new Renderer());
    	glcanvas.setSize( 300, 300 );
 
        JFrame frame = new JFrame( "Hello World" );
        frame.getContentPane().add( glcanvas);
 
        // shutdown the program on windows close event
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent ev) {
                System.exit(0);
            }
        });
 
        frame.setSize( frame.getContentPane().getPreferredSize() );
        frame.setVisible( true );
    }
}

The Render.java class looks like follows. It implements GLEventListener which is the call-back implementaiton by JOGL to do all OpenGL rendering.

package de.schabby.jogl.helloworld;
 
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
 
class Renderer implements GLEventListener 
{
    private GLU glu = new GLU();
 
    public void display(GLAutoDrawable gLDrawable) 
    {
        final GL2 gl = gLDrawable.getGL().getGL2();
        gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
        gl.glLoadIdentity();
        gl.glTranslatef(-1.5f, 0.0f, -6.0f);
        gl.glBegin(GL2.GL_TRIANGLES);		
        gl.glVertex3f(0.0f, 1.0f, 0.0f);	
        gl.glVertex3f(-1.0f, -1.0f, 0.0f);	
        gl.glVertex3f(1.0f, -1.0f, 0.0f);	
        gl.glEnd();				
        gl.glTranslatef(3.0f, 0.0f, 0.0f);
        gl.glBegin(GL2.GL_QUADS);           	
        gl.glVertex3f(-1.0f, 1.0f, 0.0f);	
        gl.glVertex3f(1.0f, 1.0f, 0.0f);	
        gl.glVertex3f(1.0f, -1.0f, 0.0f);	
        gl.glVertex3f(-1.0f, -1.0f, 0.0f);	
        gl.glEnd();				
        gl.glFlush();
    }
 
 
    public void displayChanged(GLAutoDrawable gLDrawable, boolean modeChanged, boolean deviceChanged) 
    {
    	System.out.println("displayChanged called");
    }
 
    public void init(GLAutoDrawable gLDrawable) 
    {
    	System.out.println("init() called");
        GL2 gl = gLDrawable.getGL().getGL2();
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        gl.glShadeModel(GL2.GL_FLAT);
    }
 
    public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height) 
    {
    	System.out.println("reshape() called: x = "+x+", y = "+y+", width = "+width+", height = "+height);
        final GL2 gl = gLDrawable.getGL().getGL2();
 
        if (height <= 0) // avoid a divide by zero error!
        {
            height = 1;
        }
 
        final float h = (float) width / (float) height;
 
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL2.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, h, 1.0, 20.0);
        gl.glMatrixMode(GL2.GL_MODELVIEW);
        gl.glLoadIdentity();
    }
 
 
	public void dispose(GLAutoDrawable arg0) 
	{
		System.out.println("dispose() called");
	}
}

By right-clicking on the main() method and chosing "run as application", Eclipse will execute the program. You should see something like this:

For the lazy, I provide a video-walkthough.

Common problems and solutions:

• If you get Can't load AMD 64-bit .dll on a IA 32-bit platform, then you are using an 64bit DLL (eg. gluegen-rt.dee) with an JRE that is 32bit. In most cases you can just switch to a 64bit JRE if you are running a 64bit system. Make sure that Eclipse is using the right JRE when you execute the code.
• If you get no gluegen-rt in java.library.path, then you may need to add gluegen-rt-natives-windows-amd64.jar to you classpath.
• If you get no nativewindow_awt in java.library.path, then you may need to add jogl-all-natives-windows-amd64.jar to you classpath.

That's it so far. Please let me know if you have questions or comments.

• recent JOGL binary distribution download
• precompiled Windows Java OpenGL bindings
• you just can not find the place where to download JOGL

I had a couple of hours on my own recently and though it would be a good thing to catch up with the latest developments in the Java+OpenGL environment. So I looked for the download of JOGL (Java Bindings for OpenGL) just to realize, that I is actually quite difficult to find a recent binary distribution of JOGL!

Eventually, after a while I found it: http://jogamp.org/deployment/autobuilds/master/.

There you find an extensive list of directories containing builds, mostly for different binding projects such as gluegen, joal, etc. Search for “jogl” to jump to the JOGL builds.

The downloads are basically a list of (probably automated) builds. So I hope that this will be the place for the next months to get update-to-date JOGL binaries. The builds that have the suffix “-master” in their directory name appear to contain only documentation.

Please also note that for running JOGL you also need gluegen. I personally use the 2012-01-23 release at the moment. This is

• gluegen-b480-2012-01-23_16-49-04
• jogl-b633-2012-01-23_20-37-13

which seem to work.

So the guys at JogAmp.org do actually provide precompiled binaries, they just make it difficult to find them.

Now that you downloaded JOGL, you may be interested in my JOGL Hello World example (includes how to set up the classpath and DLLs right).

Please leave a comment if it helps or my resource gets out of date.

2010-10-20 EDIT: updated download URL.
2010-11-03 EDIT: updated download URL again to point to autobild directory.
2010-11-19 EDIT: added reference to my hello world example with JOGL
2011-07-27 EDIT: updated link to JOGL downloads
2012-01-27 EDIT: updated link to JOGL downloads, added note about gluegen

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…

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.