Java程序辅导
C C++ Java Python Processing编程在线培训 程序编写 软件开发 视频讲解
C C++ Java Python Processing编程在线培训 程序编写 软件开发 视频讲解
Lab Class 2 Following the course book (Spring In Action, by Craig Walls), you will wire together some simple components to make a talent show. So, introducing Spring Idol… Create a new Java Application Project:
Name it SpringIdol, and name the Main class SpringIdolMain.java (check that NetBeans is going to create it in the package “springidol”:
(Please ignore the warning in the above screen shot – I captured it after I had already created the project). You now need to import the Spring 2.5 framework into the project. Right click the project name and select Properties. In the Library Category, click on Add Library, and scroll down the list to select and add Spring Framework 2.5. You should end up with this:
Now we are going to create all kinds of performers, but they are all going to implement the “Performer” interface.
Right click the springidol package to create a new Java Interface:
Once you have created it, edit the file in NetBeans to declare the perform() method:
public interface Performer {
void perform() throws PerformanceException; This is going to raise an error at first, as you need to define the
PerformanceException. To save you typing, you can download
PerformanceException.java from the course’s website and copy it into the springidol package. Now we can construct our first performer. Create a new java class called
Juggler in the springidol package. You should know how to do this by now. You now need to put some content into the body of the class. Edit it so that it looks like the following:
public class Juggler implements Performer {
private int beanBags = 3;
public Juggler() {}
public Juggler(int beanBags) {
this.beanBags = beanBags;
}
public void perform() throws PerformanceException {
System.out.println("JUGGLING " + beanBags + " BEANBAGS");
}
}
Now you need to create the configuration file to do all the component “wiring” and to inject properties. You will need to move from the Project view to the Files view in NetBeans. Then right click the SpringIdol project, select New/Other… to enable you to create an XML file:
In the Next screen, name the document “spring‐idol” and click Next. Finally, check that “Well‐formed document” is selected and Finish. There are some fiddly decarations to go into this document, so to make life easier, you can download version 1 of spring-idol.xml from the website and copy and paste to the file in NetBeans. (You could have just copied the xml file into the top level of the SpringIdol project, but I wanted you to see how to get NetBeans to start an xml document for you). Note how “duke” is declared as a Juggler in spring-idol.xml Now we are ready to run Duke, but using his default properties. The only thing that the Main class needs to know about Duke is that he is a Performer – that is, he implements the Performer interface, and so can “perform”. So we can keep the main method quite generic, and just specify which bean we are going to use. Modify SpringIdolMain so that it looks like the definition below. Notice that Duke is “cast” into his interface type.
package springidol;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
/**
*
* @author Craig Walls
*/
public class SpringIdolMain {
public static void main(String[] args) {
ApplicationContext ctx =
new FileSystemXmlApplicationContext("spring-idol.xml");
Performer performer = (Performer) ctx.getBean("duke");
performer.perform();
}
}
Run the project and you should see a him juggle three bean bags. Now modify Duke’s declaration in spring‐idol.xml to the following:
(You can choose any number you like, of course, not just 12).
Importing Object References: Now we can make Duke even more talented by enabling him to recite a poem while he juggles. We need to declare a new class PoeticJuggler that extnds Juggler. Again, to save typing, you can download this file from the website. Copy it into the project. Notice that this bean will be like a Juggler but it has a Poem as a property too. As the Poem will be a bean too, we will link to it via an interface. Here is the interface definition for Poem:
public interface Poem {
void recite();
} Create a new Java Interface called Poem and edit it to declare the recite() method as above. Now we are going to create an implementation of this interface that recites a
sonnet (a kind of poem that follows a very specific rhythm). I don’t want you to type out a whole poem, so you can download Sonnet29.java from the website, and copy it into the project. We can declare the new bean as follows:
You can run the main method again unchanged to see the result.
Injecting into Bean Properties: Spring supports both constructor and setter injection. We have seen constructor injection. We are now going to explore setter injection, to inject properties into a Bean. Let’s introduce Kenny, a talented instrumentalist. An Instrumentalist will also implement the Performer interface, but will have a Song and an Instrument as properties. Again, to save typing, you can download the file from this class and copy it into the project. Notice that although Kenney’s song will be a string, his Instrument will be another Bean. So we need another interface:
public interface Instrument {
void play();
} You should know how to set this up by now! Let’s give Kenny a saxophone to start with:
public class Saxophone implements Instrument {
public Saxophone() {
}
public void play() {
System.out.println("TOOT TOOT TOOT");
}
} Add in the bean declaration for the Saxophone:
You don’t need to remove any earlier declarations. We can make Kenny perform in the main method simply by changing “duke” to “kenny” (they both implement the Performer interface). Kenny can play the Piano too:
public class Piano implements Instrument {
public Piano() { }
public void play() {
System.out.println("PLINK PLINK PLINK");
}
} Create this class, and then add in the declaration for Piano: