With the Spring Framework you can easily create RESTful webservices. This is built-in the MVC part of Spring. In this post I show you how to configure this and offer the consumer the response as XML and as JSON.

The domain model

First we need a domainmodel. In this sample it is quite simple. It consists of 2 classes: Constellation and ConstellationName.

Domainmodel

The Constellation describes an astronomical constellation like Orion, Andromeda and so on. The association to ConstellationName offers names of the constellation in different languages.

The service model

In this sample the interface used by clients (web, webservice) is a classical service class. This class – named ConstellationService – needs a repository class to access the underlying database.

Servicemodel

Wiring domain and service

With Spring this is quite easy. You need only a little XML file and some Annotations. In the ConstellationService you add the @Service annotation:

@Service
public class Service{
...
}

This annotation is out of the package org.springframework.stereotype.Service. To inject the repository class you can use the @Inject annotation. If you have setup your JPA environment properly you can access the database and get some Constellation instances.

Creating the REST service

Now we have a working backend. But we want to have a RESTful webservice so we need another artifact in our sourcecode: the Controller. A controller is the first item of our application. This means if a client requests data the controller gets the request foremost. The controller then is analyzing and validating the request. After this service will be called, the retrieving data prepared and returned.

In Spring you can add some annotations to a controller method to map this method to the specified URL resource:

@RequestMapping(value = "/constellations")
public ModelAndView getAllConstellations() {}

With this mapping this controller method responses to the request http://some-host/constellations only. You can map more complex URL resources too. For instance if you have an URL with parameter. In our service we want to offer a method the client can request for one constellation identified by its code. This can be done with the annotation @RequestMapping and @PathVariable:

@RequestMapping("/constellation_by_code/{code}")
public ModelAndView findConstellationByCode(@PathVariable String code) {}

With this mapping the part with the {} will be taken as parameter for the method. You can use more placeholder too. For this you can read the Spring documentation.

Now we have all informations to create the controller class.

@Controller
public class ConstellationServiceController {
 
@Inject
private ConstellationService service;
 
@RequestMapping(value = "/constellations")
public ModelAndView getAllConstellations() {
  List<Constellation> constellations = service.findAllConstellations();
  ModelAndView mav = new ModelAndView("xmlView",
    BindingResult.MODEL_KEY_PREFIX + "constellations", constellations);
  return mav;
}
 
@RequestMapping("/constellation_by_code/{code}")
public ModelAndView findConstellationByCode(@PathVariable String code) {
  Constellation constellation = service.findConstellationByCode(code);
  return new ModelAndView("xmlView", BindingResult.MODEL_KEY_PREFIX
     + "constellations", constellation);
}
 
@RequestMapping("/constellations_by_search/{search}")
public ModelAndView findConstellationByCodeOrName
                                    @PathVariable String search) {
  return new ModelAndView("xmlView", BindingResult.MODEL_KEY_PREFIX
            + "constellations", service.findAllConstellationByCodeOrName(search));
}

The last step we need to do is to configure the Spring container to get it together. For this we need a little bit XML. In this XML we configure 2 views: one for a XML and one for a JSON response. So you need to add the xml or json extension to the url to control the format of the response.

<bean class="org.springframework.web.servlet.view.BeanNameViewResolver" />
 
<bean id="xstreamMarshaller" class="org.springframework.oxm.xstream.XStreamMarshaller"
p:autodetectAnnotations="true" />
 
<bean id="xmlView" class="org.springframework.web.servlet.view.xml.MarshallingView"
      p:contentType="application/xml">
      <constructor-arg ref="xstreamMarshaller" />
</bean>
 
<bean id="jsonView" class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />
 
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
  <property name="mediaTypes">
    <map>
      <entry key="json" value="application/json" />
      <entry key="xml" value="application/xml" />
    </map>
  </property>
  <property name="defaultViews">
    <list>
      <ref bean="jsonView" />
      <ref bean="xmlView" />
    </list>
  </property>
  <property name="ignoreAcceptHeader" value="true" />
</bean>

