开发，从需求出发 · 之四春天在这里

最新推荐文章于 2023-07-31 00:57:00 发布

唐三角

最新推荐文章于 2023-07-31 00:57:00 发布

阅读量1.4k

点赞数

分类专栏： web技术 web开发那些事儿

本文链接：https://blog.csdn.net/deltatang/article/details/38073317

版权

web技术同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

web开发那些事儿

15 篇文章 0 订阅

订阅专栏

首先，我要大字标语表达立场：

你所使用的framework & non-core features，就跟女人穿在身上的衣服一样，越少越好！

扯淡完毕，说正经的。

让我们继续盯着花姐——啊，不——是 BeanFactory看。

	public static SearchService getSearchService() {
		if(MOCK) {
			return new SearchServiceMock();
		} else {
			LuceneDAO luceneDAO = getLuceneDAO();
			MysqlDAO mysqlDAO = getMysqlDAO();
			
			return new SearchServiceInRealBiz(luceneDAO, mysqlDAO);
		}
	}

有木有点儿标题所说的“春天在这里”的意思了？

纳尼？没看出来？

好吧，也许你习惯了spring的xml装配方式，所以觉得把两者关联起来看实在需要超常的想象力，那么，

我把BeanFactory改头换面，简单的实现一个基于文本字符串的装配，咋们再来看看效果：

package cn.com.sitefromscrath;

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BeanFactory {
	
	private static Map<String, String> appBean = new HashMap<String, String>();
	private static Map<String, String[]> appRef = new HashMap<String, String[]>();
	
	static {
		appBean.put("luceneDAO", "cn.com.sitefromscrath.dao.LuceneDAOMock");
		appBean.put("mysqlDAO", "cn.com.sitefromscrath.dao.MysqlDAOMock");
		appBean.put("searchService", "cn.com.sitefromscrath.service.SearchServiceInRealBiz");
		
		appRef.put("searchService", new String[]{"luceneDAO", "mysqlDAO"});
	}
		
	public static Object getBean(String id) {
		
		try {
		
			String className = appBean.get(id);		
			Class clazz = Class.forName(className);
			Constructor constructor;
			
			String[] ref = appRef.get(id);
			
			if(ref == null || ref.length == 0) {			
				constructor = clazz.getConstructor();
				return (Object)constructor.newInstance();
			}
			
			Class[] parameterTypes = new Class[ref.length];
			Object[] initargs = new Object[ref.length];
			
			for(int i = 0; i < ref.length; i++) {
				String r = ref[i];
				
				String rclassName = appBean.get(r);
				parameterTypes[i] = Class.forName(rclassName).getInterfaces()[0]; //这里我偷懒了：）
				initargs[i] = getBean(r);
			}
			
			constructor = clazz.getConstructor(parameterTypes);
			
			return (Object)constructor.newInstance(initargs);
			
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}		
	}
	
	public static void main(String ... arg) {
		
		LuceneDAO luceneDAO = (LuceneDAO) getBean("luceneDAO");
		int[] vals = luceneDAO.findDocIDs("test");
		for(int v : vals) {
			System.out.println(v);
		}
		
		String keywords = "test";
		SearchService searchService = (SearchService)getBean("searchService");	
		List results = searchService.search(keywords);
		for(int i = 0; i < results.size(); i++) {
			Result result = (Result) results.get(i);
			System.out.print("[" + result.title + "]");
			System.out.println(result.content);
		}
	}

}

运行结果输出：

1
2
3
4
[result 1]something..................
[result 2]something..................
[result 3]something..................
[result 4]something..................

结果正确！

再看看我们对类的装配：

	private static Map<String, String> appBean = new HashMap<String, String>();
	private static Map<String, String[]> appRef = new HashMap<String, String[]>();
	
	static {
		appBean.put("luceneDAO", "cn.com.sitefromscrath.dao.LuceneDAOMock");
		appBean.put("mysqlDAO", "cn.com.sitefromscrath.dao.MysqlDAOMock");
		appBean.put("searchService", "cn.com.sitefromscrath.service.SearchServiceInRealBiz");
		
		appRef.put("searchService", new String[]{"luceneDAO", "mysqlDAO"});
	}

请比较和spring.xml的区别：

<?xml version="1.0" encoding="UTF-8"?>
<beans >

	<bean id="luceneDAO" class="cn.com.sitefromscrath.dao.LuceneDAOMock" />
	
	<bean id="mysqlDAO" class="cn.com.sitefromscrath.dao.MysqlDAOMock" /> 
	
	<bean id="searchService" class="cn.com.sitefromscrath.service.SearchServiceInRealBiz">
		<constructor-arg index="1" ref="luceneDAO" />
		<constructor-arg index="2" ref="mysqlDAO" />
	</bean>  

</beans>

好吧，没什么根本上的区别，我们同样能够解析xml，得到我们自己实现的BeanFactory所需要的一切要素。

好了，经过我们将代码从零开始，反复重构，到一个比较“经典”的模式，我们找到了“春天”，这也是spring的core features。

也许是对spring看待的角度不同，我发现我对spring的依赖注入和控制反转的用途和不少人并不一致，下一章，我打算结合一些开发和测试技巧，论述一下我的看法。

不过，现在，是吐槽spring的时间：

我在我的博文《thinking in asp》appendix A - 吐槽JAVA 中曾经说到：

还有新版本的spring，怎么说呢，它把java的annotation机制玩儿到了“奇技淫巧”的程度。

由于那个系列主要是讲视频编转码技术，因此，对spring只是一带而过，现在总算找到机会了：）

Long long ago, in the old good times, spring还是依赖xml做装配的小姑娘，青春美丽，带着点儿书卷学生气；

但是现在看，这丫头已经涂脂抹粉，跻身上流社会，出入商务场合，虽然不讨厌，但是不让人觉得亲近了 -_-b

看传统的 spring.xml，就如同看电路板设计图，一个个元器件清清楚楚，什么型号，怎么走线，如何装配。虽然没有图形化，但是一目了然，基本上可以做到不用查看源码，就能把整个系统的逻辑关系梳理的八九不离十。

而自从有了annotation，比如autowire，xml不重要了，你无法再从一个基于spring的大型项目中迅速找到一份天然的“提纲”。

——spring开始不顾一切的媚俗。——也许俺是个受虐狂，不过“ruby way”和“傲娇”的python显然更对我的胃口——设计原则是不可以松口的：）