Mark Fisher

Mark Fisher

Alumni
Recent Blog posts by Mark Fisher

Customizing Annotation Configuration and Component Detection in Spring 2.1

Engineering | May 29, 2007 | ...

NOTE: This post has been updated as of May 31, 2007 to reflect the state of the 2.1-M2 official release

Two weeks ago I blogged about the new annotation-driven dependency injection capabilities of Spring 2.1, and I mentioned that I would follow-up with more info "later in the week". It turns out that was a bit optimistic, but the good news is the functionality has evolved quite a bit in the meantime. Therefore, to follow along with the examples here you will need to download the 2.1-M2 official release (or if you are one of the first people to read this updated entry and M2 is not yet available, you should grab at least nightly build #115 which you can download here).

The first thing I want to demonstrate is how to create an application context without using any XML. For those who have used Spring's BeanDefinitionReader implementations, this will look very familiar. Before creating the context however, we need a few "candidate" beans on the classpath. Continuing with the example from my previous blog, I have the following two interfaces:


public interface GreetingService {
	String greet(String name);
}

public interface MessageRepository {
	String getMessage(String language);
}

...and these corresponding implementations:


@Component
public class GreetingServiceImpl implements GreetingService {

	@Autowired
	private MessageRepository messageRepository;
	
	public String greet(String name) {
		Locale locale = Locale.getDefault();
		if (messageRepository == null) {
			return "Sorry, no messages";
		}
		String message = messageRepository.getMessage(locale.getDisplayLanguage());
		return message + " " + name;
	}
}

@Repository…

Annotation-Driven Dependency Injection in Spring 2.1

Engineering | May 14, 2007 | ...

Spring 2.0 introduced annotation support and annotation-aware configuration options that can be leveraged by Spring users who are developing with Java 5 (or later versions):

@Transactional for demarcating and configuring transaction definitions
@Aspect (AspectJ) for defining aspects along with @Pointcut definitions and advice (@Before, @After, @Around)
@Repository for indicating a class that is operating as a repository (a.k.a. Data Access Object or DAO)
@Required for enforcing annotated bean properties are provided a value

With Spring 2.1, this theme of annotation-driven configuration has been significantly extended and will continue to evolve as we progress toward the RC1 release. In fact, it is now possible to drive Spring's dependency injection via annotations. Furthermore, Spring can discover beans that need to be configured within an application context.

This blog entry will serve as a tutorial-style introduction to the basic features in 10 easy-to-follow steps. I will follow up later in the week with information on some more advanced features and customization options. If you are interested in alternative configuration options, you should also check out the Spring Java Configuration project and this blog.

This tutorial requires at least Java 5, and Java 6 is recommended (otherwise there is a single requirement at the end of step 1).

Step 1:

Grab spring-framework-2.1-m1-with-dependencies.zip. After extracting the archive, you will find the spring.jar and spring-mock.jar in the 'dist' directory. Add them to your CLASSPATH as well as the following (paths shown are relative to the 'lib' directory of the extracted 2.1-m1 archive):

  • asm/asm-2.2.3.jar
  • asm/asm-commons-2.2.3.jar
  • aspectj/aspectjweaver.jar
  • hsqldb/hsqldb.jar
  • jakarta-commons/commons-logging.jar
  • log4j/log4j-1.2.14.jar
(NOTE: If you are not running on Java 6, you will also need to add j2ee/common-annotations.jar)

Step 2:

Provide the interfaces and classes for the example. I have tried to keep it as simple as possible yet capable of demonstrating the main functionality. I am including all of the code and configuration in a single "blog" package. I would encourage following that same guideline so that the examples work as-is; otherwise, be sure to make the necessary modifications. First, the GreetingService interface:

public interface GreetingService {
    String greet(String name);
}

Then, a simple implementation:


public class GreetingServiceImpl implements GreetingService {
    private MessageRepository messageRepository;

    public void setMessageRepository(MessageRepository messageRepository) {
        this.messageRepository = messageRepository;
    }

    public String greet(String name) {
        Locale locale = Locale.getDefault();
        String message = messageRepository.getMessage(locale.getDisplayLanguage());
        return message + " " + name;
    }
}

Since the service depends upon a MessageRepository, define…

Request-Reply JMS with Spring 2.0

Engineering | April 04, 2007 | ...

Several months ago, I posted a blog entry introducing Spring 2.0's support for Message Driven POJOs. While many people are now familiar with that feature, Spring 2.0's JMS remoting features have received less attention. Essentially, this remoting functionality provides a JMS-based version of Spring's general approach to remoting as exhibited in its support for RMI, Hessian/Burlap, and its own HttpInvoker.

For those unfamiliar with Spring remoting, the general idea is to configure a non-invasive exporter on the server-side and a proxy generator (a Spring FactoryBean) on the client-side.

I will demonstrate this JMS remoting here with a code example - based on the same example as in my previous post

Dynamic DataSource Routing

Engineering | January 23, 2007 | ...

Spring 2.0.1 introduced an AbstractRoutingDataSource. I believe that it deserves attention, since (based on frequent questions from clients) I have a hunch that there are quite a few 'home-grown' solutions to this problem floating around. That combined with the fact that it is trivial to implement yet easy to overlook, and now I have several reasons to dust off my corner of the team blog.

The general idea is that a routing DataSource acts as an intermediary - while the 'real' DataSource can be determined dynamically at runtime based upon a lookup key. One potential use-case is for ensuring transaction-specific isolation levels which are not supported by standard JTA. For that, Spring provides an implementation: IsolationLevelDataSourceRouter

Boston Spring Group First Meeting

Engineering | September 25, 2006 | ...

I am very excited to announce that the Spring SIG within the New England Java Users Group will be having our first meeting this Thursday (September 28th, 2006). Ramnivas Laddad (author of AspectJ in Action and Interface21 Principal) will be presenting "AspectJ for Spring Developers". This will be a great chance to learn about the enhancements in AspectJ integration within Spring 2.0.

You can read the details HERE, and be sure to click on the 'Register' link on the left-hand side of the page if you plan on attending.

This group will provide a great forum for "all things Spring" and will be meeting roughly once per quarter initially. I am looking forward to building a community and personally meeting fellow Spring users in the greater Boston area.

A special thanks to NEJUG president Steven Maienza and the NEJUG members who expressed an interest in having a Spring group and put this into motion before I even moved to Boston. Thanks!

Message Driven POJOs!

Engineering | August 11, 2006 | ...

Of all the new Spring 2.0 features and improvements, I must admit that Message-Driven POJOs are one of my personal favorites. I have a feeling that a lot of other Spring users will feel the same way.

Here I am providing a quick introduction. There is a lot more to show, and I will follow this up with other posts. For now though - this should provide you with enough information to get up and running with some truly POJO-based asynchronous JMS! I hope you are as excited about that as I am ;)

