Code:
public abstract class Instrumentalist implements Performer { public Instrumentalist() {} public void perform() throws PerformanceException { System.out.print("Playing " + song + " : "); getInstrument().play(); } private String song; public void setSong(String song) { this.song = song; } public abstract Instrument getInstrument(); }
XML:
<bean id="stevie" class="com.springinaction.springidol.Instrumentalist"> <lookup-method name="getInstrument" bean="guitar" /> <property name="song" value="Greensleeves" /> </bean> <bean id="guitar" class="com.springinaction.springidol.Guitar" scope="prototype" />
Notice: Bean "guitar" must be prototype otherwise always same instance will be returned
As with <replaced-method>, the name attribute of <lookup-method> indicates the method that is to be replaced. Here we’re replacing the getInstrument() method. The bean attribute refers to a bean that should be returned when getInstrument() is called. In this case, we’re wiring in the bean whose id is guitar. As a result, the getInstrument() method is effectively overridden as follows:
public Instrument getInstrument() { ApplicationContext ctx = …; return (Instrument) ctx.getBean("guitar"); }
On its own, getter injection is just a reversal of setter injection. However, it makes a difference when the referenced bean is prototype scoped:Even though it’s prototype scoped, the guitar method would only be injected once into a property if we were using setter injection. By injecting it into the get-
Instrument() method through getter injection, however, we ensure that every call to getInstrument() will return a different guitar. This can come in handy if a guitarist breaks a string in the middle of a performance and needs a freshly stringed instrument.
You should be aware that although we used <lookup-method> to perform getter injection on the getInstrument() method, there’s nothing about <lookupmethod> that requires that the replaced method actually be a getter method (i.e., one whose name starts with get). Any non-void method is a candidate for replacement with <lookup-method>.
It’s important to note that while method injection allows you to change a method’s implementation, it’s not capable of replacing a method’s signature. The parameters and return type must