Problem

You need to differentiate between build numbers. For example, you’ve just redeployed your application and need to ensure that the new version is what you are viewing. Or, you need to keep track of how many times you build. There could be many reasons why you want to know the build number that you are on. I use it for reporting bugs against specific builds.

Solution

maven-buildnumber-plugin. This Maven2 plugin will generate a unique build number each time your build your project. You can even configure which maven phase triggers the increment of the number. This plugin can also fetch data from SVN to ensure that a team of developers all get unique build numbers.

As a bonus, it generates a buildNumber.properties file so that you can read in this build number from anywhere in your project. Here is how I use the plugin.

First, update your pom.xml. You need to setup the build trigger.

<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>buildnumber-maven-plugin</artifactId>
      <version>1.0-beta-3</version>
      <executions>
        <execution>
          <phase>validate</phase>
          <goals>
            <goal>create</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <doCheck>true</doCheck>
        <doUpdate>false</doUpdate>
        <format>${version}.{0,number}</format>
        <items>
          <item>buildNumber0</item>
        </items>
      </configuration>
    </plugin>
  </plugins>
</build>

Now, you’ll need the build number and append it to your artifact’s final name. Add this to your pom.xml

<build>
  <finalName>
    ${project.artifactId}-${project.version}.{buildNumber}
  </finalName>
</build>

Now you’re package goal will output a file named

projectname-1.0.1.war

This is a great start and now you can differentiate each and every build. However, I need to take this a step further.

I need to see the version on my application’s index page. To do this, I use an ant filter to write the version and timestamp to a version.html file, and then copy it to my project’ web app directory. Add this to your pom.xm.

<build>
  <plugins>
    <plugin>
      <artifactId>maven-antrun-plugin</artifactId>
      <executions>
        <execution>
          <phase>compile</phase>
          <configuration>
            <tasks>
              <!-- versioning -->
              <echo message="[build version]"/>
              <delete file="target/projectname/version.html"/>
              <tstamp>
                <format property="rightNow" pattern="d MMM yyyy" locale="en"/>
              </tstamp>
              <copy todir="target/projectname">
                <fileset dir="src/main/webapp">
                  <include name="version.html"/>
                </fileset>
                <filterset>
                  <filter token="VERSION" value="${buildNumber}"/>
                  <filter token="BUILTON" value="${rightNow}"/>
                </filterset>
              </copy>
              <echo message=" version is ${buildNumber}"/>
            </tasks>
          </configuration>
          <goals>
            <goal>run</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Version.html is simple.

<p class="version">Version: @VERSION@</p>
<p class="built">Built on: @BUILTON@</p>

Finally, in my index page…

<jsp:include page="/version.html"/>

Almost everything you want to know about this plugin can be found on the plugin’s site: http://mojo.codehaus.org/buildnumber-maven-plugin/

Alternatives

As an alternative to writing and importing version.html, you can read buildNumber.properties in an MVC controller and put the version in your page model. This is what I for my login pages. I use a java class to read the build number, format it, and cache it. I start the first build number at 00100, then format that to 0.1.0. So the next build is 00101 which gets displayed as 0.1.1.

Update:Tips

Here is a usage tip. You can move the create goal into a build profile so that the build number only increments in specific situations. I use a profile for my Continuous Integration builds so that our version increments only when Hudson builds our apps. This also makes it possible to synchronize our Hudson build numbers to our module versions.

Feedback

What do you use to track build numbers? How do your format it?

Related Posts

• New and Unknown Java Libraries
• PropertyPlaceholderConfigurer with Default Values

My notes and thoughts about day two of strange loop 2009.

Also be sure to check out my Day one notes.

jQuery – Matt Taylor

• http://weblog.dangertree.net/
• Showed numerous examples how easy jQuery makes it to select and edit HTML elements. Made me realize I should use jQuery even in small apps.
• Also showed examples of the jQuery AJAX functionality

Mobile Development 101

