Getting Started
- Static ApplicationContext access
- Creating a Spring application
- Arbitrary Spring loading
- Runtime bean wiring
- FitNesse-Spring integration
Static ApplicationContext access
It is often useful to gain access to the ApplicationContext object in order to locate existing beans. Sproing provides a ApplicationContextProvider class that can be used anywhere in a spring application to access the application context like so:
ApplicationContext ctx = ApplicationContextProvider.getApplicationContext();
If you have used Sproing to start the application and/or load Spring, you will automatically have access to this class. If you want to use this feature of Sproing in a web application, all you need to do is declare the ApplicationContextProvider as a spring bean in your spring xml file ie
<bean id="applicationContextProvider"
class="uk.org.sith.sproing.spring.ApplicationContextProvider"/>
Creating a Spring application
Creating a standalone (ie non-web) application can seem a little confusing to some. Sproing makes this easy by extending a Sproing class and implementing a method, and that's it! All you need do is have your main (the class with the main() method that starts the application) extend ApplicationWirer and implement the getPaths() method that returns the path(s) to your application context xml files. Then a single call to the wire() method does the rest
import uk.org.sith.sproing.spring.ApplicationWirer;
public class Main extends ApplicationWirer {
public static void main(String[] args) {
Main main = new Main();
main.wire(main);
}
public String[] getPaths() {
return new String[] {"applicationContext.xml"};
}
}
This code will start your application and load the applicationContext.xml file into spring with all the spring beans defined. Easy!
Arbitrary Spring loading
Sometimes is is desirable to load spring when an arbitrary (ie, not containing a main() method) object is created. Sproing provides this for when another application is creating java objects in order to provide a route into your code (for example FitNesse, The Grinder etc) that you need to wire into spring. Sproing does this by loading any application context files you specify and then wiring the object into it, allowing you to inject beans at runtime.
Spring beans are weired using the AutowireCapableBeanFactory.AUTOWIRE_BY_NAME strategy, so your object needs to have setter methods with the same names as the beans you want to wire up. You need to create a subclass of ApplicationWirer and implement the getPaths() method to return the paths of the spring application context files you want to wire up
For example:
public class YourAppWirer extends ApplicationWirer {
public String[] getPaths() {
return new String[] {
"classpath:someApplicationContext.xml",
"classpath:applicationContext.xml"};
}
}
To wire up your object, all you need do is create a new instance of your overridden ApplicationWirer class in a constructor on your object, and call the wire() method
For example, using YourAppWirer in the above example:
public class JediMindTrick {
public JediMindTrick() {
new YourAppWirer().wire(this);
}
}
Provided you have defined public setter methods for any spring dependencies your object needs, and called them the same names as described
above, spring will inject these at runtime. You can then write your object methods as normal
Runtime bean wiring
Sproing provides an easy method of wiring an object into Spring at runtime when that object han't been created by Spring but needs access to Spring beans. The SpringWirer class provides a static method that, given an object, will wire it into the existing application context and set the spring beans needed
public class Jedi {
private Force force;
public Jedi() {
// wire this object up
SpringWirer.wireBean(this);
force.push();
}
// set the Force spring bean
public void setForce(Force force) {
this.force = force;
}
}
In this example, the Force object can be accessed because it is a bean defined in Spring. At runtime, the SpringWirer.wireBean(this) call will wire the object into Spring, setting the Force object using the setter method
FitNesse-Spring integration
Sproing wires up FitNesse fixtures into Spring using all of the above features to load any application context files you specify and then wiring the fixture into it, allowing you to inject beans into the fixture at runtime. You need both FitNesse and Spring in the classpath of your application
The fixture needs to implement SpringWirableFixture and extend your chosen FitNesse fixture. It is wired using the AutowireCapableBeanFactory.AUTOWIRE_BY_NAME strategy - it needs to do this to work properly with FitNesse, so your fixtures need to have setter methods with the same names as the beans you want to wire up
You need to create a subclass of FixtureWirer and implement the getPaths() method to return the paths of the spring application context files you want to wire up
For example:
public class YourAppFixtureWirer extends FixtureWirer {
public String[] getPaths() {
return new String[] {
"classpath:fitnesseApplicationContext.xml",
"classpath:applicationContext.xml"};
}
}
To wire up your fixture, all you need do is create a default constructor (or setUp() method if using a fixture that has one) and create a new instance of your overridden FitnesseFixtureWirer class
For example, using YourAppFixtureWirer in the above example:
public class JediFixture extends ColumnFixture implements SpringWirableFixture {
public JediFixture() {
new YourAppFixtureWirer().wire(this);
}
}
FitNesse will call the default constructor, wiring up your fixture with the bean factory. Provided you have defined public setter methods for any spring dependencies your fixture needs, and called them the same names as described above, spring will inject these at runtime. You can then write your fixture methods as normal