We have contacted the creator of these tests Ikoko , and he has clarified thatthe Spring documentation for the exam syllabus has changed (improved) since he had created the exam so the tests now appear to be different to the syllabus

The historical documentation and support for the certification has been poor from Spring and might even be incorrect.

he also pointed out that Skill-guru test-takers basing their opinions on the Spring documentation and not actually doing the Spring exam are therefore possibly misled by the official documentation

From Ikoko’s email

I sat both the 2.5 exam and 3.0 exam so have experienced both exams first-hand and have been keen to keep my exams accurate based on real exam-experience and not any vague syllabus published by Spring

Having said all, this at a higher topic level I only noticed the category of SpEL (Spring expression language) being a category in my tests that was not in the offical syllabus. I had 1 SpEL question in test 1, and 2 questions in test 2. I have now removed all three questions.

Hope  this clarifies the doubt of our readers and thanks to MaggieL and Shane Mannion for pointing this out

Spring 3 allows you to intercept the request and response headers without writing the filter explicitly .  Spring’s handler mapping mechanism includes handler interceptors.

If you would prefer to write a filter explicitly, it has been covered in Servlet Filter to prevent No Cache.

From Spring MVC docs

Interceptors located in the handler mapping must implement HandlerInterceptor from the org.springframework.web.servlet package. This interface defines three methods: one is called before the actual handler is executed; one is called after the handler is executed; and one is called after the complete request has finished. These three methods should provide enough flexibility to do all kinds of preprocessing and postprocessing

You have an option in which instead of writing your own custom class, you can modify the servlet-Context.xml file to provide no caching feature

Here is what will go inside the file

<mvc:annotation-driven/>
<mvc:interceptors>
<bean id=”webContentInterceptor”>
<property name=”cacheSeconds” value=”0″/>
<property name=”useExpiresHeader” value=”true”/>
<property name=”useCacheControlHeader” value=”true”/>
<property name=”useCacheControlNoStore” value=”true”/>
</bean>
</mvc:interceptors>

I am giving the example of No cache but you can add any other property supported .

Remember, these settings will be done in your servlet-Context.xml and not in your application Context file.

The servlet-context.xml is set up when you are configuring the Displatcher Servlet

<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/servlet-context.xml</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>

The only drawback is that it applies to all your requests and response . So if you would like to cache your images files, it would not allow even to do that.

When will this not work ?

If you are using any other filter mechanism outside Spring MVC , and your pages are not rendered through Dispatcher servlet, then this will not help you out. For eg the dispatcher servlet is configured to server pages behind folder foo/abc.htm, foo/faa/hello.html .

Now you have another set of pages outside foo like /index.html, /myDataView.jsp , then the above changes will not affect the response for these pages.

Reference : Spring 3 MVC docs

Spring 3.0 which has come up with a lot of simplification like asynchronous method invocation , have also simplified AJAX calls.  You can now now invoke server side code with JSON and Spring 3 provide support for that. Details on it can be read from Spring Source blog AJAX Simplification in Spring 3

PS: Last time I checked out the spring blog,  the above url was pointing to wrong post. They might have fixed it by now

The @Async annotation

The @Async annotation allows invocation of that method to occur asynchronously. In other words, the caller will return immediately upon invocation.

One of the use cases of @Async function can be in situations where in user registers and system has to send confirmation mail or any similar task where you do not want to block user.

We will look at the  example below to explain it more clearly . Since for most of you this will be first Spring 3.0 application, please notice the changes in applicationContext.xml.

<?xml version=”1.0″ encoding=”UTF-8″?>

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

<context:component-scan base-package=”cs”/>

</beans>

Let us now look at our classes

TestService.java

import org.springframework.context.support.ClassPathXmlApplicationContext;
import cs.service.RegularService;

public class TestService {

public static void main(String args[]){

ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {
“applicationContext.xml”});

RegularService regService = (RegularService) appContext.getBean(“regularService”);

regService.registerUser(“Skill-Guru”);

}

}

RegularService.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cs.async.MailUtility;

@Service
public class RegularService {

@Autowired
private MailUtility mailUtility ;

public void registerUser(String userName){

System.out.println(” User registration for  “+userName +” complete”);

mailUtility.sendMail(userName);

System.out.println(” Registration Complete. Mail will be send after 5 seconds “);
}

}

MailUtility.java

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class MailUtility {

@Async
public void sendMail(String name){

System.out.println(” I Will be formatting html mail and sending it  “);

try {
Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();
}

System.out.println(” Asynchronous method call of send email — Complete “);

}

}

Once you run the TestService.java the output would be

User registration for  Skill-Guru complete
I Will be formatting html mail and sending it
Asynchronous method call of send email — Complete
Registration Complete. Mail will be send after 5 seconds

Now wait a minute. This does not look like asynchronous call. What the hell is wrong here ?

We missed <task:annotation-driven/> in applicationContext.xml

The modified applicationContext.xml would be

<?xml version=”1.0″ encoding=”UTF-8″?>

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

<context:component-scan base-package=”cs”/>

<task:annotation-driven/>

</beans>

Notice the changes in bold.

Now run your TestService again. The output would be

User registration for  Skill-Guru complete
Registration Complete. Mail will be send after 5 seconds
I Will be formatting html mail and sending it

The program will not exit and after 5 second you will see

Asynchronous method call of send email — Complete

You can see registerUser calls sendMail and the control is returned back to caller immediately.

Are you preparing for Spring Certification ? Try out the Spring certification Mock Practice test

What are the new features in Spring 3.0?

1. The Spring Framework is now based on Java 5, and Java 6 is fully supported.

2. The entire framework code has been revised to take advantage of Java 5 features like generics, varargs and other language improvements.  The code is still compatible with older versions of Java

3. Spring Expression Language – Spring has introduced an expression language which is similar to Unified EL in its syntax but offers significantly more features

The following is an example of how the Expression Language can be used to configure some properties of a database setup

<bean class=“mycompany.RewardsTestDatabase”> <property name=“databaseName” value=“#{systemProperties.databaseName}”/> <property name=“keyGenerator” value=“#{strategyBean.databaseKeyGenerator}”/> </bean>

4. Some core features from the JavaConfig project have been added to the Spring Framework now. This means that the following annotations are now directly supported:

5. Additional annotations such as @CookieValue and @RequestHeaders have been added

6. Early support for asynchronous method invocations through the use of the new @Async annotation (or EJB 3.1’s @Asynchronous annotation).

7. The most exciting new feature for the Web Tier is the support for building RESTful web services and web applications

8. Object to XML mapping functionality (OXM) from the Spring Web Services project has been moved to the core Spring Framework now

9. Extended support for meta-annotations: Spring’s @Scope and @Transactional annotations, as well as specialized stereotypes such as @Service and @Controller, can be applied as meta-annotations on custom annotations now. for eg

Source :  Spring 3.0 documentation