• http://www.slideshare.net/michael.galpin
• http://fupeg.blogspot.com/
• This session was full which doesn’t surprise me since mobile development is about to get easier thanks to Android.
• Started off going how to develop apps for the iPhone
  • The emulator and development software only run on a Mac
  • Has to be written in Objective C
    • I wanted to throw up when I saw the objective c examples
    • No garbage collection. Memory is limited on phones so this is an important issue.
    • Maybe I’m just to much of a simpleton, but I really don’t ever want to write any objective C
  • MVC framework – cocoa touch
  • No background processing on iphone
• Android
  • Can run any language that is built on the JVM
  • XML format for UI develoment
  • Does not use standard MVC pattern. Uses something called Activities and Intents.
  • There are multiple android emulators
• Mobile dev best practices (not specific to android or iphone)
  • Need lean web services
  • Limit network traffic
  • Limit audio/video/images
• Mobile Web Application
  • Alternative to writing an iPhone/Android app
  • A lot of phones have the same browser now
  • Some mobile browsers leak memory

Entrepreneur Talk – Panel Discussion

• This book was mentioned, Outliers: The Story of Success
• Someone said that you need irrational arrogance to start your own company.
• Another person said that start ups are all offense and no defense. Just keep putting stuff out, early and often
• The idea was presented that everyone has risk even the person working for a company because you can be fired at any time
• The current work culture is sort of like having one client at a time because developers change jobs so often.

Polyglot Grails – Jeff Brown

• http://www.nofluffjuststuff.com/conference/speaker/jeff_brown
• http://javajeff.blogspot.com/
• You can use many languages with Grails. Jeff even gave an example of Grails with a simple language he created
• methodMissing(string name, args) is a very interesting feature of Groovy

Minimalism – Alex Payne

• http://twitter.com/Al3X
• http://al3x.net/books_talks.html
• Interesting talk about little m minimalism and how it be applied to code
• Alex made a few comments about how programming is a young field

List of slides on strangeloop.com
Day two sessions

Related Posts

• Strange Loop 2009 – Day 1
• Strange Loop 2010 – Early Bird Registration

A new developer conference has started in St Louis this year named Strange Loop. Normally I don’t go to developer conferences because they are either in a different country or on the coasts. This one was close by in St Louis, MO. And from the quality of speakers and diverse sessions I predict next years conference will sell out very quickly unless they increase the capacity. Below are my overall topics/themes I took away from the conference and some interesting points from each talk I witnessed along with links to the speaker’s site and slide show if available.


Day two

Strange Loop Thoughts Overall

• open source, open source, open source
• every talk envolved open source. The FUD around open source is finally withering away.
• DRY constant theme
• Mobile development is upon us and will be for maybe ever
• Scala, Clojure, Groovy are HOT languages on the JVM
• Great conference that covered many relevant topics
• All the talks were technical, no boring management oriented sales pitches

Functional Ruby – Dean Wampler

• http://deanwampler.com/
• Link to slide show
• I atteneded this talk because I’m interested in the functional programming line of thought. And I don’t get to see much ruby code.
• Recommends learning a functiona programming language: Scala, Hascal, Cojure
• Multiprocessor systems are making it more important to use threads. Threads and synchronizaton is hard to get right. So functional languages that have immutable objects/values are easier because immutable objects/values don’t require synchronization.
• Try to avoid a bloated domain objects that have numerous properties to fullfill multiple requirements for different use cases. Have smaller objects for seperate uses.

Polyglot Programming – Dean Wampler

• Link to slide show
• polyglot programming: using more than one programming language. Not like using CSS, JS. But like using Groovy and Java or Groovy and Clojure.
• Dean thinks that Scala could become very popular in the future
• Hybrid object and functional language
• Multiple cpus is driving the need for functional languages
• Mentioned the famous quote: “Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.”
  – Antoine de Saint-Exuper

Griffon (Swing just got fun again) – James Williams

• http://jameswilliams.be/blog/entry/index
• http://groovy.codehaus.org/Griffon
• Mentioned that the swring application framework is dead
• Griffon is the unofficial grails for the desktop
• It really did looks rails like from the project layout to the build process
• Suggested Groovy In Action for anyone that wanted to earn Groovy

Future of Java – Bob Lee

• http://crazybob.org
• Writes his talks in Java. I’m serious. Here is the SVN repo for his talks
  • http://crazybobs-talks.googlecode.com/svn/trunk/
