RESTful JAX-RS Facade durch MySQL backend erweitern

[Stefan2902]

Hallo,

basierend auf einen Tutorial (O'Reilly's RESTful JAX-RS Jersey implementation) habe ich einen RESTful Service geschrieben, der Kunden hinzufügen kann (POST /customers HTTP/1.1) sowie Kundendaten abrufen kann (GET /customers/1 HTTP/1.1).

Dieses Beispiel läuft als Singleton, d.h. ich habe z.Zt. keine Datenbankschicht implementiert. Die dementsprechende Klasse sieht z.Zt. wie folgt aus:

package com.restfully.shop.services;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

public class ShoppingApplication extends Application{
	
	private Set<Object> singletons = new HashSet<Object>();
	private Set<Class<?>> empty = new HashSet<Class<?>>();
	
	public ShoppingApplication(){
		singletons.add(new CustomerResourceImplementation());
	}
	
	@Override
	public Set<Class<?>> getClasses() {
		return empty;
	}
	
	@Override
	public Set<Object> getSingletons(){
		return singletons;
	}


}

Die web.xml Datei sieht dementsprechend so aus:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>MathResult</display-name>
  <servlet>
    <display-name>JAX-RS REST Servlet</display-name>
    <servlet-name>Rest</servlet-name>
    <servlet-class>
  		com.sun.jersey.spi.container.servlet.ServletContainer
  	</servlet-class>
    <init-param>
      <param-name>javax.ws.rs.Application</param-name>
      <param-value>com.restfully.shop.services.ShoppingApplication</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Rest</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>
</web-app>

Mein Ziel ist es nun die Daten in einer MySQL Datenbank zu pflegen, dass heißt, dass der POST Request einen neuen Eintrag in einer Tabelle erzeugt, sowie der GET Request Daten aus einer Tabelle ausliest.

Ich habe dementsprechende Methode geschrieben und in einem seperaten Java Projekt getestet. Was mir feht ist, wie ich die Datenbankanbindung durch das Singleton im Service ersetze. Mit anderen Worten, was muss ich tun, damit beim Starten des Webservices die MySQL Connection aufgebaut anstelle einer Erzeugung eines Singleton's?

Viele Grüße
Stefan

 

[Stefan2902]

Kurzes Update:

Da ich neu auf dem Gebiet der RESTful Programmierung bin, glaube ich, dass ich mich hier sehr schlecht ausgedrückt habe.

Mit dem Singleton hat meine Anfrage eigentlich gar nicht zu tun.

Was ich eigentlich möchte, ist eine persistente Datenbank Schicht in meinen RESTful Service einzubauen. Dafür verwende ich eine MySQL Datenbank. Nach ein paar Überlegungen habe ich meinen Code jetzt dahingehend angepasst, dass wenn immer ein HTTP/GET Request gestellt wird, eine Datenbankverbindung aufgebaut wird und die Daten aus der entsprechenden Tabelle gelesen werden.

Hier die Resource:

@Path("/trades")
public interface TradeResource {

	@GET
	@Path("{tranNum}")
	@Produces( { MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
	public Trade getTrade(@PathParam("tranNum") int tranNum);
	
}

Hier die Implementierung:

public class TradeResourceImplementation implements TradeResource {

	MySqlConnection con = null;
	
	public Trade getTrade(int tranNum) {

		con = new MySqlConnection();
		con.establishConnection("datenbank", "username", "pw");		
		Trade trade = con.getTrade(tranNum);
		return trade;
		
		
	}

Dies ist jedoch ziemlich ineffizient. Daher denke ich, dass meine eigentliche Frage ist, wie man eine persistente Datenbankschicht in einem Webservice (egal, ob REST oder SOAP) nach Best Practise Gesichtspunkten aufsetzt. Ich verwende Eclipse, Tomcat6, MySQL5. Ist es z.B. sinnvoll einen JNDI Eintrag auf meinem Tomcat Server einzurichten und diesen im Code zu verwenden? Macht es Sinn Spring für die Datenbankspersistenz zu verwenden?