Prerequisites:

You will need the following JAR files on your classpath. I've also listed the versions that I am using (any spring-2.x version should be fine. I just dropped RC3 in there about 2 minutes ago in fact):

  • activemq-core-3.2.2.jar
  • concurrent-1.3.4.jar
  • geronimo-spec-j2ee-managment-1.0-rc4.jar
  • commmons-logging-1.0.4.jar
  • log4j-1.2.9.jar
  • jms-1.1.jar
  • spring-2.0-rc3.jar

Setup the Environment

First, we need to setup the environment. I am going to be using ActiveMQ, but the impact of changing a provider will be limited to modifications within this one file. I'm calling this file "shared-context.xml" since as you will see shortly, I am going to be importing these bean definitions for both sides of the JMS communication. Here are the "shared" bean definitions: the connection factory and two queues (one for the requests and one for replies):


<?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.xsd">
	
    <bean id="requestQueue" class="org.activemq.message.ActiveMQQueue">
        <constructor-arg value="requestQueue"/>
    </bean>
 
    <bean id="replyQueue" class="org.activemq.message.ActiveMQQueue">
        <constructor-arg value="replyQueue…

10 Common Misconceptions About Spring

Engineering | August 04, 2006 | ...

Yesterday there were a few posts related to the forthcoming Beginning Spring 2 book, and I wanted to point those out here.

First, since this book will be of interest to those new to Spring - or even those who are simply curious at this point, we decided that it would be a good idea to include some discussion of common misconceptions about Spring. These have been posted here:
http://www.oreillynet.com/onjava/blog/2006/08/ten_common_misconceptions_abou.html
and on the Apress blog: http://ablog.apress.com/?p=1221.



Second, Interface21's Steven Devijver, the book's tireless lead author, has posted a great overview:
http://blog.interface21.com/main/2006/08/03/finishing-beginning-spring-2-from-novice-to-professional/.


The book, Beginning Spring 2: from Novice to Professional, will be in stores this October. While it aims to provide a gentle introduction appropriate for new Spring users, it will also be very useful for "filling in the gaps" even if you have been using the Spring Framework for a while. In other words, the book covers a lot of ground: the Spring container, AOP, data acess, MVC, and more. The coverage includes many new Spring 2.0 features - most notably an entire chapter exploring Spring's new and improved approach to AOP such as the XSD-based AOP namespace, integration with the AspectJ pointcut expression language, and @AspectJ integration! (Don't worry Spring 2 is backwards compatible - and the migration path is easy too). Throughout, the book provides a pragmatic balance of theory and examples. Those examples are backed by an interesting sample application (not overly simplistic). I personally was delighted when Steven asked me to contribute some exercises - yet another of his great ideas for providing an excellent resource to beginners. The first set of exercises walk through several techniques of dependency injection from basic wiring to the use of FactoryBeans and externalizing properties files. The second set of exercises are focused on AOP - including the new namespace and the @AspectJ style.

We are looking forward to an active companion site after the book's release, and of course you can continue to find many great discussions and examples of Spring 2.0 features here at the Interface21 team blog.

Getting Started With JPA in Spring 2.0

Engineering | May 30, 2006 | ...

The motivation behind this blog entry is to provide a simple step-by-step guide for getting started with JPA in a standalone environment with the Spring Framework. While the JPA specification originated as the persistence mechanism for EJB 3.0, it was fortunately recognized that any such mechanism should in fact be able to persist simple POJOs. Therefore, with a handful of JARs in your classpath and a few Spring-configured beans, you can begin experimenting with JPA code within your favorite IDE. I will be using Glassfish JPA - which is the reference implementation and is based upon Oracle's…

POJO Aspects in Spring 2.0: A Simple Example

Engineering | March 22, 2006 | ...

While the material in this post is quite simple, it will actually offer a glimpse of some rather significant new features in Spring 2.0. I hope that with a little imagination, you will be able to apply what you see here to far less trivial use cases of your own.

I am going to show 2 examples actually. The first will use a rather simple logger:


package example;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class SimpleLogger {

  private static Log log = LogFactory.getLog(SimpleLogger.class);

  public void logOneString(String s) {
    log.info…

Get ahead

VMware offers training and certification to turbo-charge your progress.

Learn more

Get support

Tanzu Spring offers support and binaries for OpenJDK™, Spring, and Apache Tomcat® in one simple subscription.

Learn more

Upcoming events

Check out all the upcoming events in the Spring community.

View all