• Talked about how/why he wanted better resource management in Java.
• Said he searched the JDK and found that 74 out of 110 the JDK has leaks for a certain IO functionality.
• Talked about his work on JSR-330 dependency injection in JDK
  • @Inject annotation
• New quicksort that was developed for Android JVM (Harmony)

Day two


Day One Sessions

Related Posts

• Strange Loop 2009 – Day 2
• Strange Loop 2010 – Early Bird Registration

This is a book review of Pro Java™ EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework

About the Book

Apress describes this book as

Pro Java™ EE Spring Patterns focuses on enterprise patterns, best practices, design strategies, and proven solutions using key Java EE technologies including JSP™, servlets, EJB™, and JMS APIs.

This Java EE patterns resource, catalog, and guide, with it’s patterns and numerous strategies, documents and promotes best practices for these technologies, implemented in a very pragmatic way using the Spring Framework and it’s counters.

The book was written by Dhrubojyoti Kayal. Dhrubojyoti works as a senior consultant with Capgemini Consulting. He has more than five years of experience developing and designing applications and products leveraging Enterprise Java technologies. His areas of interest include the Spring Framework, ORM, SOA, refactoring, prefactoring, and performance engineering.

In this book the author takes us through the process of refactoring a legacy system built without using patterns or the Spring Framework into a shiny new system leveraging Spring and design patterns. Throughout the book he takes us through this practical, real-word example.

Introduction to the MVC Pattern

The first chapter introduces you to the MVC pattern. I think that this book is for a well versed J2EE professional developer, who would probably be familiar with the pattern, so this chapter may have been overkill. However, the basis of this book is to refactor an antiquated web application to use Spring and the Spring MVC, so a clear and thorough understanding of the MVC pattern is necessary. Most readers of this book can probably skip this chapter. On the other hand it is written well enough that it would serve a good resource for any rookie developers that you might be working with who need to learn this pattern.

Patterns

Each chapter of this book takes you through the concepts of a common pattern, describes how the Spring Framework is used to implement that pattern, and then replaces the legacy insurance system code with new spring code. Once you get into the patterns, the book is divided into four major sections. These sections are

• Presentation Tier Design Patterns
• Business Tier Design Patterns
• Integration Tier Design Patterns
• Crosscutting Design Patterns.

This division helps to keep the conversation between the author and the reader focused and also makes it easy to find later when you come back to reference this information.

The Best Part

My favorite part about this book is that it is a patterns book. I like to read books based on patterns more than any other type of book. Patterns books are naturally broken down into small, manageable chunks of information. When written, patterns are usually described using a common, easy to follow template and are small enough to read an entire pattern in one sitting, whether that sitting be while you are eating your lunch or a quick read before hitting the pillow. Because they are written this way, it is easy to read this book very quickly and easy to find what you are looking for when you come back later for specific information. Pattern-based books are great.

I also liked this book because it takes you through all the layers of a real-world system. As developers we all have to work with legacy code. If you don’t your very lucky. Because this is real world it is very easy to follow along with the author and the project and see the benefits of Spring and refactoring to patterns.

Needs Refactoring

It’s a good, well-written book, but there are some things that I think need to be changed.

First, as with any book with code examples, there is some odd code that should be rewritten or removed. For example, there is a business bean that has a DAO injected into it via a setter. However, this bean also contains a getter for that DAO. This is not common practice and, in my opinion, not recommended.

And second, all of the presentation patterns are in a single chapter, and all of the business and integration patterns are in their own chapters. I think each pattern should have had its own chapter. I just prefer the clearer boundaries between patterns and I think it would make finding these patterns later, when I come to reference the book, a little easier.

You Should Read this Book

You should read this book if you are a developer who uses Spring, and especially if you use Spring MVC. This is a great resource and a great way to learn about how Spring utilizes patterns internally to implement its services. Of course it also shows you how to use Spring to add patterns to your current code base. You should read this book if you use an MVC framework that is not Spring MVC and are considering Spring MVC for  your next project or are considering adapting Spring MVC to your current project. While this book deals with more than just the Spring MVC, the entire presentation tier section is based on it.

Or Not…

I do recommend this book to most developers, however you should not read Spring Patterns if you are not well versed with J2EE/JEE and the Spring framework. If you are looking to learn Spring, there are other books that might be more suitable.

Here are some last notes, straight from Apress, about this book:

• What you’ll Learn:
  • Get an introduction to enterprise Java/Java EE application design patterns.
  • Simplify enterprise Java design using the popular Spring Framework.
  • Examine presentation, business, web, and integration tier design patterns and best practices, including cross–cutting design patterns, AOP, etc.
  • See how the enhanced and up–to–date pattern catalog compares to core J2EE design blueprints.
  • Learn how to use comprehensive source code and configuration information.
  • Develop order management system requirements for the first in–depth enterprise application case study.
  • Design your order management system application using the final case study.

Table of Contents

Finally, here is the table of contents:

Related Posts

• ASP.Net MVC Book Review and musings
• NHibernate 2 Beginner’s Guide – Book Review
• Outliers – A non technical book every freelancer/developer should read

There are several ways to get the HTML content of a URL from Java. There are even more ways to get the HTML using open source java libraries. Last week Lars Vogel shared how to get the HTML using nothing but the SDK.

SDK

final URL url = new URL("http://blog.codehangover.com");
final InputStream inputStream = new InputStreamReader(url);
final BufferedReader reader
             = new BufferedReader(inputStream).openStream();

String line;

while ((line = reader.readLine()) != null) {
   System.out.println(line);
}

reader.close();

Apache Commons HttpClient

You can also use the Apache Commons HttpClient for a slightly easier to use library.

HttpClient client = new HttpClient();
HttpMethod method = new GetMethod("http://blog.codehangover.com");

try {
 client.executeMethod(method);

 byte[] responseBody = method.getResponseBody();

 System.out.println(new String(responseBody));

} catch (Exception e) {

 e.printStackTrace();

} finally {

 method.releaseConnection();
}

But the real fun comes after you get the HTML. Now you get to work with it.

7 Things to do with HTML Source in Java

1. Extract the Text from the Markup

I worked on a web application that was similar to a feed reader. One of the features that we supported was searching the pages. To do this I needed to extract the text from the markup. I use the CyberNeko HTML Parser for this task.

private String getHtmlFilteredString(Reader reader)
{

  // create element remover filter
  ElementRemover remover;
  remover = new ElementRemover();
  remover.removeElement("script");
  remover.removeElement("link");
  remover.removeElement("style");
  remover.removeElement("CDATA");
  remover.removeElement("<!--");
  remover.removeElement("meta");

  OutputStream stream = new ByteArrayOutputStream();

  try
  {
    String encoding = "ISO-8859-1";
    XMLDocumentFilter writer = new Writer(stream, encoding);

    XMLDocumentFilter[] filters = {remover, writer};

    XMLInputSource source = new XMLInputSource(null, null, null, reader, null);

    XMLParserConfiguration parser = new HTMLConfiguration();
    parser.setProperty("http://cyberneko.org/html/properties/filters", filters);

    parser.parse(source);

  } catch (Exception e) {

    e.printStacktrace();
  }

  String content = stream.toString().trim();

  return content;
}

2. Extract Links

To find all of the links in an HTML fragment, maybe for your own spider, or to extract email addresses, you can use HtmlParser

Collection<String> links = new ArrayList<String>();

try {

  URI uriLink = new URI(url);
  Parser parser = new Parser();
  parser.setInputHTML(htmlBody);
  NodeList list = parser.extractAllNodesThatMatch(new NodeClassFilter (LinkTag.class));

  for (int i = 0; i < list.size (); i++){
    LinkTag extracted = (LinkTag)list.elementAt(i);
    String extractedLink = extracted.getLink();
    links.add(extractedLink);
  }

} catch (Exception e) {

  e.printStackTrace();
}

3. Change Links

Using the previous code, instead of calling getLink, you can call setLink to change the href. For example, this might be used by any type of analytics software that needs to track hits.

4. Collect Email Addresses