First we configure the XMLMarshaller to generate XML out of the Java beans. Then we need 2 Views. One for XML and one for JSON. The most configuration needs the ContentNegotiatingViewResolver. This resolver handles the different response formats. The last property ignoreAcceptHeader you need to get JSON in your browser too. Otherwise always XML will be returned.

Configuring the web.xml

You need to activate the Spring servlet and the context listener to get the service running. This is done with a small web.xml.

<web-app>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/rpc-servlet.xml</param-value>
  </context-param>
 
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
 
  <servlet>
    <servlet-name>rpc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>rpc</servlet-name>
    <url-pattern>/rpc/*</url-pattern>
  </servlet-mapping>
</web-app>

Now we have all together and can start the web application. You can access the services with http://localhost:8080/rpc/constellations. As default format XML will be returned. If you want to have JSON change the URL into http://localhost:8080/rpc/constellations.json. Of course you can add .xml to get XML output, too.

If you want to have the data for one constellation you can use the 2nd controller method with http://localhost:8080/rpc/constellation_by_code/and. The last part of the URL is the official code/abbreviation of a constellation. All codes/abbreviations you can get here. If you want the output as JSON you can add the extension .json too: http://localhost:8080/rpc/constellation_by_code/and.json

Optimize the output

We have even 2 little problems:

1. The Constellation class defines a byte array containing imagedata of a starcard. If we want to retrieve all constellations the response will be great.
2. The association will not be resolved. We want to get all names of a constellation with one request to minimize the response-request cycle.

public class Constellation{
  ...
  @XStreamOmmitField
  private byte[] starCardData;
}

public class Constellation{
...

@XStreamImplicit(itemFiledName = "names")
private List<ConstellationName> names;
}

The XML result should look like

<constallation>
  <id>4</id>
  <name>Andromeda</name>
  <code>and</code>
  ...
  <names>
    <id>19</id>
    <name>Andromeda</name>
    <langCode>de</langCode>
    <code>and</code>
  </names>
  <names>
    <id>20</id>
    <name>Andromeda</name>
    <langCode>en</langCode>
    <code>and</code>
  </names>
  ...
</constellation>

Conclusion

Now you have a Spring-based RESTful service created. As you can see there are not many code you must write. The most is configuration with annotation and some XML. With the @RequestMapping you can create powerful mappings from URL resources to controller methods. Another nice feature is to deliver the response as XML and JSON.

Resources

»Spring 3« ist da. Vieles ist geblieben, manches verschwunden, manches neu. Spring 3 verspricht eine verbesserte und dynamischere  Konfiguration, einen leistungsfähigen und mächtigen REST-Support und viele kleine Verbesserungen. Parallel zu dem Spring 3-Release wurden auch andere Tools und Projekte aktualisiert, auf die wir ebenfalls einen Blick werfen wollen:

• Wichtige Änderungen
• Java Configuration
• Spring Expression Language
• Spring MVC und Rest
• Embedded Database
• SpringSource Toolsuite
• Spring Roo
• Grails

»Spring 3« ist da. Vieles ist geblieben, manches verschwunden, manches neu. Dieser Vortrag beleuchtet die Änderungen und zeigt wie man die neuen Features einsetzen kann.

Zusätzlich werfen wir gemeinsam einen Blick auf die SpringSource Toolsuite, Spring Roo, Grails.

This article is about the managing of Domainobjects with the Spring Framework. Domainobjects are often initilized with the new keyword. This avoids the usage with Spring, because there aren’t Spring Beans. But with AOP and the @Configurable Annotation of Spring you can manage these objects too.

This article is in german and published at Jaxenter.
You will find them here: http://it-republik.de/jaxenter/artikel/Mit-Spring-und-AOP-Domaenenklassen-verwalten-2644.html

In vielen Projekten ist das Spring-Framework das Mittel der Wahl. Zusätzlich werden in vielen Produkten Spring intern eingesetzt. Damit die Arbeit mit Spring uneingeschränkt Spass macht ist es wichtig einige Tricks und Kniffe zu kennen. In diesem Vortrag zeigt Ihnen der Referent, wie Sie effektiv Spring in Ihren Projekten einsetzen können. Die Themenbandbreite reicht dabei vom Tooling über Architekturthemen bis hin zum Testing:

• Spring-IDE: Features und Verwendung
  • Navigation zwischen Beandefinitionen und Code
  • Aspekte
• Architekturen unabhängig von Spring
  • keine HibernateTemplates
  • mein Code kennt nur Standards
  • eigene Annotations anstatt Spring-Annotations
• Testen mit Spring
  • Spring für Unittests
  • Dependency Injection
  • Angepasste Spring-Konfigurationen
  • DAO-Test

The Spring-Framework is a non-invasive framework. This means you can develop pure POJOs without any dependencies to the framework. You don’t need implement any interface nor you need to extend any base classes. However there are a lot of useful classes and interfaces provided by Spring – do you know the HibernateTemplate? – so you can use them if you want but you aren’t forced to use them.

If you remember the Spring 1.x stream without use of these templates make it very difficult to implement DAOs. This is much better with Spring 2 and JPA. For now you need only to inject an EntityManager and use the methods of them. That’s very nice, because of the EntityManager is a class out of the JPA/EJB3 standard.

Since Spring 2 there are annotation support. Not only standardized annotations are supported. Spring provides his own annotations. This is not so nice, because the use of this annotations makes your PoJos depend on Spring.

The Sample

There are a sample project to this article. You can download it here. The sample is an Eclipse Project. You need at least 3 plugins to get the sample running:

• SpringIDE (http://springide.org/updatesite)
• GroovyIDE (http://dist.codehaus.org/groovy/distributions/update/)
• Maven Integration (http://m2eclipse.sonatype.org/update/)

Additional to these plugins it is recommend to install a native Maven from http://maven.apache.org. The embedded Maven of the Maven Integration sometimes have problems with Groovy-based tests. To enable another Maven Installation you can add it in the Preferences (Window -> Preferences -> Maven -> Installations). After you have prepared your Eclipse you can import the sample and run it with Run As -> Maven install.

Spring and Annotations

Spring supports a lot of annotations. Additional to the standard Java 6 annotations like (@Resource, @PostConstruct, @PreDestroy,…) there are a number of Spring-Annotations:

• @Autowired – injets a resource byType or byName
• @Required – marks a property as mandatory
• @Component – marks a class as Component. This you need for @Resource, @Autowired
• @Service – similar to @Component
• @Controller – marks a class as Controller for SpringMVC
• …

If you want to use dependency injection with annotations you can

package testprojects.spring.annotations;

import javax.annotations.Resource;

public class Demo{
  @Resource(name="otherResource")
  private Other resource;
}

In this case the Java field named with resource should get a reference to another bean with the symbolic name otherResource. To get this work you must define a bean with this symbolic name:

import org.springframework.stereotype;

@Component("otherResource")
public class Other{}

Now we have configured our classes with annotations. But Spring doesn’t know that he should scan our classes for annotations. This we can do with the element context:component-scan in an applicationContext.xml:

At the start of the ApplicationContext of Spring all classes in the package testprojects.spring.annotations will be scanned for annotations. If Spring found any the context will be build – similar to the XmlApplicationContext

.

The Problem

If you take a closer look at the class Other you will see the import of¬† org.springframework.stereotype. This will make the class depend to the Spring Framework. Thats very bad, because we won’t have such a dependency. But what we can do? The solution is quite simple. Let us define our own annotation for this case and re-configure Spring in that way that our annotation instead teh Spring one will be used to mark classes as Components. The definition of the annotation is simple and a one-to-one copy of the original annotation provided by Spring:

package testprojects.spring.annotations;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.stereotype.Repository;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {

  /**
  * The value may indicate a suggestion for a logical component name, to be
  * turned into a Spring bean in case of an autodetected component.
  *
  * @return the suggested component name, if any
  */
  String value() default "";
}

