今天来学习Spring,重点有四
①IoC(Inverse of Control)控制反转：指一个对象获取它所依赖对象的引用，这个责任被反转，由容器来帮助我们得到这个引用。
②DI(Dependency Injection)依赖注入：对象之间的依赖关系由Bean对象自己来处理，这样可以使得类之间达到更高层次的松耦合。
③面向接口编程：遵循"开闭原则"，对于修改是关闭的，对于扩展是开放的。
④AOP(Aspect Oriant Programming)面向切面编程：弥补了面向对象编程的不足。
我们直接写个小例子，在例子中对此四点加以分析。
开发工具：eclipse for Jee,JDK1.6,Spring2.0。
首先引入jar包，spring.jar,commons-logging.jar,cglib-nodep-2.1.3.jar,aspectjrt.jar,aspectjweaver.jar。
新建工程，工程名Spring_base(任意)，src下新建包，com.myPackage,src下新建bean.xml作为spring的配置文件。
首先建立老师类，接口名ITeacher,其中放入一个老师的方法teacherMethod()，代码如下：
package com.myPackage; public interface ITeacher { public void teacherMethod(); }
实现类类名：Teacher,代码如下：
package com.myPackage; public class Teacher implements ITeacher { private String name; public void setName(String name){ this.name=name; } public String getName(){ return this.name; } private IBaseTemplate bt; public void setBt(IBaseTemplate bt){ this.bt=bt; } public IBaseTemplate getBt(){ return this.bt; } public void teacherMethod() { System.out.println("老师<"+name+">"+bt.baseMethod()+"留作业！"); } }
学生类：接口名IStudent,代码如下：
package com.myPackage; public interface IStudent { public void studentMethod(); }
学生实现类，类名Student,代码如下：
package com.myPackage; public class Student implements IStudent { public Student() { } public Student(String name) { this.name = name; } private String name; public void setName(String name) { this.name = name; } public String getName() { return this.name; } private IBaseTemplate bt; public void setBt(IBaseTemplate bt) { this.bt = bt; } public IBaseTemplate getBt() { return this.bt; } private Birthday birthday; public void setBirthday(Birthday birthday) { this.birthday = birthday; } public Birthday getBirthday() { return this.birthday; } public void studentMethod() { System.out.println(birthday+"出生的学生<" + name + ">" + bt.baseMethod() + "做作业！"); } }
学生类中引用了生日类，生日类类名：Birthday,代码如下：
package com.myPackage; public class Birthday { private int year; private int month; private int day; public Birthday(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public void setDay(int day) { this.day = day; } @Override public String toString() { return year + "-" + month + "-" + day; } }
老师和学生类中都引用到了BaseTemplate，这个类抽离了学生类和老师类中都要用到的共通属性，为了表示bean定义的继承关系而写，接口名：IBaseTemplate，代码如下：
package com.myPackage; public interface IBaseTemplate { public String baseMethod(); }
实现类类名：BaseTemplate,代码如下：
package com.myPackage; public class BaseTemplate implements IBaseTemplate { @Override public String baseMethod() { return "..疯狂的.."; } }
然后建立面向切面编程的类，类名AOP，代码如下：
package com.myPackage; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; @Aspect public class AOP { @Before("execution(* *.studentMethod(..))") public void dispHint(){ System.out.println("*************这是在执行学生方法前**************"); } }
最后是测试类Test,代码如下：
package com.myPackage; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test { public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"bean.xml"}); //老师 ITeacher tea = (ITeacher)ac.getBean("teacher"); tea.teacherMethod(); ITeacher tea22 = (ITeacher)ac.getBean("teacher"); tea22.teacherMethod(); Teacher tea1 = (Teacher)ac.getBean("teacher"); tea1.setName("hahaha"); tea1.teacherMethod(); Teacher tea2 = (Teacher)ac.getBean("teacher"); tea2.setName("heihei"); tea2.teacherMethod(); if(tea22==tea) System.out.println("true"); else System.out.println("false"); //学生 IStudent stu = (IStudent)ac.getBean("student"); stu.studentMethod(); //学生2 IStudent stu2 = (IStudent)ac.getBean("student2"); stu2.studentMethod(); } }
bean.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-2.0.xsd " > <!-- template类 --> <bean id="template" class="com.myPackage.BaseTemplate" /> <!-- 模板类 --> <bean id="base" abstract="true"> <property name="bt" ref="template"></property> </bean> <!-- 老师类 --> <bean id="teacher" class="com.myPackage.Teacher" parent="base" scope="singleton"> <property name="name" value="刘作业"></property> </bean> <!-- 学生类 --> <bean id="student" class="com.myPackage.Student" parent="base" scope="prototype"> <property name="name" value="左作业"></property> <property name="birthday" ref="bir"></property> </bean> <!-- 学生类2 --> <bean id="student2" class="com.myPackage.Student" parent="base" scope="prototype"> <constructor-arg index="0" value="左作业"></constructor-arg> </bean> <!-- 生日类 --> <bean id="bir" class="com.myPackage.Birthday"> <constructor-arg index="0" value="2000"></constructor-arg> <constructor-arg index="1" value="8"></constructor-arg> <constructor-arg index="2" value="8"></constructor-arg> </bean> <bean id="aop" class="com.myPackage.AOP"/> <!-- AspectJ自动代理找程序中的注解 --> <aop:aspectj-autoproxy /> </beans>
运行as a Java Application,得到结果为：
老师<刘作业>..疯狂的..留作业！ 老师<hahaha>..疯狂的..留作业！ 老师<heihei>..疯狂的..留作业！ true *************这是在执行学生方法前************** 2000-8-8出生的学生<左作业>..疯狂的..做作业！ *************这是在执行学生方法前************** null出生的学生<左作业>..疯狂的..做作业！
从结果我们分析，
第一句输出："老师<刘作业>..疯狂的..留作业！"，我们看bean.xml里的老师类下的内容，我们通过Spring容器，实现了重点中的IoC,也就是通过spring容器来创造的这个对象，使用了DI中的setting注入，而且是面向接口的编程(ITeacher),scope="singleton"这一句是为了让类的实例化为单例模式，而这正是业务层需要的，因此我们看到第四句的输出是true，也就是通过(ITeacher)的方式造出来的两个实例其实是同一个实例。
第五句第7句的输出：*************这是在执行学生方法前**************，正是运用了AOP，在学生方法的执行之前，就加上这一句的输出处理，这里AOP的方式有很多种，之前执行，之后执行，环绕执行等，这里我们只是做简单了解。
依赖注入的方法有setting,构造子注入，当然我们不仅可以注入基本类型的值，还可以注入具有依赖关系的对象，譬如这句的输出：2000-8-8出生的学生<左作业>..疯狂的..做作业！，中的生日我们就是这么做的，<property name="birthday" ref="bir"></property>这一句就是对对象的依赖注入，而bir又使用了构造子注入的方式。
