自定义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思路

自定义beans.xml文件实现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容器中

自定义beans.xml文件实现Spring框架

我们先来实现这个容器：

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中注入参数

秒客网

自定义beans.xml文件实现Spring框架

相关文章