自定义beans.xml文件实现Spring框架
经过一天的补习，学习文件加载，java反射，JDom等知识，到了晚上终于能够搭出一个基于配置文件的简单spring框架实现！
首先我们先看看这个问题：
下面是两副图左边是项目结构图，右边是UML图：
正常情况下我们会按照上图一行一行的写代码：
其中UserService的代码是这样的
public class UserService {
//实现dao层的一个实例对象
private UserDAO userDAO=new UserDAOImpl();
//userDAO的setter和getter
public UserDAO getUserDao() {
return userDAO;
}
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
//添加用户
public void add(User user) {
if (userDAO == null)
System.out.println("erro");
else {
userDAO.add(user);
}
}
}
正像UML图所画的那样，UserService对User,UserDao,UserDAOImpl都有单向关联！
这里我们思考一下：
这仅仅是一个对象的操作，如果有TeacherService，狗Service，猫Service.........那么我们是不是每个都得实现service手动的调动Dao，DAOImpl，User等等，何其麻烦，
我们再注意看看：
1.Dao层是专门 与数据库交互的，里面有很多方法，而service是用来调用dao层的方法，他们之间唯一的联系就是在方法调用时，
Service层通过 private UserDAO userDAO=new UserDAOImpl();来实现与DAO层的耦合，我们知道程序设计讲究”高内聚低耦合“，
2.我们再看private UserDAO userDAO=new UserDAOImpl(); 这句是得到UserDao这个接口对象实例，并且这个实例是由new UserDAOImpl来决定，
我们知道，一个接口可以有很多实现类，这样写就是证明这个类中UserDAO的实例只能是UserDaoImpl的实例，不能使其他实现接口类的实例，那么这个类就具备重用的灵活性
既然这样，有没有一种方式能够降低这种耦合，提高灵活性呢，答案是spring
Spring思路
我们的service和UserDAOImpl没有任何的联系，而是通过一个配置文件来关联各个类之间的关系
1.我们看看beans.xml
<beans> <bean id="u" class="com.spring.dao.impl.UserDAOImpl" /> <bean id="userService" class="com.spring.service.UserService" > <property name="userDAO" bean="u"/> </bean> </beans>
配置文件中又两个bean,所谓的bean就是java中的类，每个bean都有 id和class两个属性，id就是代表这个bean唯一标识，class就是这个类的（包+类）名
我们看到第二个bean是有<property>子节点的，<property>表明这个bean中时存在以其他bean作为参数的，
并且这个参数bean在这个类中实例对象名字为（userDAO）,在所有beans中这个参数bean的id=u
2.加载beans.xml
我们先定义一个容器，通常是一个Map类型的容器，按照<bean>顺序依次初始化每个bean对应的类的对象，并把这个对象，和对象的id存放到Map容器中
我们先来实现这个容器：
package com.spring.buildframework;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class ClassPathXMLApplicationContext {
private static Map<String, Object> beans = new HashMap<String, Object>();
public ClassPathXMLApplicationContext() {
SAXBuilder sb = new SAXBuilder();
try {
Document doc = sb.build(this.getClass().getClassLoader()
.getResourceAsStream("beans.xml"));
//获取根节点
Element root=doc.getRootElement();
//将根节点的下的孩子全部放到List中
List allList= root.getChildren("bean");
for(int i=0;i<allList.size();i++)
{
Element sigElement=(Element)allList.get(i);
//获取每个<bean>节点的id和class属性的值
String id=sigElement.getAttribute("id").getValue();
String clazz=sigElement.getAttribute("class").getValue();
System.out.println(id+clazz);
//根据获取的类名利用反射得到实例
Class<?> demo=Class.forName(clazz);
Object obj=demo.newInstance();
//将id和类的实例放到beans中
beans.put(id, obj);
//判断该bean下是否存在property的子节点
List propertyChild=sigElement.getChildren("property");
for(int j=0;j<propertyChild.size();j++)
{
//获取此bean下name和bean的属性 ，其中bean指的是配置文件中另一个bean
Element propertyElement=(Element)propertyChild.get(j);
String name=propertyElement.getAttributeValue("name"); //userDAO
String bean=propertyElement.getAttributeValue("bean"); //u
//拼接该bean（useDAO）的setter方法 setUserDAO
String setterMethodName="set"+name.substring(0,1).toUpperCase()+name.substring(1);
//调用setter方法是需要注入com.spring.dao.impl.UserDAOImpl类的 对象
Object fieldObj=beans.get(bean);
//获取fieldObj对象的类的类型，
Class<?> type=fieldObj.getClass().getInterfaces()[0];
Method setterMethod=obj.getClass().getMethod(setterMethodName, type);
setterMethod.invoke(obj,fieldObj);
System.out.println(type);
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//提供给外界接口
public static Object getBean(String id)
{
return beans.get(id);
}
}
我们只需要初始化这个类，我们就能获得上图中的容器，而容器中就包含着我们需要的所有配置了的类的对象！
这时我们的UserService：
package com.spring.service;
import com.spring.dao.UserDAO;
import com.spring.dao.impl.UserDAOImpl;
import com.spring.model.User;
public class UserService {
private UserDAO userDAO;
public UserDAO getUserDao() {
return userDAO;
}
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
public void add(User user) {
if (userDAO == null)
System.out.println("erro");
else {
userDAO.add(user);
}
}
}
请注意和之前的不同，我们不再实例化userDAO而是通过 ClassPathXMLApplicationContext 类调用其set方法来实例化。
其他类：
public class UserDAOImpl implements UserDAO {
@Override
public void add(User user) {
// TODO Auto-generated method stub
System.out.println("user added successful");
}
}
package com.spring.dao;
import com.spring.model.User;
public interface UserDAO {
public void add(User user);
}
package com.spring.model;
public class User {
private String username;
private String age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
测试类：
public class ClassPathXMLApplicationContextTest {
@Test
public void test() {
try {
// Class<?> demo=Class.forName("com.spring.dao.impl.UserDAOImpl");
} catch (Exception e) {
// TODO: handle exception
}
//得到转载容器类的实例
ClassPathXMLApplicationContext test=new ClassPathXMLApplicationContext();
//从容器中获取userService对象
UserService service=(UserService)ClassPathXMLApplicationContext.getBean("userService");
User user=new User();
//执行方法
service.add(user);
fail("Not yet implemented");
}
}
需要说明的是：我们得从容器中拿到UserService对象才能进行调用
就这样：通过xml文件配置的简单spring框架就实现了
顺便讲讲IOC和DI的概念：
IOC（Inverse Of Control）：1>就在UseService中我们UserDaO的初始化不是掌握在我们自己手中，而是掌握在容器中
2>原来我们的程序写实现，现在依赖于抽象，也就是从实现具体的东西反转到接口（抽象上），给人的感觉是在控制接口而不是控制事项 3>控制的实现在与接口而不是具体实现
DI（Dependency Inject） :向bean中注入参数
