SpringIDE - Using Spring in Eclipse

Creating a New Project

To create a new project, you just need to use the New Spring Project wizard to get going. If you don't do this it's ok -you can just add a "Spring Nature" to your project at a later stage.

It's important to have a few core jars included in your library. Firstly,we want to run the Spring container in our application, so we should include spring.jar from the dist directory of the Spring download.
Additionally, we need two more jars to get running with Spring AOP. If you've downloaded Spring with dependencies, you can find these libraries in lib directory. Jakarta Commons logging is always required by Spring, and you will also need to include cglib.

Object Creation

When implementing a bean/object to be held in the Spring container, you will need to first create an interface for
that bean.

public interface ISampleBean 
{
	public void setName(String name);
	public String getName();
	
	public void setAge(String age);
	public String getAge();
}

Following this, we will create an implementation of that interface. Don't forget you can make this very easy on yourself by using the new class wizard, and choosing to implement stubs for the methods in your interface.

public class SampleBean implements ISampleBean
{
	private String name;
	private String age;
	
	public String getName() 
	{
		return name;
	}
	public void setName(String name) 
	{
		this.name = name;
	}
	public String getAge() 
	{
		return age;
	}
	public void setAge(String age) 
	{
		this.age = age;
	}
}

Create a New Bean Definition File

Next, we need to make the Spring container aware of this bean. To do this we add a new Spring Bean Definition using the wizard provided by SpringIDE.

We will be using aspects, as well as beans in our Spring container, we need to select both the AOP and
bean namespaces. There are other namespaces available depending on what you need your Spring container to do, but for this example we don't need any others.

There is also the option to add this configuation to a Bean Config Set. As we are only using on configuration file,
this is outside of our example. In the Design view (which will be opened by default) for you configuration file, you can easily add elements to represent your beans.

The first bean we add is the implementation of the interface defined earlier, as this is the object we wish
to intercept. All we need to do is provide an id for us to reference this bean with, and a class attribute to show
exactly which object this is.

Add Method Interceptor

The next step is to add a MethodInterceptor implementation. Here all we will do is print out a message when we intercept a method (i.e. when the method has been called).

package com.eclipsezone.spring.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class Interceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation methodInv) throws Throwable 
	{
		System.out.println("Intercepted method - " + methodInv.getMethod().getDeclaringClass() 
		+ " - " + methodInv.getMethod().getName());
		// TODO Auto-generated method stub
		
		return null;
	}

}

This interceptor then needs to be added to the configuration file.

Once we have added the bean and the interceptor, we need to put it all together. In order to create the bean from the Spring container, we will need to use a ProxyFactoryBean.
This then needs the following properties:

• proxyInterfaces - This needs to be given the value of the interface defined earlier for the bean
• interceptorNames - A list of interceptor names, in this case 'interceptor'
• target - A reference to the id of the bean we wish to access, in this case 'com.eclipsezone.spring.sample'
• proxyTargetClass - Should be set to true

For completeness, here is the configuration file in pure 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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	<bean id="com.eclipsezone.spring.sample" class="com.eclipsezone.spring.test.SampleBean"></bean>
	<bean id="interceptor" class="com.eclipsezone.spring.aop.Interceptor"></bean>
	<bean id="proxyBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="proxyInterfaces">
			<value>com.eclipsezone.spring.test.ISampleBean</value>
		</property>
		<property name="interceptorNames">
			<list>
				<value>interceptor</value></list></property>
		<property name="target">
			<ref local="com.eclipsezone.spring.sample" /></property>
		<property name="proxyTargetClass">
			<value>true</value></property>
	</bean>
</beans>

Run the Example

So now we need to put it all together and see the example in action. The following code sets up the Spring container within our application, and loads up the bean from the container, using a reference to the proxy. It's important that we do this, as just instantiating the bean using new <instance>(), won't add in the interceptor.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Tester 
{
	private static ApplicationContext context;
	
	/**
	 * Load up the Spring container 
	 */
	private void loadContext()
	{
		String filename = "beanDefinition.xml";  
		context = new FileSystemXmlApplicationContext(filename);
	}
	
	public static void main(String[] args) 
	{
		
		Tester test = new Tester();
		test.loadContext();
		//reference the proxy through the Spring container
		SampleBean sb = (SampleBean)context.getBean("proxyBean");
		sb.setName("New Name");
	}
}

It's a pretty simple example, but it shows the possibilities when you use Spring in your application.
Of course there's a lot more to Spring than just AOP - I'd encourage you to try out some of the other
features that Spring gives you.