The next step is to tell Spring that he doesn’t use its own @Component-Annotation but our annotation. This can do with the context:component-scan element, too:

The important changes are the attribute use-default-filters. If you set this to false, Spring ommit his own annotations. In this case you can define you own annotation classes with the context:include-filter element.

And now… a sample

Now we want it get together. To demonstrate the mechnism we want to create an own Annotation as replacement for the Spring @Service-Annotation. Then we mark a PoJo with this annotation and write a Unittest to verify that Spring use this class as Spring-Bean.

1. Create the Service-Annotation

package testprojects.spring.annotations.Service;

@Target( { ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface MyService {

  /**
  * The value may indicate a suggestion for a logical component name, to be
  * turned into a Spring bean in case of an autodetected component.
  *
  * @return the suggested component name, if any
  */
  String value() default "";
}

2. Add this annotation to our class

import testprojects.spring.annotations.Service;

@MyService
public class ServiceBean {

}

3. Re-configure Spring to use the @MyService-Annotation

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:p="http://www.springframework.org/schema/p"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

   <context:component-scan
     base-package="testprojects.spring.annotations" use-default-filters="false">
     <context:include-filter
         expression="testprojects.spring.annotations.Service"
         type="annotation" />
    </context:component-scan>
</beans>

4. Write a Unittest to verify that Spring is using the annotated class as SpringBean

@RunWith(SpringJUnit4ClassRunner)
@ContextConfiguration
public class ServiceAnnotationTest{

  @Autowired
  ServiceBean serviceBean

  @Test
  final void testServiceAnnotation(){
    Assert.assertNotNull(serviceBean)
  }
}

bcbcbc

Gute Software sollte sich an der entsprechenden Fachdomäne orientieren und nicht an der zugrundeliegenden Technologie. Um dies zu erreichen, wird allerdings eine Basis benötigt, die technisch ausgereift ist ohne Einschränkungen für die Entwicklung. Eine solche Basis kann mit dem Springframework geschaffen werden. Die Kombination von Spring, Annotations, Java Persistence (JPA) und Unit-Testing erlaubt eine flexible und modulare Architektur und könnte eine mögliche technische Basis für ein solches Softwaresystem sein.

Dieser Vortrag stellt einen Lösungsansatz anhand eines einfachen Beispiels vor. Die Aufbereitung der Inhalte orientiert sich dabei an einem typischen test-zentrierten Entwicklungsprozess. Folgende Themen werden angesprochen:

• Einleitung Spring und JPA, Maven, Groovy
• Projektstruktur
• Entwicklung der API (der Schnittstellen)
• Test-getriebene Entwicklung der Implementierung
• Spring-unterstützte Integrationstests

Ausblick:

• Spring 2.5 – mehr Annotations; Verwaltung von Entities mit Spring
• Webschicht – Anbindung einer Webanwendung mit Java Server Faces (JSF)
• Spring-Webservices – Contract-First Webservices mit Spring-WS 1.0

Gute Software sollte sich an der entsprechenden Fachdomäne orientieren und nicht an der zugrundeliegenden Technologie. Um dies zu erreichen, wird allerdings eine Basis benötigt, die technisch ausgereift ist ohne Einschränkungen für die Entwicklung. Eine solche Basis kann mit dem Springframework geschaffen werden. Die Kombination von Spring, Annotations, Java Persistence (JPA) und Unit-Testing erlaubt eine flexible und modulare Architektur und könnte eine mögliche technische Basis für ein solches Softwaresystem sein.

Dieser Vortrag stellt einen Lösungsansatz anhand eines einfachen Beispiels vor. Die Aufbereitung der Inhalte orientiert sich dabei an einem typischen test-zentrierten Entwicklungsprozess. Folgende Themen werden angesprochen:

• Einleitung Spring und JPA, Maven, Groovy
• Projektstruktur
• Entwicklung der API (der Schnittstellen)
• Test-getriebene Entwicklung der Implementierung
• Spring-unterstützte Integrationstests

Ausblick:

• Spring 2.5 – mehr Annotations; Verwaltung von Entities mit Spring
• Webschicht – Anbindung einer Webanwendung mit Java Server Faces (JSF)
• Spring-Webservices – Contract-First Webservices mit Spring-WS 1.0