Using the previous code, before adding the link to the Collection, chech to see if it uses the mailto protocol by calling the boolean method isMailLink()

  for (int i = 0; i < list.size (); i++){

    LinkTag extracted = (LinkTag)list.elementAt(i);

    if (extracted.isMailLink())
    {
      String extractedLink = extracted.getLink();
      links.add(extractedLink);
    }
  }

5. Collect Images

Still using HtmlParser, you can extract images by filtering on the ImageTag.

Collection<String> imageUrls = new ArrayList<String>();

try {

  URI uriLink = new URI(url);
  Parser parser = new Parser();
  parser.setInputHTML(htmlBody);
  NodeList list = parser.extractAllNodesThatMatch(new NodeClassFilter (ImageTag.class));

  for (int i = 0; i < list.size (); i++){
    ImageTag extracted = (ImageTag)list.elementAt(i);
    String extractedImageSrc = extracted.getImageUrl();
    imageUrls.add(extractedImageSrc);
  }

} catch (Exception e) {

  e.printStackTrace();
}

6. Add Syntax Highlighting

If you’re going to present the source on screen you have to add syntax highlighting. If you’re displaying on a web page, I would highly recommend using something like SyntaxHighligher, which is what we use on this blog. If you are displaying an a Swing app, you can use a tool called  Syntax which is now several years old.

try {

     ToHTML toHTML = new ToHTML();

     toHTML.setInput(new FileReader("Source.java"));
     toHTML.setOutput(new FileWriter("Source.java.html"));
     toHTML.setMimeType("text/x-java");
     toHTML.setFileExt("java")

     toHTML.writeFullHTML();

 } catch (Exception e){

    e.printStackTrace();
 }

7. Diff Two Sources

Once you get the HTML source of two URLs, or you have an old version of the HTML stored somewhere, you might want a nicely formatted diff output.

Madlep wrote his own method to handle the diff and output the results over on Stackoverflow.com

Given some simple input, his code gives simple output.

String one = "" +
    "<ul>" +
    "  <li>item 1</li>" +
    "  <li>item 2</li>" +
    "</ul>";

String two = "" +
    "<p>This is text</p>" +
    "<ul>" +
    "  <li>item 1</li>" +
    "  <li>item 2</li>" +
    "  <li>item 3</li>" +
    "</ul>";

System.out.println(diffSideBySide(one, two));

Outputs

                     >  <p>This is text</p>
<ul>                    <ul>
 <li>item 1</li>          <li>item 1</li>
 <li>item 2</li>          <li>item 2</li>
                     >    <li>item 3</li>
</ul>                   </ul>

3 More Things to do with the HTML

This list sure feels incomplete at only 7 of a nice even 10 things. What else could you you do with the HTML? Ill pick the top three from the comments and finish this blog post with them.

(read html in java) (java get html source)

Related Posts

• PHP Framework Comparison
• Read HTML with Java – Then 7 Fun Things to do to It
• List of Version Control Web Sites

Here are some steps that can get you using Spring, JUnit and EasyMock all together in some Test Driven Development hotness.

Start by adding the following lines to the top of your unit test. Specifying Autowire by name ensures you get the injection you want and will stop those Spring errors that there are more than one of the same type of mock objects in your mock-applicationContext.xml. When you specify the Spring Junit runner you must provide one ore more context configurations with @ContextConfiguration.

MyClassUnitTest.java

...
@Configurable(autowire = Autowire.BY_NAME)
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:com/some/domain/someproject/resources/mock-applicationContext.xml"})
public class MyClassUnitTest {
...
     @Autowired private Collaborator mockCollaborator;

     @Before
     public void setup() throws Exception {
     ...
     }

     @After
     public void teardown() throws Exception {
     ...
     }

     @Test
     public void testMyClass() throws Exception {

          //Set your mock behavior here
          ....

          EasyMock.replay(mockCollaborator);

          MyClass myClass = new MyClass(mockCollaborator);
          myClass.run();
          EasyMock.verify(mockCollaborator);

          // Other JUnit assertions
          ...
     }
 }

Then add your mocks to your mock-applicationContext.xml (an applicationContext in your test resources just for providing your unit tests with spring injection dependencies):

mock-applicationContext.xml

...
<bean id="mockCollaborator" name="mockCollaborator" class="org.easymock.EasyMock" factory-method="createStrictMock">
     <constructor-arg value="com.some.domain.someproject.Collaborator"/>
</bean>

<bean id="mockOtherCollaborator" name="mockOtherCollaborator" class="org.easymock.EasyMock" factory-method="createStrictMock">
     <constructor-arg value="com.some.domain.someproject.OtherCollaborator"/>
</bean>
...

Ensure your maven pom has the following test-scoped dependency:

pom.xml

...
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-test</artifactId>
     <version>2.5.6</version>
     <scope>test</scope>
</dependency>
...

Then use your mocks as normal. Make sure you call EasyMock.reset(mock) in your @After teardown() method so that each of your mocks are reset for each test. You can also tell Spring to reset the context after a test if needed with @DirtiesContext.

For official documentation and tutorials check out these links.

Spring

http://www.springsource.org/documentation

JUnit

http://www.junit.org

EasyMock

http://easymock.org/Documentation.html

Related Posts

• Spring Patterns: Best Practices and Design Strategies Book Review
• Load Multiple Contexts into Spring
• Choose many Spring contexts over a single context

I have  already argued that many application contexts are better than a single application context. But how do you load more than one context?

There are a couple of ways to do this.

web.xml contextConfigLocation

Your first option is to load them all into your Web application context via the ContextConfigLocation element. You’re already going to have your primary applicationContext here, assuming you’re writing a web application. All you need to do is put some white space between the declaration of the next context.

<context-param>
    <param-name>
        contextConfigLocation
    </param-name>
    <param-value>
        applicationContext1.xml
        applicationContext2.xml
    </param-value>
</context-param>

<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

The above uses carriage returns. Alternatively, yo could just put in a space.

<context-param>
    <param-name>
        contextConfigLocation
    </param-name>
    <param-value>
        applicationContext1.xml applicationContext2.xml
    </param-value>
</context-param>

<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

applicationContext.xm import resourcel

Your other option is to just add your primary applicationContext.xml to the web.xml and then use import statements in that primary context.

In applicationContext.xml you might have…

<!-- hibernate configuration and mappings -->
<import resource="applicationContext-hibernate.xml"/>

<!-- ldap -->
<import resource="applicationContext-ldap.xml"/>

<!-- aspects -->
<import resource="applicationContext-aspects.xml"/>

Which strategy should you use?

I always prefer to load up via web.xml This allows me to keep all contexts isolated from each other. With tests, we can load just the contexts that we need to run those tests. This makes development more modular too as components stay loosely coupled, so that in the future I can extract a package or vertical layer and move it to its own module.

If you are loading contexts into a non-web application, I would use the import resource.

Any benefits to going with the application context import method over the web.xml contextConfigLocation?

Related Posts

• Spring Patterns: Best Practices and Design Strategies Book Review
• Getting friendly with Spring, JUnit and EasyMock.
• Choose many Spring contexts over a single context

This is a short introduction to splitting up your bean definitions from one single Spring application context, to many application contexts. That is, from one XML file to many XML files. The general idea is to have one single primary application context, usually titled applicationContext.xml, and then many other application contexts with are named what they contain.

Example

For example, a single web project might contain the following contexts.

• applicationContext.xml
• applicationContext-dao.xml
• applicationContext-dao-datasource.xml
• applicationContext-ldap.xml
• applicationContext-aspects.xml
• applicationContext-web.xml

Breakdown

In this example, your DAO definitions, transaction managers, and DAO or integration interceptors are defined in applicationContext-dao.xml. We have further broken the DAO application context to a dao-datasource which contains our data sources. LDAP configuration, beans, and DAOs are in their own applicationContext-ldap.xml.

Benefits

Why so many? There have been a few benefits so far.

Responsibility

The Single Responsibility Principal is widely accepted and states that

… every object should have a single responsibility, and that all its services should be narrowly aligned with that responsibility.states that every object should have a single responsibility, and that all its services should be narrowly aligned with that responsibility.

