Java, Webprogrammierung, Linux und mehr

Version 2.2.0 of Struts2 jQuery Plugin is out now. The new Version is Based on latest jQuery UI 1.8.2, see Changelog for more Detail about this version.

Changes since Version 2.1.0:

• Upgrade to jQuery UI 1.8.2
• Upgrade to jqGrid 3.6.5
• Solve  Issue 154 : load from google cdn does not work for jquery ui themes
• Solve Issue 155: Default Loading Text
• Solve Issue 156: onSelectAll topics
• Solve  Issue 157 : useSelectedTabCookies in tabbedpanel broken in 2.1.0
• Solve  Issue 161 : Select options vanish when re-entering the page
• Solve  Issue 170 : Struts2-jquery-plugin not recognizing tag in jsp page
• Solve  Issue 171 : sj:accordion autoHeight does not work
• Solve  Issue 176 : Autcompleter input textfield width should be configurable
• Solve Issue 179: Nested tab didn’t work
• Solve Issue 184: loadingText doesn’t appear to have any effect with jqgrid plugin
• Solve Issue 185: attributes hidegrid, hoverrows and shrinkToFit in grid tag can not be set to false
• Solve Issue 186: how to submit a form while loading grid?
• Solve Issue 188: Some locales does not work, particularly “fr”
• Solve Issue 190: Add Head Tag attribute ‘compatibility’ for an jQuery 1.3 compatibility mode
• Solve Issue 191: deferred loading of dynamic elements
• Solve Issue 192: Default Error Text
• Solve Issue 193: Using base tag with sj:a causes page to reload

Download: http://code.google.com/p/struts2-jquery/downloads/list
Showcase: http://www.weinfreund.de/struts2-jquery-showcase/
Issues: http://code.google.com/p/struts2-jquery/issues/list
User Group: http://groups.google.com/group/struts2-jquery

Bookmark It

Hide Sites

Seit der Europawahl 2009 schafft es die Piratenpartei immer mehr Menschen anzuziehen.
Doch wofür stehen die Piraten eigentlich? Seit gestern existiert ein neuer Wahlwerbespot der Piratenpartei der diese Frage beantworten soll.

Ich finde das Video wirklich gelungen und es bringt die Forderungen der Piraten gut herüber.

Bookmark It

Hide Sites

Durch das Jersey Projekt existieren Bibliotheken die es Java Entwicklern besonders einfach machen REST Web Services zu entwickeln. In diesem Tutorial werde ich zeigen wie einfach es ist eine Web Service zu schreiben der uns einfache Mathematische Berechnung zurückliefert.

1.)
Wir erstellen in unserer Entwicklungsumgebung, in meinem Beispiel Eclipse, ein Web Projekt.  In das WEB-INF/lib Verzeichnis packen wir alle für Jersey benötigten JARs die es bei Jersey/Downloads runterzuladen gibt.  Für dieses Tutorial benötigen wir folgende Bibliotheken: jersey-server.jar, jersey-core.jar, jsr311-api.jar, asm.jar, jaxb-impl.jar, jaxb-api.jar, activation.jar, stax-api.jar

