Spring 3.x certification mock test

Questions very similar to originals with almost the same difficulty level. Majority questions are from most important sections at exam: container, testing, AOP, transactions. Only few from other sections like MVC, REST, JMX, JMS.

This is a 30 question practice test. 5 questions are free for you to try.

It is very reasonably priced at $1.99.

If you buy all there tests, you would save on paypal fees.

I am sure you would like the test. Jacek is looking for feedback and inputs to make the test better.

Let us say you have database user name , password etc configured in jdbc.properties and would like to inject the values at run time.

Here is what will go in applicationContext.xml

<bean id=”dataSource” destroy-method=”close”>
<property name=”driverClass” value=”${jdbc.driverClass}”/>
<property name=”jdbcUrl” value=”${jdbc.url}”/>
<property name=”user” value=”${jdbc.user}”/>
<property name=”password” value=”${jdbc.password}”/>
<property name=”minPoolSize” value=”${jdbc.minPoolSize}”/>
<property name=”maxPoolSize” value=”${jdbc.maxPoolSize}”/>
</bean>

and this will be your properties file

jdbc.driverClass=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@abc.com:1521:ORAC
jdbc.user=hello
jdbc.password=hello
jdbc.minPoolSize=1
jdbc.maxPoolSize=10

At run time, the properties file value will be injected  into the applicationContext.xml

session.setFlushMode(FlushMode.NEVER)

What does it signify ?

It means that the Hibernate session not to flush any state changes to database unless flush() is explicitly called by the application.

When setting the FlushMode.NEVER , will it improve the performance and reduce the run time  ?

It would not affect if you are running a single update or a series of small updates. It really affects you when you are doing batch processing. The reason for this is the way hibernate implements dirty checking. Once you load an object in memory and do not evict it, the hibernate session keeps track of it in case if it was changed. So, any time you perform a query, the session iterates over all objects in the session checking dirtiness and flushes any dirty objects to the database. It does this to ensure that all state changes that might affect the query are present in the database before issuing the query to it. That’s fine when you have only a few objects in session, but when you have thousands and are performing thousands of queries, it becomes a real drain on performance.

Tim fennel has made this interesting observation about the FlushMode.NEVER in his blog here.

Spring provides a similar way to annotate methods @Transactional(readOnly=true) in Spring which internally has the same affect.

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

If you are using SimpleJDBCtemplate then the Spirng docs are good place to find a good explanation for it Simple JDBC Template

If you are using JDBCtemplate , here is the example to use prepared statements and do batch updates

public boolean createGroceyList(List<Grocery> groceryList){

final List<Grocery> aGroceryList =  groceryList

int result[] = this.jdbcTemplate.batchUpdate(

“the query goes here “,new BatchPreparedStatementSetter() {

public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setLong(1, “param 1 goes here “);
ps.setString(2, “param 2 goes here “);

ps.setString(3, “param 3 goes here “);
}

public int getBatchSize() {
return aGroceryList.size();
}
});

return (aGroceryList.size() == result.length ? true : false);
}

The query would be something similar to

INSERT INTO GROCERY(ID, NAME, QUANTITY) VALUES(?,?,?)

During test, if you may want to set up up test data or some fields like connection pool only once. If you are using simple JUnit tests , then an easy way would be to annotate your methods with @BeforeClass and @AfterClass.  Here is an example of @BeforeClass and @AfterClass

How do you achieve the functionality of @BeforeClass in Spring ?

Now let us say you want to run Spring integration tests and your class is

public class MySpringIntegrationTest extends AbstractDependencyInjectionSpringContextTests {

private static int ID = 1111;

@Autowired
private MyBean myBean;

@BeforeClass
public static void before() {

// all the set up code will come here. for eg connecting to database
}

}

If you run this class,  @BeforeClass will never run.

Reason is that spring’s test classes are based on Junit 3.x framework. @BeforeClass has been introduced with JUnit4. Since your class extends AbstractDependencyInjectionSpringContextTests, Junit 4 functions are never invoked.

You will not see compile time errors because Junit 4 would be in your IDE or project classpath.

How to run Spring tests cases with Junit4 ?

Here is what I did

@RunWith(BlockJUnit4ClassRunner.class)
public class MySpringIntegrationTest extends AbstractDependencyInjectionSpringContextTests {

private static int ID = 1111;

@Autowired
private MyBean myBean;

protected String[] getConfigLocations()
{
return new String[]{“classpath:applicationContext-*.xml”};
}

@BeforeClass
public static void before() {

// all the set up code will come here. for eg connecting to database
}

@Before
final public void callSetup() throws Exception {
super.setUp();
}

@After
public void callTearDown() throws Exception {
super.tearDown();
}

@Test
public void testMethod1_happy() throws Exception{
}

}

You can use @RunWith((TestClassRunner.class) but it has been depreciated. So you better off with @RunWith(BlockJUnit4ClassRunner.class)

What you have done by annotating your class with @RunWith(BlockJUnit4ClassRunner.class) is that you have forced Spring to run with JUnit4 and asked it to ignore JUnit3.

But once you do this, your annotated myBean would be null. Spring would not injected it for you.

Why ?

JUnit 4 only cares about annotations and won’t run the old setUp and tearDown methods defined by the Spring classes. To get around this, add methods with Before and After annotations to call setUp and tearDown.

<tt>@Before final public void callSetup() throws Exception {
  super.setUp();
}

@After public void callTearDown() throws Exception {
  super.tearDown();
}

</tt>

Now your test class with run with Junit4 and base class features are also available.

There are situations in which you would like your Spring services as web services. In this link below there is a code example of both REST and SOAP access the same backbone. Here is the link

We were using in memory database  HSSQL db in our application for doing testing and we discovered that we required more than one connection. So basically we need to set up a connection pool.

The old definition looked like

<bean id=”dataSource” class=”org.springframework.jdbc.datasource.DriverManagerDataSource” >
<property name=”driverClassName” value=”org.hsqldb.jdbcDriver”/>
<property name=”url” value=”jdbc:hsqldb:file:testdb;shutdown=true”/>
<property name=”username”  value=”sa”/>
<property name=”password” value=”"/>
</bean>

Before talking about how we set up a connection, let us talk about some basic concept. All databases support connection pooling , even in memory database like hssql. For setting up a connection pool through Spring’s application Context,  you should be using the class which support the pooling

Notice here that we are using class=”org.springframework.jdbc.datasource.DriverManagerDataSource”.

This class does not support connection pool .

So if you try to add properties such as minPoolSize and maxPoolSize , spring will throw exception similar to

Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘dataSource’ defined in file

To avoid the exceptions, you should be using class=”com.mchange.v2.c3p0.ComboPooledDataSource

This class support connection pooling and setting up of other properties  such as idleConnectionTestPeriod etc.

Your bean definition will look like

<bean id=”dataSource” destroy-method=”close”>
<property name=”driverClass” value=”org.hsqldb.jdbcDriver”/>
<property name=”jdbcUrl” value=”jdbc:hsqldb:file:testdb;shutdown=true”/>
<property name=”user” value=”sa”/>
<property name=”password” value=”"/>
<property name=”minPoolSize” value=”1″/>
<property name=”maxPoolSize” value=”4″/>
</bean>

This pool size can be used with any database including myssql. For mysql , the driver would change and the defintion would look something like

MySQl connection Pool in spring applicationContext.xml

<bean id=”dataSource1″ destroy-method=”close”>
<property name=”driverClass” value=”${db.driverClass}”/>
<property name=”jdbcUrl” value=”${db.wordpress_db_url}”/>
<property name=”user” value=”${db.wp.username}”/>
<property name=”password” value=”${db.wp.password}”/>
<property name=”minPoolSize” value=”1″/>
<property name=”maxPoolSize” value=”4″/>
<property name=”breakAfterAcquireFailure” value=”false”/>
<property name=”acquireRetryAttempts” value=”3″/>
<property name=”idleConnectionTestPeriod” value=”300″>
<property name=”testConnectionOnCheckout” value=”true”/>
</bean>

The value for db.driverClass can be set up in an external properties file or defined here in xml file itself as we had done above.

What does this mean ?

When a Multi Version Concurrency Control database (Oracle, Postgresql, MySQL + InnoDb) is used, a read only transaction can be translated to the non standard isolation level: READ_ONLY.

The READ_ONLY isolation level provides the same protection as the SERIALIZED isolation level (no dirty reads, no unrepeatable reads, no phantom reads) but doesn’t allow any updates. It also doesn’t cause any lock contention because no locking is required (the database is able to revert back to previous versions of the records ignoring all new changes).

Ms Sql 2005 also has a similar isolation level: SNAPSHOT.

If you specify readOnly as true, the flush mode will be set as FlushMode.NEVER in the current Hibernate Session preventing the session from committing the transaction.

Furthermore, setReadOnly(true) will be called on the JDBC Connection, which is also a hint to the underlying database. If your database supports it (most likely it does), this has basically the same effect as FlushMode.NEVER, but it’s stronger since you cannot even flush manually.

Now let’s see how transaction propagation works.

If you don’t explicitly set readOnly to true, you will have read/write transactions. Depending on the transaction attributes (like REQUIRES_NEW), sometimes your transaction is suspended at some point, a new one is started and eventually committed, and after that the first transaction is resumed.

If a method in a read/write transaction calls a method that requires a readOnly transaction, the first one should be suspended, because otherwise a flush/commit would happen at the end of the second method.

Conversely, if you call a method from within a readOnly transaction that requires read/write, again, the first one will be suspended, since it cannot be flushed/committed, and the second method needs that.

In the readOnly-to-readOnly, and the read/write-to-read/write cases the outer transaction doesn’t need to be suspended (unless you specify propagation otherwise, obviously).

For Example:

<bean id=”dataSource” class=”org.springframework.jndi.JndiObjectFactoryBean”>

<property name=”jndiName”> <

value>java:comp/env/jdbc/appfuse</value>

</property>

</bean>