<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>MoDoFo.println(" &#187; 模式</title>
	<atom:link href="http://zhangv.com/archives/tag/%e6%a8%a1%e5%bc%8f/feed" rel="self" type="application/rss+xml" />
	<link>http://zhangv.com</link>
	<description>Life for Idea - forever young</description>
	<lastBuildDate>Fri, 20 Jan 2012 01:32:57 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.4</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>模式背后的事情</title>
		<link>http://zhangv.com/archives/413</link>
		<comments>http://zhangv.com/archives/413#comments</comments>
		<pubDate>Fri, 18 Jul 2008 06:33:20 +0000</pubDate>
		<dc:creator>zhangv</dc:creator>
				<category><![CDATA[技术(Tech)]]></category>
		<category><![CDATA[软件工程]]></category>
		<category><![CDATA[模式]]></category>

		<guid isPermaLink="false">http://zhangv.com/?p=413</guid>
		<description><![CDATA[如果只单纯的从程序设计的角度去理解模式是不够的。
有时候看看那些封装，抽象和接口定义很容易有一个想法 - 何必呢。大师都说这是为了解耦，因为软件管理终归是依赖的管理，模式的背后同样是为了更好的管理依赖。
依赖管理的好坏从模块之间的划分就可以看出，最终的好处体现在开发,测试以及最后的整合的简化。从软件工程的角度可以很容易的体会出依赖管理的重要性。
说说抽象工厂模式，最常用的就是DAOFactory，可以有很多方法创建各种DAO对象。例如
DaoFactoryIF{
UserDaoIF getUserDao();
MemberDaoIF getMemberDao();
}
DaoFactoryImpl{
UserDaoIF userDao;
MemberDaoIF memberDao;
UserDaoIF getUserDao(){return userDao;}
MemberDaoIF getMemberDao(){return memberDao;}
//setters
}
DaoFactoryImpl通过类似spring这样的框架的帮助下注入所有的依赖，即真正的UserDaoIF,MemberDaoIF的实现。
这样的好处是什么呢？从DaoFactoryImpl这个类看，它并没有依赖任何具体实现。在发布时，所有的接口被发布为inf.jar，而各种实现 impl1.jar,impl2.jar...则是都只依赖于inf.jar。常见的错误做法是做成all.jar，也就是不管3721发布到一起，这么做也不能说绝对的不好，但如果要更大程度上的复用，避免局部的copy/paste，还是要把依赖划分的清楚一点，虽然这样做要求一些集成（integration）的能力。

	Tags: 软件工程, 模式
]]></description>
			<content:encoded><![CDATA[<p>如果只单纯的从程序设计的角度去理解模式是不够的。<br />
有时候看看那些封装，抽象和接口定义很容易有一个想法 - 何必呢。大师都说这是为了解耦，因为软件管理终归是依赖的管理，模式的背后同样是为了更好的管理依赖。</p>
<p>依赖管理的好坏从模块之间的划分就可以看出，最终的好处体现在开发,测试以及最后的整合的简化。从软件工程的角度可以很容易的体会出依赖管理的重要性。</p>
<p>说说抽象工厂模式，最常用的就是DAOFactory，可以有很多方法创建各种DAO对象。例如</p>
<p>DaoFactoryIF{<br />
UserDaoIF getUserDao();<br />
MemberDaoIF getMemberDao();<br />
}</p>
<p>DaoFactoryImpl{<br />
UserDaoIF userDao;<br />
MemberDaoIF memberDao;<br />
UserDaoIF getUserDao(){return userDao;}<br />
MemberDaoIF getMemberDao(){return memberDao;}<br />
//setters<br />
}</p>
<p>DaoFactoryImpl通过类似spring这样的框架的帮助下注入所有的依赖，即真正的UserDaoIF,MemberDaoIF的实现。<br />
这样的好处是什么呢？从DaoFactoryImpl这个类看，它并没有依赖任何具体实现。在发布时，所有的接口被发布为inf.jar，而各种实现 impl1.jar,impl2.jar...则是都只依赖于inf.jar。常见的错误做法是做成all.jar，也就是不管3721发布到一起，这么做也不能说绝对的不好，但如果要更大程度上的复用，避免局部的copy/paste，还是要把依赖划分的清楚一点，虽然这样做要求一些集成（integration）的能力。</p>

	Tags: <a href="http://zhangv.com/archives/tag/%e8%bd%af%e4%bb%b6%e5%b7%a5%e7%a8%8b" title="软件工程" rel="tag">软件工程</a>, <a href="http://zhangv.com/archives/tag/%e6%a8%a1%e5%bc%8f" title="模式" rel="tag">模式</a><br />
]]></content:encoded>
			<wfw:commentRss>http://zhangv.com/archives/413/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