2.)
In unserer WEB-INF/web.xml fügen wir folgendes hinzu:

  <servlet>
  	<display-name>JAX-RS REST Servlet</display-name>
  	<servlet-name>REST-Servlet</servlet-name>
  	<servlet-class>
  		com.sun.jersey.spi.container.servlet.ServletContainer
  	</servlet-class>
  	<load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  	<servlet-name>REST-Servlet</servlet-name>
  	<url-pattern>/services/*</url-pattern>
  </servlet-mapping>

3.)
Wir erstellen zwei Klassen die wir für unser Ergebniss benötigen.

Die erste Klasse MathResults kapselt unsere Mathematischen Ergebnisse.

package de.wstest;
 
public class MathResults {
	private String formel;
	private Integer ergebniss;
	public String getFormel() {
		return formel;
	}
	public void setFormel(String formel) {
		this.formel = formel;
	}
	public Integer getErgebniss() {
		return ergebniss;
	}
	public void setErgebniss(Integer ergebniss) {
		this.ergebniss = ergebniss;
	}
}

Und die zweite Klasse ServiceResult ist das Result unseres WebService

package de.wstest;
 
import java.util.List;
 
import javax.xml.bind.annotation.XmlRootElement;
 
@XmlRootElement
public class ServiceResult {
	private String message;
	private Integer returncode;
	private List<MathResults> ergebnisse;
 
	public Integer getReturncode() {
		return returncode;
	}
	public void setReturncode(Integer returncode) {
		this.returncode = returncode;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
 
	public List<MathResults> getErgebnisse() {
		return ergebnisse;
	}
	public void setErgebnisse(List<MathResults> ergebnisse) {
		this.ergebnisse = ergebnisse;
	}
}

4.)
Jetzt erstellen wir eine weitere Klasse CalculatorService, diese ist unser eigentlicher Webservice und wird durch Annotions als dieser gekennzeichnet. Ein gute Übersicht über zulässige Annotions findet Ihr im Wiki von Jersey.

package de.wstest;
 
import java.util.LinkedList;
import java.util.List;
 
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
 
@Produces("application/xml")
@Path("calculator")
public class CalculatorService {
 
	@GET
	@Path("calc")
	@Produces("application/xml")
	public ServiceResult add(@QueryParam("a") Integer a, @QueryParam("b") Integer b) {
 
		ServiceResult r = new ServiceResult();
		List<MathResults> ergs = new LinkedList<MathResults>();
 
		if(a == null || b == null)
		{
			r.setMessage("No Values!");
			r.setReturncode(8);
			r.setErgebnisse(ergs);
			return r;
		}
 
		r.setMessage("Results for Value a = "+a+", Value b = "+b);
		r.setReturncode(0);
		MathResults e1 = new MathResults();
		e1.setFormel("a + b");
		e1.setErgebniss(a+b);
		MathResults e2 = new MathResults();
		e2.setFormel("a - b");
		e2.setErgebniss(a-b);
		MathResults e3 = new MathResults();
		e3.setFormel("a * b");
		e3.setErgebniss(a*b);
 
		ergs.add(e1);
		ergs.add(e2);
		ergs.add(e3);
 
 
		r.setErgebnisse(ergs);
		return r;
	}
}

Fertig ist unsere RESTFull Webservice. Nach dem deployen in einem ServletContainer wie Tomcat erhalten wir nach einem Aufruf des Webservices im Browser

http://localhost:8080/wstest/services/calculator/calc?a=234&b=456

folgendes Ergebniss:

<serviceResult>
	<ergebnisse>
		<ergebniss>690</ergebniss>
		<formel>a + b</formel>
	</ergebnisse>
	<ergebnisse>
		<ergebniss>-222</ergebniss>
		<formel>a - b</formel>
	</ergebnisse>
	<ergebnisse>
		<ergebniss>106704</ergebniss>
		<formel>a * b</formel>
	</ergebnisse>
	<message>Value a = 234, Value b = 456</message>
	<returncode>0</returncode>
</serviceResult>

Durch einen Aufruf der URL

http://localhost:8080/wstest/services/application.wadl

erhalten wir eine Übersicht über unsere Services und deren Parameter.

<application xmlns="http://research.sun.com/wadl/2006/10">
    <doc xmlns:jersey="http://jersey.dev.java.net/" jersey:generatedBy="Jersey: 1.0 10/13/2008 12:27 PM"/>
    <resources base="http://localhost:8080/wstest/services/">
        <resource path="calculator">
            <resource path="calc">
                <method name="GET" id="add">
                    <request>
                        <param xmlns:xs="http://www.w3.org/2001/XMLSchema" type="xs:int" style="query" name="a"/>
                        <param xmlns:xs="http://www.w3.org/2001/XMLSchema" type="xs:int" style="query" name="b"/>
 
                    </request>
                    <response>
                        <representation mediaType="application/xml"/>
                    </response>
                </method>
            </resource>
        </resource>
    </resources>
</application>

Fertig ist in wenigen Schritten unser REST Web Service der uns eine Liste von Berechnungen für einen Eingabe zurückliefert.

Bookmark It

Hide Sites

Mit Axis2 ist das Erstellen von Webservices für Java Programmierer noch einfacher geworden. Mit folgendem kleinen Beispiel will ich zeigen, wie man einen Webservice programmieren kann, der von Spring ein Bean injiziert bekommt.

Als Erstes erstellen wir unseren Webservice als einfache Java Klasse:

package com.jgeppert.services;
 
import com.jgeppert.dao.MyDAO;
 
private MyDAO myDAO;
 
public class MyWebService
{
	/* Die Funktion add() ist unsere Webservice Operation die
	 * dann mit einem Client angesprochen werden kann.
	 */
	public String add(String text)
	{
		try
		{
			myDAO.save(text);
			return "insert successfully";
		}
		catch(RuntimeException e)
		{
			return e.getMessage();
		}
	}
 
	// Mit dieser Methode injiziert uns Spring unser DAO Objekt
	public String setMyDAO(MyDAO myDAO)
	{
		this.myDAO = myDAO;
	}
}

Als Zweites brauchen wir für Aris2 eine service.xml mit folgendem Inhalt:

<service>
	<description>My First WebService</description>
	<parameter name="ServiceClass" locked="false">
		com.jgeppert.services.MyWebService
	</parameter>
    <parameter name="ServiceObjectSupplier" locked="false">org.apache.axis2.extensions.spring.receivers.SpringServletContextObjectSupplier</parameter>
    <parameter name="SpringBeanName" locked="false">myWebService</parameter>
	<operation name="add">
		<messageReceiver class="org.apache.axis2.rpc.receivers.RPCMessageReceiver" />
	</operation>
 
