Spring--依赖注入

1 //定义Person接口
2 public interface Person
3 {
4 //Person接口里定义一个使用斧子的方法
5 public void useAxe();
6 }

1 //定义Axe接口
2 public interface Axe
3 {
4 //Axe接口里有个砍的方法
5 public void chop();
6 }

 1 //Chinese实现Person接口
 2 
 3 public class Chinese implements Person
 4 {
 5 //面向Axe接口编程，而不是具体的实现类
 6 private Axe axe;
 7 //默认的构造器
 8 public Chinese()
 9 {}
10 //设值注入所需的setter方法
11 public void setAxe(Axe axe)
12 {
13 this.axe = axe;
14 }
15 //实现Person接口的useAxe方法
16 public void useAxe()
17 {
18 System.out.println(axe.chop());
19 }
20 }

 1 //Axe的第一个实现类 StoneAxe
 2 
 3 public class StoneAxe implements Axe
 4 {
 5 //默认构造器
 6 public StoneAxe()
 7 {}
 8 //实现Axe接口的chop方法
 9 public String chop()
10 {
11 return "石斧砍柴好慢";
12 }
13 }

 1 ＜!-- 下面是标准的XML文件头 --＞
 2 ＜?xml version="1.0" encoding="gb2312"?＞
 3 ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
 4 "http://www.springframework.org/dtd/spring-beans.dtd"＞
 5 ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
 6 ＜!-- Spring配置文件的根元素 --＞
 7 ＜BEANS＞
 8 ＜!—定义第一bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
 9 ＜BEAN class="lee".Chinese id=chinese＞
10 ＜!-- property元素用来指定需要容器注入的属性，axe属性需要容器注入此处是设值注入，因此Chinese类必须拥有setAxe方法 --＞
11 
12 ＜property name="axe"＞
13 ＜!-- 此处将另一个bean的引用注入给chinese bean --＞
14 ＜REF local="”stoneAxe”/"＞
15 ＜/property＞
16 ＜/BEAN＞
17 ＜!-- 定义stoneAxe bean --＞
18 ＜BEAN class="lee".StoneAxe id=stoneAxe /＞
19 ＜/BEANS＞

 1 public class BeanTest
 2 {
 3 //主方法，程序的入口
 4 public static void main(String[] args)throws Exception
 5 {
 6 //因为是独立的应用程序，显式地实例化Spring的上下文。
 7 ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
 8 //通过Person bean的id来获取bean实例，面向接口编程，因此
 9 //此处强制类型转换为接口类型
10 Person p = (Person)ctx.getBean("chinese");
11 //直接执行Person的userAxe()方法。
12 p.useAxe();
13 }
14 }

 1 ＜?xml version="1.0"?＞
 2 ＜!-- 定义编译该项目的基本信息-->
 3 ＜PROJECT name="spring" default="." basedir="."＞
 4 ＜!-- 定义编译和运行该项目时所需的库文件 --＞
 5 ＜PATH id=classpath＞
 6 ＜!-- 该路径下存放spring.jar和其他第三方类库 --＞
 7 ＜FILESET dir=../../lib＞
 8 ＜INCLUDE name="*.jar" /＞
 9 ＜/FILESET＞
10 ＜!-- 同时还需要引用已经编译过的class文件--＞
11 ＜PATHELEMENT path="." /＞
12 ＜/PATH＞
13 ＜!-- 编译全部的java文件--＞
14 ＜TARGET description="Compile all source code" name="compile"＞
15 ＜!-- 指定编译后的class文件的存放位置 --＞
16 ＜JAVAC debug="true" destdir="."＞
17 deprecation="false" optimize="false" failonerror="true"＞
18 ＜!-- 指定需要编译的源文件的存放位置 --＞
19 ＜SRC path="." /＞
20 ＜!-- 指定编译这些java文件需要的类库位置--＞
21 ＜CLASSPATH refid="classpath" /＞
22 ＜/JAVAC＞
23 ＜/TARGET＞
24 ＜!-- 运行特定的主程序 --＞
25 ＜TARGET description="run the main class" name="run" depends="compile"＞
26 ＜!-- 指定运行的主程序:lee.BeanTest。--＞
27 ＜JAVA failonerror="true" fork="yes" classname="lee.BeanTest"＞
28 ＜!-- 指定运行这些java文件需要的类库位置--＞
29 ＜CLASSPATH refid="classpath" /＞
30 ＜/JAVA＞
31 ＜/TARGET＞
32 ＜/PROJECT＞

 1 //Axe的另一个实现类 SteelAxe
 2 public class SteelAxe implements Axe
 3 {
 4 //默认构造器
 5 public SteelAxe()
 6 {}
 7 //实现Axe接口的chop方法
 8 public String chop()
 9 {
10 return "钢斧砍柴真快";
11 }
12 }

1 ＜!-- 定义一个steelAxe bean--＞
2 ＜BEAN class="lee".SteelAxe id=steelAxe />

＜REF local="”stoneAxe”/"＞

＜REF local="”steelAxe”/"＞

 1 //Chinese实现Person接口
 2 public class Chinese implements Person
 3 {
 4 //面向Axe接口编程，而不是具体的实现类
 5 private Axe axe;
 6 //默认的构造器
 7 public Chinese()
 8 {}
 9 //构造注入所需的带参数的构造器
10 public Chinse(Axe axe)
11 {
12 this.axe = axe;
13 }
14 //实现Person接口的useAxe方法
15 public void useAxe()
16 {
17 System.out.println(axe.chop());
18 }
19 }

 1 ＜!-- 下面是标准的XML文件头 --＞
 2 ＜xml version="1.0" encoding="gb2312"?＞
 3 ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
 4 "http://www.springframework.org/dtd/spring-beans.dtd"＞
 5 ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
 6 ＜!-- Spring配置文件的根元素 --＞
 7 ＜BEANS＞
 8 ＜!—定义第一个bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
 9 ＜BEAN class="lee".Chinese id=chinese>
10 ＜/BEAN＞
11 ＜!-- 定义stoneAxe bean --＞
12 ＜BEAN class="lee".SteelAxe id=steelAxe />
13 ＜/BEANS＞