Here is a simple and effective approach to cloning objects in Java using XStream. The process uses XStream to serialize your object to XML, and then using the XML to create a new Java object that is a deep copy of the original.
Sheep dolly = new Sheep("Dolly");
XStream xstream = new XStream();
String xml = xstream.toXML(dolly);
Sheep newDolly = (Sheep)xstream.fromXML(xml);
I wish I never discovered Django templates because I shudder every time I have to use Freemarker or Velocity for my Spring MVC applications. Fortunately there is an alternative. You can use StringTemplate to generate your views in Spring MVC quite easily. StringTemplate enforces a strict separation of concerns, which therefore minimises the amount of logic that is allowed in the view, thus forcing you to do more in your controllers. Therefore your view remains purely for presentation purposes.
First things first is that you need to download StringTemplate and Antlr, and make those libraries available on your classpath. Next, extend Spring’s InternalResourceView.
import org.springframework.web.servlet.view.InternalResourceView;
import org.springframework.core.io.Resource;
import org.antlr.stringtemplate.StringTemplateGroup;
import org.antlr.stringtemplate.StringTemplate;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.io.PrintWriter;
public class StringTemplateView extends InternalResourceView {
@Override
protected void renderMergedOutputModel(Map model, HttpServletRequest request,
HttpServletResponse response) throws Exception {
Resource templateFile = getApplicationContext().getResource(getUrl());
StringTemplateGroup group = new StringTemplateGroup("webpages", templateFile.getFile().getParent());
StringTemplate template = group.getInstanceOf(getBeanName());
template.setAttributes(model);
PrintWriter writer = response.getWriter();
writer.print(template);
writer.flush();
writer.close();
}
}
Finally, you need to configure your Spring application context to use StringTemplate to render your views.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd>
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="com.agilecognition.bookshelf.web.view.StringTemplateView"/>
<property name="prefix" value="/WEB-INF/templates/"/>
<property name="suffix" value=".st"/>
<property name="requestContextAttribute" value="rc"/>
</bean>
</beans>
Now you can organise your StringTemplate files that have the “.st” suffix in /WEB-INF/templates. For example, you might want to organise your templates as follows.
WEB-INF
+ templates
+ layout
layout.st
+ partials
header.st
footer.st
feedback_form.st
contact_us.st
The layout.st template might look like the following template.
<html>
<body>
<div class="header">$partials/header()$</div>
<div class="content">$body$</div>
<div class="footer">$partials/footer()$</div>
</body>
</html>
The above layout.st contains the basic structure for an HTML page on your site. You can use this one template to keep a consistent look and feel across your entire site. The layout.st template depends on the header.st and footer.st templates that exist in the partials directory.
To insert the feedback form in feedback_form.st into the $body$ placeholder attribute for your contacts page you simply create a contact_us.st template with the following line.
$layout/layout(body=partials/feedback_form())$
When your controller handles the request to display the contact us page, the controller will return a ModelAndView with the view name set to “contact_us”. The view name maps to the contact_us.st file in your templates directory. StringTemplate will render the contact_us page using the layout template with the header, footer and feedback form templates.
Holy crap! I was just perusing the bin directory of my JDK installation and stumbled on a tool called VisualVM. It is a free lightweight profiling tool for the JVM. I can easily find which Java process maps to a specific Java application. Better yet the tool tells me what the PIDs are so that I can easily terminate “rogue” Java processes. VisualVM also provides visualisation tools for monitoring Java Classes, Threads, PermGen, and the Heap. It saves me from having to buy JProfiler or setting up Netbeans to profile my Java applications.
I have recently had the need to restrict a test to run within a certain time limit. If the test does not complete within a specific time constraint then the test should fail. The approach that I took was to run the function under test in its own thread and use a CountDownLatch to specify the duration in which the process should complete within. The code for this is as follows.
public class TimeConstrainedIntegrationTest {
private static final int RUN_ONCE = 1;
@Test
public void shouldVerifyGoogleIsAlive() throws Exception {
CountDownLatch doneSignal = new CountDownLatch(RUN_ONCE);
new Thread(new VerifyGoogleIsAliveWorker(doneSignal)).start();
boolean finishedInTime = doneSignal.await(10, TimeUnit.SECONDS);
assertTrue(finishedInTime);
}
private class VerifyGoogleIsAliveWorker implements Runnable {
private final CountDownLatch doneSignal;
VerifyGoogleIsAliveWorker(CountDownLatch doneSignal) {
this.doneSignal = doneSignal;
}
public void run() {
try {
try {
verifyGoogleIsAlive();
} catch (IOException e) {
throw new InterruptedException();
}
doneSignal.countDown();
} catch (InterruptedException ex) {
}
}
private void verifyGoogleIsAlive() throws IOException {
WebClient webClient = new WebClient();
Page page = webClient.getPage("http://google.com");
assertTrue(StringUtils.contains(page.getTitleText(), "Google"));
}
}
}
In the code above I assert that Google is alive by checking the title text for http://google.com is in fact Google. Essentially I am asserting expected behaviour, which is what you would typically do. I have encapsulated this within the verifyGoogleIsAlive() method above.
To make sure that the test runs within a specific time, the verifyGoogleIsAlive() method is called within the run method of a class that implements Runnable. In this case I have called the class VerifyGoogleIsAliveWorker. The test case shouldVerifyGoogleIsAlive() should be quite self-explanatory. First a CountDownLatch is instantiated. Then a new VerifyGoogleIsAliveWorker thread is started. The CountDownLatch then awaits for the VerifyGoogleIsAliveWorker thread to run its course and complete.
Of interest though is that the awaits() method on the CountDownLatch allows you to specify the length of time in which the CountDownLatch should wait before ending the thread. If the process doesn’t complete within the specified time, then the awaits() method will return false, and therefore fail the assertion that the test will run within a specific time. If on the other hand the process completes within the allocated time frame then the test will pass.
The above concurrency pattern should be useful in making sure that your tests run within a specific time frame.