</service>

Für Spring sind die zwei Parameter ServiceObjectSupplier und SpringBeanName entscheidend, um uns das benötigte DAO zu übergeben.

Mit Hilfe eines Ant Scriptes oder manuell kann man sich den Webservice in das für Axis2 benötigte AAR Archiv packen. Das Archiv ist im Grunde eine normale JAR Datei mit der service.xml im META-INF Verzeichnis.

Die Struktur des AAR-Archives sollte so aus sehen:

- MyWebService
   - META-INF
     - services.xml
   - com
     - jgeppert
       - services
         - MyWebService.class

Damit Spring unser DAO in dem Service injizieren kann, brauchen wir noch folgenden Eintrag in unserer applicationContext.xml.

<bean id="applicationContext" class="org.apache.axis2.extensions.spring.receivers.ApplicationContextHolder" />
 
	<bean id="myWebService" class="com.jgeppert.services.MyWebService">
    	<property name="myDAO" ref="MyDAO"/>
 
  	</bean>

Nach dem deployen des AAR-Archives im services Folder der Axis2 Web Application steht der Service nun zur Verfügung.

Bookmark It

Hide Sites

Letzten September öffnete das Genießerportal www.weinfreund.de seine Pforten. Auf ihm können sich deutsche Winzer und österreichische Winzer mit ihren Weingütern präsentieren und gleichzeitig ihre Weine über einen Online-Shop anbieten. Derzeit präsentieren sich 80 Weingüter der Weinfreunde-Community. Die Community wählt dabei jährlich ihren liebsten Weiß- und Rotwein. Das Rennen machten bei der Wahl 2008 das Weingut Uebel aus der Pfalz mit seinem Cuvée blanc 2007 und das Weingut Klaus Runkel mit seinem Merlot ‚M‘ 2006.

Auch dieses Jahr stehen wieder interessante neue Weine zur Wahl. Weinkenner, die sich an der Abstimmung beteiligen wollen, aber noch nicht zu den eingetragenen Weinfreunden gehören, können sich auf dem Genießerportal kostenlos anmelden. Wer sich bis 30. März dazu entschließt, der Community beizutreten, hat die Chance, einen guten Tropfen zu gewinnen. Auf die Gewinner wartet eine edle Weinauswahl der beiden Siegerweingüter Uebel und Klaus Runkel.

Cuvée blanc und Merlot sind die ‚besten‘ deutschen Weinen 2008

“Weine mit Charakter und eigener Persönlichkeit”, so beschreibt Winzer Jochen Uebel seine Wein-Kollektion. Die Ausdruckskraft der Uebel-Weine kann die Community auf www.weinfreund.de nur bestätigen. Sie wählte den Cuvée blanc 2007 zum Weißwein des Jahres 2008. Der zusätzlich goldprämierte Weißwein (Landesprämierung) zeichnet sich durch eine kaum zu übertreffende Vielfalt an fruchtigen und blumigen Aromen aus. Im Geschmack ist er ausgewogen und mineralisch zugleich mit einem langen würzigen Abgang.

Das Weingut Uebel ist eines der jungen Weingüter, die die Pfalz derzeit zum dynamischsten Weinbaugebiet Deutschlands macht. Es liegt in Nußdorf an der südlichen Weinstraße. Auf 10 Hektar gedeihen hier die Reben für Riesling, Chardonnay, Grauer Burgunder Sauvignon Blanc, Dornfelder, Portugieser, Merlot und Cabernet Sauvignon.

‚M‘ steht für den Gewinnerwein unter den Roten. Der Merlot aus dem Jahr 2006 vom Weingut Klaus Runkel besticht durch den Geschmack nach Waldbeeren und Dörrobst. Durch seine 18 monatige Lagerung hat der Wein zusätzlich feine Aromen von Tabak und Edelvollmilch Schokolade. Dafür bekam er auch die silberne Kammerpreismünze.

Das Familienweingut Klaus Runkel stammt aus der Weinbaugemeinde Bechtheim in Rheinhessen. Neben 10 Hektar Weinbau besitzt die Winzerfamilie den ältesten verbrieften Weinkeller aus dem Jahr 1559. Runkels Sortiment umfasst auserlesene Rotweine in den Sorten Portugieser, Dornfelder, Spätburgunder, Merlot sowie ganz neu St. Laurent. Die Weißweine von den Rebsorten Chardonnay, Silvaner, Weißer Burgunder, Grauer Burgunder und Riesling sind geprägt von sortentypischen Fruchtaromen. Typische rheinhessische Rebsorten, z.B. Ortega und Gewürztraminer mit ihrer edlen Süße und vollen Aromen, ergänzen das Weinsortiment.

Bookmark It

Hide Sites