Spring学习--面向抽象编程（模拟Spring的简单实现）

Spring学习--面向抽象编程（模拟Spring的简单实现）

2013年6月7日

时间：19:05

地点：大学图书馆

事件：隔壁坐着个美女我竟然无动于衷

小巫学习SSH三个框架可谓是有一番苦水，到目前为止该忘了都忘了，不该忘的也忘了。我的学习方法是看教学视频，我看的是尚学堂的Struts2、Hibernate、Spring的视频，马老师讲课不错的啦，建议想学J2EE的童鞋都去听听。

我学习框架的目的也是为了窥探它们之间所用到的编程思想和架构理念，也并不是完全为了工作，况且小巫比较擅长的是移动平台，也就是Android平台下的开发。好了，废话不多说，下面做一下笔记，学习Spring的开端，模拟一下Spring的实现。

项目结构如下：

如何思考？面向抽象编程？

先来看看一个序列图

从以上看出了什么？初学的，能看得出是什么才怪，那不管它了。看看具体实现吧

首先要建立一个实体类：User,放在model包下

package com.wwj.model;

/**
 * 实体类
 * @author wwj
 * Spring
 */
public class User {
	private String username;
	private String password;
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

下面就是叫你如何面向抽象编程，简单来说如何面向接口编程，下面定义一个接口

package com.wwj.dao;

import com.wwj.model.User;

/**
 * 面向抽象编程
 * @author wwj
 * 优点：增加了灵活性
 */
public interface UserDAO {
	public void save(User user);
}

可以很清楚看到，这个接口声明了一个方法，save方法，里面有一个参数User对象，我们可以想到它是可以用来保存User对象到数据库里去的。

把具体实现交给实现类

package com.wwj.dao.impl;

import com.wwj.dao.UserDAO;
import com.wwj.model.User;

/**
 * 接口实现类
 * @author wwj
 * 
 */
public class UserDAOImpl implements UserDAO{

	@Override
	public void save(User user) {
		System.out.println("save user");
	}
	
}

这样做的好处是，如果你要更换数据库环境，你就能灵活定义不同的数据库代码了。

怎么调用以上的方法，为了使业务逻辑和数据库操作分离开，我们需要定义一个业务逻辑类

package com.wwj.service;

import com.wwj.dao.UserDAO;
import com.wwj.dao.impl.UserDAOImpl;
import com.wwj.model.User;

/**
 * 服务类，实现业务逻辑
 * @author wwj
 *
 */
public class UserService {
	private UserDAO userDAO;
	
	public UserDAO getUserDAO() {
		return userDAO;
	}

	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}

	public void add(User user) {
		this.userDAO.save(user);
	}
}

我们可以看到，上面有一个东西，东西？UserDAO啊，看到它的作用了没有，看到才怪。这里设计到一个IOC也叫做DI的概念，中文意思叫做依赖注入，也叫控制反转，这在Spring是一个很重要的概念，要把它弄懂，才能很好的理解Spring的原理。

下面真正模拟Spring的实现，有点像工厂模式，利用Spring，我们可以把不同对象装配在一起使用。

先看一下配置文件beans.xml

<beans>
	<bean id="u" class="com.wwj.dao.impl.UserDAOImpl" />
	<bean id="userService" class="com.wwj.service.UserService" >
		<property name="userDAO" bean="u"/>
	</bean>
</beans>

一个工厂方法

package com.wwj.spring;

public interface BeanFactory {
	public Object getBean(String name);
}

一个解析xml文件的类，并实现BeanFactory

package com.wwj.spring;

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;

/**
 * 2013/6/7
 * @author wwj
 * 模拟Spring
 */
public class ClassPathXmlApplicationContext implements BeanFactory{
	//定义一个容器，用来存放对象
	private Map<String,Object> beans = new HashMap<String, Object>();
	
	
	public ClassPathXmlApplicationContext() throws Exception{
		SAXBuilder sb = new SAXBuilder();
		Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
		Element root = doc.getRootElement();	//获取根结点
		List list = root.getChildren("bean");	//取名为bean的所有元素
		for(int i = 0; i < list.size(); i++) {
			Element element = (Element) list.get(i);
			String id = element.getAttributeValue("id");	//取id值
			String cla = element.getAttributeValue("class"); //取class值
			Object o = Class.forName(cla).newInstance();
			System.out.println(id);
		    System.out.println(cla);
			beans.put(id,o);
			
			for(Element propertyElement : (List<Element>)element.getChildren("property")){
				String name = propertyElement.getAttributeValue("name");	//UserDAO
				String bean = propertyElement.getAttributeValue("bean");	//u
				Object beanObject = beans.get(bean);//UserDAOImpl instance
				
				//拼凑方法名，实现setUserDAO方法
				String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
				System.out.println("method name = " + methodName);
				
				//利用反射机制获取方法对象
				Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
				m.invoke(o, beanObject);	//调用方法
			}
			
		}
		
	}


	@Override
	public Object getBean(String name) {
		return beans.get("id");
	}

}

来一个测试类

package com.wwj.service;

import org.junit.Test;

import com.wwj.model.User;
import com.wwj.spring.BeanFactory;
import com.wwj.spring.ClassPathXmlApplicationContext;

/**
 * 单元测试类
 * @author wwj
 *
 */
public class UserServiceTest {
	
	@Test
	public void testAdd() throws Exception{
		BeanFactory beanFactory = new ClassPathXmlApplicationContext();
		
		UserService service =(UserService)beanFactory.getBean("userService");
		User u = new User();
		service.add(u);
	}
	
}

从测试类我们可以看出点端倪了，首先定义一个BeanFactory对象，通过这个对象调换用其getBean的方法，获取业务逻辑类对象，后面就可以通过调用这个服务类的add方法把user对象添加到数据库中去。当然这里没有实现插入数据库，只是简单的实现了测试。其实整个过程很明了的，Spring的核心配置文件，将对象控制起来了，当要使用的时候就将对象注入到服务类当中去，服务类就可以利用DAO层的对象，进行数据库相关的操作。

以上只是我本人简单的一个理解，不知道是否有不对的地方。希望高手指正。