The same holds true for XML contexts.  The general ides is to make our contexts more robust and to be able to isolate a context’s tasks and capabilities. And clearly, working with a smaller XML file is easier than working with one enormous file. It is easier to maintain and easier to read.

Testing

When I wrote my tests for LDAP, I had my LDAP configuration in applicationContext.xml, but then every time I ran an LDAP test, I would get the WebApplicationContext, which would import applicationContext-hibernate, which would connect to the database. Tests took forever and needless resources were used. Now I just get applicationContext-ldap.xml which only contains LDAP configurations, so no needless resources are loaded and tests remain quick.

Inclusion and Exclusion

Finally, its really easy to comment out a line like

<import resource="applicationContext-aspects.xml"/>

and quickly have all my aspects, which for me only write logs, disabled. Or easy to add a line like

<import resource="applicationContext-dao-mock.xml"/>

which overrides all of your DAO implementations with mock DAOs. This would be for testing.

Does anyone else use multiple application context files? See any other benefits? Or problems?

Related Posts

• Spring Patterns: Best Practices and Design Strategies Book Review
• Getting friendly with Spring, JUnit and EasyMock.
• Load Multiple Contexts into Spring

My current project relies heavily on Spring. We use the PropertyPlaceholderConfigurer so that our application contexts can pull values from the properties files and inject them into our beans. This is all very common. This means when the beans are being created and a value like ${someproperty} shows up, the BeanFactory visits the configured properties files to find the value for someproperty and injects that value into the bean.

The problem arises when a bean is configured using such a placeholder but the requested property is not found. This causes our application to fail to start.

Our solution was to extend PropertyPlaceholderConfigurer to provide default values. These default values are loaded before loading any properties files.  Firs well glance over the java class.

import java.io.IOException;
import java.util.Properties;
import java.util.Map;
import java.util.HashMap;

public class DefaultPropertyPlaceholderConfigurer
        extends org.springframework.beans.factory.config.PropertyPlaceholderConfigurer
{
  private Map<String, String> startingProperties = new HashMap<String, String>();

  public void setStartingProperties(Map<String, String> startingProperties)
  {
     this.startingProperties = startingProperties;
  }

  public DefaultPropertyPlaceholderConfigurer()
  {
      try
      {
          loadDefaultProperties();
      }
      catch (IOException e)
      {
          logger.warn("failed to load default properties", e);
      }
  }
   private void loadDefaultProperties()
          throws IOException
  {
      final Properties defaultProperties = new Properties();
       for(Map.Entry<String,String> entry : startingProperties.entrySet())
      {
          defaultProperties.put(entry.getKey(), entry.getValue());
      }
       this.setPropertiesArray(new Properties[]{defaultProperties});
  }
}

And the XML bean definition for our new PropertyPlaceholderConfigurer.

  <bean id="propertyConfigurer"
        class="app.factory.config.DefaultPropertyPlaceholderConfigurer">
      <property name="ignoreUnresolvablePlaceholders" value="true" />
      <property name="startingProperties">
          <map>
              <entry key="one.two.three" value="123" />
          </map>
      </property>
      <property name="locations">
          <list>
              <value>/WEB-INF/classes/preferences.properties</value>
          </list>
      </property>
  </bean>

So now, when one.two.three is not included in the properties file preferences.properties the value will be initialized to 123. The value is defined in the properties file, the default value of 123 is overridden with the custom value.

Use Case

Here are the details on our specific use case. We release updates that add new properties, however, in order for the user to run the updates, the application has to start first (it is a web application). If the property is not set then the BeanFactory fails to start the application because it can not resolve the placeholder. So the software can’t start without running the updates first, but the updates can not be run until the application is started.

Now the web application starts and uses the default value, the administrator can run the updates which add the custom values to the preferences.properties file, and the user is prompted to restart the software after the updates are complete. The restart is required to read the new values into the bean.

Oops

While I was writing this post I realized that there was a much simpler way to provide default properties without extending the base class.

Any ideas as to how I could have done it?

Related Posts

• Track every Build Number with Maven
• Spring Patterns: Best Practices and Design Strategies Book Review
• Getting friendly with Spring, JUnit and EasyMock.