﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-欢迎来到邱恩的博客-文章分类-.net技术</title><link>http://www.blogjava.net/blogpig/category/16002.html</link><description>.net,java,AJAX技术，很高兴跟大家共享资源，共同提高!
我的联系：
  MSN：qndeny@hotmail.com
   QQ:190715237 &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;        
   承接各种软件和网站开发项目,有意则请跟我MSN，或QQ联系  .个人主页： http://edl.wy0597.com     
  </description><language>zh-cn</language><lastBuildDate>Wed, 16 May 2007 05:26:09 GMT</lastBuildDate><pubDate>Wed, 16 May 2007 05:26:09 GMT</pubDate><ttl>60</ttl><item><title>c#.net多线程编程</title><link>http://www.blogjava.net/blogpig/articles/117785.html</link><dc:creator>邱恩</dc:creator><author>邱恩</author><pubDate>Wed, 16 May 2007 03:11:00 GMT</pubDate><guid>http://www.blogjava.net/blogpig/articles/117785.html</guid><wfw:comment>http://www.blogjava.net/blogpig/comments/117785.html</wfw:comment><comments>http://www.blogjava.net/blogpig/articles/117785.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/blogpig/comments/commentRss/117785.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/blogpig/services/trackbacks/117785.html</trackback:ping><description><![CDATA[<div id=ctitle>
<h1>c#.net多线程编程教学(2):Thread类</h1>
</div>
<div id=cabs style="TEXT-ALIGN: center">添加时间:2007-4-11<!--　-->　</div>
<div id=content>
<p>　　这章将向大家介绍.NET中的线程API,怎么样用C#创建线程,启动和停止线程,设置优先级和状态.<br><br>　　在.NET中编写的程序将被自动的分配一个线程.让我们来看看用C#编程语言创建线程并且继续学习线程的知识。我们都知道.NET的运行时环境的主线程由Main ()方法来启动应用程序，而且.NET的编译语言有自动的垃圾收集功能,这个垃圾收集发生在另外一个线程里面,所有的这些都是后台发生的,让我们无法感觉到发生了什么事情.在这里默认的是只有一个线程来完成所有的程序任务，但是正如我们在第一篇文章讨论过的一样，有可能我们根据需要自己添加更多的线程让程序更好的协调工作。比如说我们的例子中，一个有用户输入的同时需要绘制图形或者完成大量的运算的程序，我们必须得增加一个线程，让用户的输入能够得到及时的响应，因为输入对时间和响应的要求是紧迫的，而另外一个线程负责图形绘制或者大量的运算。<br><br>　　.NET 基础类库的System.Threading命名空间提供了大量的类和接口支持多线程。这个命名空间有很多的类，我们将在这里着重讨论Thread这个类。<br><br>　　System.Threading.Thread类是创建并控制线程，设置其优先级并获取其状态最为常用的类。他有很多的方法，在这里我们将就比较常用和重要的方法做一下介绍：<br><br>　　Thread.Start（）：启动线程的执行；<br><br>　　Thread.Suspend（）：挂起线程，或者如果线程已挂起，则不起作用；<br><br>　　Thread.Resume（）：继续已挂起的线程；<br><br>　　Thread.Interrupt（）：中止处于 Wait或者Sleep或者Join 线程状态的线程；<br><br>　　Thread.Join（）：阻塞调用线程，直到某个线程终止时为止<br><br>　　Thread.Sleep（）：将当前线程阻塞指定的毫秒数；<br><br>　　Thread.Abort（）：以开始终止此线程的过程。如果线程已经在终止，则不能通过Thread.Start（）来启动线程。<br><br>　　通过调用Thread.Sleep，Thread.Suspend或者Thread.Join可以暂停/阻塞线程。调用Sleep()和Suspend()方法意味着线程将不再得到CPU时间。这两种暂停线程的方法是有区别的，Sleep()使得线程立即停止执行，但是在调用Suspend()方法之前，公共语言运行时必须到达一个安全点。一个线程不能对另外一个线程调用Sleep()方法，但是可以调用Suspend()方法使得另外一个线程暂停执行。对已经挂起的线程调用Thread.Resume（）方法会使其继续执行。不管使用多少次Suspend()方法来阻塞一个线程，只需一次调用Resume()方法就可以使得线程继续执行。已经终止的和还没有开始执行的线程都不能使用挂起。Thread.Sleep（int x）使线程阻塞x毫秒。只有当该线程是被其他的线程通过调用Thread.Interrupt（）或者Thread.Abort（）方法，才能被唤醒。</p>
<p>　　如果对处于阻塞状态的线程调用Thread.Interrupt（）方法将使线程状态改变，但是会抛出ThreadInterupptedException异常，你可以捕获这个异常并且做出处理，也可以忽略这个异常而让运行时终止线程。在一定的等待时间之内，Thread.Interrupt（）和Thread.Abort（）都可以立即唤醒一个线程。<br><br>　　下面我们将说明如何从一个线程中止另外一个线程。在这种情况下，我们可以通过使用Thread.Abort（）方法来永久销毁一个线程，而且将抛出ThreadAbortException异常。使终结的线程可以捕获到异常但是很难控制恢复，仅有的办法是调用Thread.ResetAbort（）来取消刚才的调用，而且只有当这个异常是由于被调用线程引起的异常。因此，A线程可以正确的使用Thread.Abort（）方法作用于B线程，但是B线程却不能调用Thread.ResetAbort（）来取消Thread.Abort（）操作。</p>
<p>　　Thread.Abort（）方法使得系统悄悄的销毁了线程而且不通知用户。一旦实施Thread.Abort（）操作，该线程不能被重新启动。调用了这个方法并不是意味着线程立即销毁，因此为了确定线程是否被销毁，我们可以调用Thread.Join（）来确定其销毁，Thread.Join（）是一个阻塞调用，直到线程的确是终止了才返回。但是有可能一个线程调用Thread.Interrupt（）方法来中止另外一个线程，而这个线程正在等待Thread.Join（）调用的返回。</p>
<p>　　尽可能的不要用Suspend()方法来挂起阻塞线程，因为这样很容易造成死锁。假设你挂起了一个线程，而这个线程的资源是其他线程所需要的，会发生什么后果。因此，我们尽可能的给重要性不同的线程以不同的优先级，用Thread.Priority（）方法来代替使用Thread.Suspend（）方法。<br><br>　　Thread类有很多的属性，这些重要的属性是我们多线程编程必须得掌握的。<br><br>　　Thread.IsAlive属性：获取一个值，该值指示当前线程的执行状态。如果此线程已启动并且尚未正常终止或中止，则为 true；否则为 false。<br><br>　　Thread.Name 属性：获取或设置线程的名称。<br><br>　　Thread.Priority 属性：获取或设置一个值，该值指示线程的调度优先级。<br>　　Thread.ThreadState 属性：获取一个值，该值包含当前线程的状态。<br>　　在下面的例子中，我们将看看怎么设置这些属性，在随后的例子中我们将详细的讨论这些属性。<br>　　创建一个线程，首先得实例化一个Thread类，在类得构造函数中调用ThreadStart委派。这个委派包含了线程从哪里开始执行。当线程启动后，Start()方法启动一个新的线程。下面是例子程序。<br></p>
<p>&#160;</p>
<p class=code>using System;<br>using System.Threading ;<br>namespace LearnThreads<br>{ <br>class Thread_App<br>{<br>public static void First_Thread()<br>{<br>　Console.WriteLine("First thread created");<br>　Thread current_thread = Thread.CurrentThread;<br>　string thread_details = "Thread Name: " + current_thread.Name + "\r\nThread State: " + current_thread.ThreadState.ToString()+"\r\n Thread Priority level:"+current_thread.Priority.ToString();<br>　Console.WriteLine("The details of the thread are :"+ thread_details);<br>　Console.WriteLine ("first thread terminated");<br>}<br><br>public static void Main()<br>{<br>　ThreadStart thr_start_func = new ThreadStart (First_Thread);<br>　Console.WriteLine ("Creating the first thread ");<br>　Thread fThread = new Thread (thr_start_func);<br>　fThread.Name = "first_thread";<br>　fThread.Start (); //starting the thread<br>}<br>}<br>}</p>
<p><br>　　在这个例子中，创建了一个fThread的线程对象，这个线程负责执行First_Thread()方法里面的任务。当Thread的Start() 方法被调用时包含First_Thread()的地址ThreadStart的代理将被执行。<br><br><strong>Thread状态</strong><br>　　System.Threading.Thread.ThreadState属性定义了执行时线程的状态。线程从创建到线程终止，它一定处于其中某一个状态。当线程被创建时，它处在Unstarted状态，Thread类的Start() 方法将使线程状态变为Running状态，线程将一直处于这样的状态，除非我们调用了相应的方法使其挂起、阻塞、销毁或者自然终止。如果线程被挂起，它将处于Suspended状态，除非我们调用resume（）方法使其重新执行，这时候线程将重新变为Running状态。一旦线程被销毁或者终止，线程处于Stopped状态。处于这个状态的线程将不复存在，正如线程开始启动，线程将不可能回到Unstarted状态。线程还有一个Background状态，它表明线程运行在前台还是后台。在一个确定的时间，线程可能处于多个状态。据例子来说，一个线程被调用了Sleep而处于阻塞，而接着另外一个线程调用Abort方法于这个阻塞的线程，这时候线程将同时处于WaitSleepJoin和AbortRequested状态。一旦线程响应转为Sle阻塞或者中止，当销毁时会抛出ThreadAbortException异常。<br><br><strong>线程优先级</strong><br>　　System.Threading.Thread.Priority枚举了线程的优先级别，从而决定了线程能够得到多少CPU时间。高优先级的线程通常会比一般优先级的线程得到更多的CPU时间，如果不止一个高优先级的线程，操作系统将在这些线程之间循环分配CPU时间。低优先级的线程得到的CPU时间相对较少，当这里没有高优先级的线程，操作系统将挑选下一个低优先级 的线程执行。一旦低优先级的线程在执行时遇到了高优先级的线程，它将让出CPU给高优先级的线程。新创建的线程优先级为一般优先级，我们可以设置线程的优先级别的值，如下面所示：<br></p>
<p class=code>　　Highest <br>　　AboveNormal <br>　　Normal <br>　　BelowNormal <br>　　Lowest</p>
<p><br></p>
</div>
<img src ="http://www.blogjava.net/blogpig/aggbug/117785.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/blogpig/" target="_blank">邱恩</a> 2007-05-16 11:11 <a href="http://www.blogjava.net/blogpig/articles/117785.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>面向服务的体系结构概述(转自IBM developerworks) </title><link>http://www.blogjava.net/blogpig/articles/74769.html</link><dc:creator>邱恩</dc:creator><author>邱恩</author><pubDate>Thu, 12 Oct 2006 05:05:00 GMT</pubDate><guid>http://www.blogjava.net/blogpig/articles/74769.html</guid><wfw:comment>http://www.blogjava.net/blogpig/comments/74769.html</wfw:comment><comments>http://www.blogjava.net/blogpig/articles/74769.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/blogpig/comments/commentRss/74769.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/blogpig/services/trackbacks/74769.html</trackback:ping><description><![CDATA[
		<div class="postbody">
				<p>
						<a href="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/#author">
								<font color="#996699">
										<br />
										<br />
										<font size="2">来自Min Luo, Mark Endrei, Philippe Comte,Pal Krogdahl, Jenny Ang, Tony Newling</font>
								</font>
						</a>
						<font size="2">, International Technical Support Organization, Raleigh Center<br /></font>
				</p>
				<p>
						<font size="2">2004 年 6 月 01 日</font>
						<br />
						<br />
						<font size="2">在这一节中，我们简要地描述了面向服务的体系结构的发展。然后，我们探究了面向组件的开发与面向服务的体系结构之间的关系，并且说明了如何将组件作为实现服务的基础设施。</font>
				</p>
				<!--START RESERVED FOR FUTURE USE INCLUDE FILES-->
				<!-- include java script once we verify teams wants to use this and it will work on dbcs and cyrillic characters -->
				<!--END RESERVED FOR FUTURE USE INCLUDE FILES-->
				<p>
						<a name="1">
								<span class="atitle">
										<font face="Arial" size="2">第一部分：新方法的商业驱动力</font>
								</span>
						</a>
				</p>
				<p>
						<font size="2">虽然 IT 经理一直面临着削减成本和最大限度地利用现有技术的难题，但是与此同时，他们还必须不断地努力，以期更好地服务客户，更快地响应企业战略重点，从而赢得更大的竞争力。</font>
				</p>
				<p>
						<font size="2">在所有这些压力之下，有两个基本的主题：异构和改变。现在，大多数企业都有各种各样的系统、应用程序以及不同时期和技术的体系结构。集成来自多个厂商跨不同平台的产品简直就像一场噩梦。但是我们也不能单单使用一家厂商的产品，因为改变应用程序套件和支持基础设施是如此之难。</font>
				</p>
				<p>
						<font size="2">在当今 IT 经理面临的问题之中，改变是第二个主题。全球化和电子商务加快了改变的步伐。全球化带来了激烈的竞争，产品周期缩短了，每个公司都想赢得超过竞争对手的优势。在竞争产品和可以从 Internet 上获得的大量产品信息的推动下，客户要求更快速地进行改变。因而，在改进产品和服务方面展开的竞争进一步加剧了。</font>
				</p>
				<p>
						<font size="2">为了满足客户提出的越来越多的新要求，技术方面的改进也在不断地加快。企业必须快速地适应这种改变，否则就难以生存，更别提在这个动荡不安竞争激烈的环境中取得成功了，而 IT 基础设施必须支持企业提高适应能力。</font>
				</p>
				<p>
						<font size="2">因此，企业组织正在从上世纪八十年代或更早的时期的相互隔离的垂直业务部门，到上世纪八十年代和九十年代关注业务流程的水平结构，向新的生态系统业务范例发展。重点是扩展供应链，支持客户和合作伙伴访问业务服务。第 19 页的图 2-1 展示了企业的这种发展。</font>
				</p>
				<p>
						<br />
						<a name="N10053">
								<b>
										<font size="2">图 2-1 企业的发展</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-1 企业的发展" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-1.jpg" />
								<br />
						</font>
				</p>
				<p>
						<font size="2">我如何使我的 IT 环境更灵活且更快地响应不断改变的业务需求呢？ 我们如何使这些异构系统和应用程序尽可能无缝地进行通信呢？我们如何达到企业目标而不使企业走向破产的深渊呢？</font>
				</p>
				<p>
						<font size="2">IT 响应者/支持者是随着企业的这种发展而并行发展的，如图 2-2 所示。现在，许多 IT 经理和专业人员都同样相信，我们真的快找到了一种满意的答案——面向服务的体系结构。</font>
				</p>
				<p>
						<font size="2">图 2-2 体系结构的发展</font>
				</p>
				<p>
						<br />
						<a name="N1006B">
								<b>
										<font size="2">图 2-2 体系结构的发展</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="Figure 2-2 The evolution of architecture" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-2.jpg" />
								<br />
						</font>
				</p>
				<p>
						<font size="2">为了减少异构性、互操作性和不断改变的要求的问题，这样的体系结构应该提供平台来构建具有下列特征的应用程序服务：</font>
				</p>
				<ul>
						<li>
								<font size="2">松散耦合 </font>
						</li>
						<li>
								<font size="2">位置透明 </font>
						</li>
						<li>
								<font size="2">协议独立 </font>
						</li>
				</ul>
				<p>
						<font size="2">基于这样的面向服务的体系结构，服务使用者甚至不必关心与之通信的特定服务，因为底层基础设施或服务“总线”将代表使用者做出适当的选择。基础设施对请求者隐藏了尽可能多的技术。特别地，来自不同实现技术（如 J2EE 或 .NET）的技术规范不应该影响 SOA 用户。如果已经存在一个服务实现，我们就还应该重新考虑用一个“更好”的服务实现来代替，新的服务实现必须具有更好的服务质量。</font>
				</p>
				<p>
						<br />
				</p>
				<table cellspacing="0" cellpadding="0" width="100%" border="0">
						<tbody>
								<tr>
										<td>
												<font size="2">
														<img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" />
														<br />
														<img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" />
												</font>
										</td>
								</tr>
						</tbody>
				</table>
				<table class="no-print" cellspacing="0" cellpadding="0" align="right">
						<tbody>
								<tr align="right">
										<td>
												<font size="2">
														<img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" />
														<br />
												</font>
												<table cellspacing="0" cellpadding="0" border="0">
														<tbody>
																<tr>
																		<td valign="center">
																				<font size="2"> <br /></font>
																		</td>
																		<td valign="top" align="right">
																				<a class="fbox" href="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/#main">
																						<b>
																						</b>
																				</a>
																		</td>
																</tr>
														</tbody>
												</table>
										</td>
								</tr>
						</tbody>
				</table>
				<br />
				<br />
				<p>
						<a name="2">
								<span class="atitle">
										<font face="Arial" size="2">第二部分：作为解决方案的面向服务体系结构</font>
								</span>
						</a>
				</p>
				<p>
						<font size="2">自从“软件危机”促进软件工程的开创以来，IT 界一直在努力寻求解决上述问题的方案。在过去几年里，下面简要概述的核心技术进展使我们走到了今天。我们将简要讨论这些核心技术，而我们重点关注的将是这些技术如何帮助解决 IT 问题。</font>
				</p>
				<p>
						<a name="N10093">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">面向对象的分析和设计</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">在“Applying UML and Patterns - An Introduction to Object-Oriented Analysis and Design”中，Larman 将面向对象的分析和设计的本质描述为“从对象（物体、概念或实体）的角度考虑问题域和逻辑解决方案”。在“Object-Oriented SoftwareEngineering: A Use Case Driven Approach”中，Jacobson 等将这些对象定义为“特点在于具有许多操作和状态（记忆这些操作的影响）的物体”。</font>
				</p>
				<p>
						<font size="2">在面向对象的分析中，这样的对象是用问题域来标识和描述的，而在面向对象的设计中，它们转变成逻辑软件对象，这些对象最终将用面向对象的编程语言进行实现。</font>
				</p>
				<p>
						<font size="2">通过面向对象的分析和设计，可以封装对象（或对象组）的某些方面，以简化复杂业务场景的分析。为了降低复杂性，也可以抽象对象的某些特征，这样就可以只捕获重要或本质的方面。</font>
				</p>
				<p>
						<font size="2">基于组件的设计并不是一种新技术。它是从对象范例中自然发展而来的。在面向对象的分析和设计的早期，细粒度的对象被标榜为提供“重用”的机制，但是这样的对象的粒度级别太低了，没有适当的标准可以用来使重用广泛应用于实践之中。在应用程序开发和系统集成中，粗粒度组件越来越成为重用的目标。这些粗粒度对象通过内聚一些更细粒度的对象来提供定义良好的功能。通过这种方式，还可以将打包的解决方案套件封装成这样的“组件”。</font>
				</p>
				<p>
						<font size="2">一旦组织在更高层次上实现了基于完全独立的功能组件的完备体系结构，就可以将支持企业的应用程序划分成一组粒度越来越大的组件。可以将组件看作是打包、管理和公开服务的机制。它们可以共同使用一组技术：实现企业级用况的大粒度企业组件可以通过更新的面向对象的软件开发与遗留系统相结合来实现</font>
				</p>
				<p>
						<a name="N100A8">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">面向服务的设计</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">在“Component-Based Development for Enterprise Systems”中，Allen 涉及了服务的概念，“它是将组件描述成提供相关服务的物理黑盒封装的可执行代码单元。它的服务只能通过一致的已发布接口（它包括交互标准）进行访问。组件必须能够连接到其他组件（通过通信接口）以构成一个更大的组”。服务通常实现为粗粒度的可发现软件实体，它作为单个实例存在，并且通过松散耦合的基于消息通信模型来与应用程序和其他服务交互。第 22 页的图 2-3 展示了重要的面向服务术语：</font>
				</p>
				<ul>
						<li>
								<font size="2">服务：逻辑实体，由一个或多个已发布接口定义的契约。 </font>
						</li>
						<li>
								<font size="2">服务提供者：实现服务规范软件实体。 </font>
						</li>
						<li>
								<font size="2">服务使用者（或请求者）：调用服务提供者的软件实体。传统上，它称为“客户端”。服务使用者可以是终端用户应用程序或另一个服务。 </font>
						</li>
						<li>
								<font size="2">服务定位器：一种特殊类型的服务提供者，它作为一个注册中心，允许查找服务提供者接口和服务位置。 </font>
						</li>
						<li>
								<font size="2">服务代理：一种特殊类型的服务提供者，它可以将服务请求传送到一个或多个其他的服务提供者。 </font>
						</li>
				</ul>
				<p>
						<br />
						<a name="N100C5">
								<b>
										<font size="2">图 2-3 面向服务的术语</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-3 面向服务的术语" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-3.jpg" />
								<br />
						</font>
				</p>
				<p>
						<a name="N100D2">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">基于接口的设计</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">在组件和服务开发中，都需要进行接口设计，这样软件实体就可以实现和公开其定义的关键部分。因此，在基于组件和面向服务的系统中，“接口”的概念对于成功的设计非常关键。下面是一些与接口有关的重要定义：</font>
				</p>
				<ul>
						<li>
								<font size="2">接口：定义一组公共方法签名，它按照逻辑分组但是没有提供实现。接口定义服务的请求者和提供者之间的契约。接口的任何实现都必须提供所有的方法。 </font>
						</li>
						<li>
								<font size="2">已发布接口：一种可唯一识别和可访问的接口，客户端可以通过注册中心来发现它。 </font>
						</li>
						<li>
								<font size="2">公共接口：一种可访问的接口，可供客户端使用，但是它没有发布，因而需要关于客户端部分的静态知识。 </font>
						</li>
						<li>
								<font size="2">双接口：通常是成对开发的接口，这样，一个接口就依赖于另一个接口；例如，客户端必须实现一个接口来调用请求者，因为该客户端接口提供了某些回调机制。 </font>
						</li>
				</ul>
				<p>
						<font size="2">第 23 页的图 2-4 定义了客户关系管理 (CRM) 服务的 UML 定义，它表示为一个 UML 组件，实现接口 AccountManagement、ContactManagement 和 SystemsManagement。在这些接口中只有头两个接口是已发布接口，不过，后者是公共接口。注意，SystemsManagement 接口和 ManagementService 接口构成了双接口。CRMservice 可以实现许多这样的接口，但是它以多种方式行为的能力取决于客户端在行为的实现方面是否允许有大的灵活性。甚至有可能给特定类型的客户端提供不同或附加的服务。在一些运行时环境中，这样的功能也用于在单个组件或服务上支持相同接口的不同版本。</font>
				</p>
				<p>
						<br />
						<a name="N100EF">
								<b>
										<font size="2">图 2-4 已实现的服务</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-4 已实现的服务" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-4.jpg" />
								<br />
						</font>
				</p>
				<p>
						<a name="N100FC">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">分层应用程序体系结构</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">如前所述，面向对象的技术和语言是实现组件的极好方式。虽然组件是实现服务的最好方法，但是您必须理解的一点是，好的基于组件的应用程序未必就构成好的面向服务的应用程序。一旦理解了服务在应用程序体系结构中所起的作用，组件开发人员就很有可能会利用现有的组件。进行这种转变的关键是认识到面向服务的方法意味着附加的应用程序体系结构层。第 24 页中的图 2-5 演示了如何将技术层应用于程序体系结构以提供粒度更粗的实现（它更靠近应用程序的使用者）。为称呼系统的这一部分而创造的术语是“应用程序边界”，它反映了服务是公开系统的外部视图的极好方法的事实（通过内部重用并结合使用传统组件设计）。</font>
				</p>
				<p>
						<br />
						<a name="N10107">
								<b>
										<font size="2">图 2-5 应用程序实现层：服务、组件、对象</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-5 应用程序实现层：服务、组件、对象" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-5.jpg" />
								<br />
								<br />
						</font>
				</p>
				<table cellspacing="0" cellpadding="0" width="100%" border="0">
						<tbody>
								<tr>
										<td>
												<font size="2">
														<img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" />
														<br />
														<img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" />
												</font>
										</td>
								</tr>
						</tbody>
				</table>
				<table class="no-print" cellspacing="0" cellpadding="0" align="right">
						<tbody>
								<tr align="right">
										<td>
												<font size="2">
														<img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" />
														<br />
												</font>
												<table cellspacing="0" cellpadding="0" border="0">
														<tbody>
																<tr>
																		<td valign="center">
																				<font size="2"> </font>
																		</td>
																		<td valign="top" align="right">
																				<a class="fbox" href="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/#main">
																						<b>
																						</b>
																				</a>
																		</td>
																</tr>
														</tbody>
												</table>
										</td>
								</tr>
						</tbody>
				</table>
				<br />
				<br />
				<p>
						<a name="3">
								<span class="atitle">
										<font face="Arial" size="2">第三部分：近距离审视面向服务的体系结构</font>
								</span>
						</a>
				</p>
				<p>
						<font size="2">面向服务的体系结构提供了一种方法，通过这种方法，可以构建分布式系统来将应用程序功能作为服务提供给终端用户应用程序或其他服务。其组成元素可以分成功能元素和服务质量元素。第 25 页的图 2-6 展示了体系结构堆栈以及在一个面向服务的体系结构可能观察到的元素。</font>
				</p>
				<p>
						<font size="2">
								<b>注意：</b>面向服务的体系结构堆栈可能是一个容易引起争议的问题，因为各方面的支持者已经提出了几种不同的堆栈。我们的堆栈不是作为服务堆栈提出的。我们之所以在此提出它，是因为我们想要搭建一个有用的框架，在本书的剩余章节中，我们将通过这个框架来组织对 SOA 的讨论。 </font>
				</p>
				<p>
						<br />
						<a name="N10125">
								<b>
										<font size="2">图 2-6 面向服务的体系结构的元素</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-6 面向服务的体系结构的元素" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-6.jpg" />
								<br />
						</font>
				</p>
				<p>
						<font size="2">体系结构堆栈分成两半，左边的一半集中于体系结构的功能性方面，而右边的一半集中于体系结构的服务质量方面。这些元素详细描述如下：</font>
				</p>
				<p>
						<font size="2">功能性方面包括：</font>
				</p>
				<ul>
						<li>
								<font size="2">传输是一种机制，用于将来自服务使用者的服务请求传送给服务提供者，并且将来自服务提供者的响应传送给服务使用者。 </font>
						</li>
						<li>
								<font size="2">服务通信协议是一种经过协商的机制，通过这种机制，服务提供者和服务使用者可以就将要请求的内容和将要返回的内容进行沟通。 </font>
						</li>
						<li>
								<font size="2">服务描述是一种经过协商的模式，用于描述服务是什么、应该如何调用服务以及成功地调用服务需要什么数据。 </font>
						</li>
						<li>
								<font size="2">服务描述实际可供使用的服务。 </font>
						</li>
						<li>
								<font size="2">业务流程是一个服务的集合，可以按照特定的顺序并使用一组特定的规则进行调用，以满足业务要求。注意，可以将业务流程本身看作是服务，这样就产生了业务流程可以由不同粒度的服务组成的观念。 </font>
						</li>
						<li>
								<font size="2">服务注册中心是一个服务和数据描述的存储库，服务提供者可以通过服务注册中心发布它们的服务，而服务使用者可以通过服务注册中心发现或查找可用的服务。服务注册中心可以给需要集中式存储库的服务提供其他的功能。 </font>
						</li>
				</ul>
				<p>
						<font size="2">服务质量方面包括：</font>
				</p>
				<ul>
						<li>
								<font size="2">策略是一组条件和规则，在这些条件和规则之下，服务提供者可以使服务可用于使用者。策略既有功能性方面，也有与服务质量有关的方面；因此，我们在功能和服务质量两个区中都有策略功能。 </font>
						</li>
						<li>
								<font size="2">安全性是规则集，可以应用于调用服务的服务使用者的身份验证、授权和访问控制。 </font>
						</li>
						<li>
								<font size="2">传输是属性集，可以应用于一组服务，以提供一致的结果。例如，如果要使用一组服务来完成一项业务功能，则所有的服务必须都完成，或者没有一个完成。 </font>
						</li>
						<li>
								<font size="2">管理是属性集，可以应用于管理提供的服务或使用的服务。 </font>
						</li>
				</ul>
				<p>
						<a name="N1015F">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">SOA 协作</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">图 2-7 展示了面向服务的体系结构中的协作。这些协作遵循“查找、绑定和调用”范例，其中，服务使用者执行动态服务定位，方法是查询服务注册中心来查找与其标准匹配的服务。如果服务存在，注册中心就给使用者提供接口契约和服务的端点地址。下图展示了面向服务的体系结构中协作支持“查找、绑定和调用”范例的实体。</font>
				</p>
				<p>
						<br />
						<a name="N1016A">
								<b>
										<font size="2">图 2-7 面向服务的体系结构中的协作</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="Figure 2-7 Collaborations in a service-oriented architecture" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-7.jpg" />
								<br />
						</font>
				</p>
				<p>
						<font size="2">面向服务的体系结构中的角色包括：</font>
				</p>
				<ul>
						<li>
								<font size="2">服务使用者：服务使用者是一个应用程序、一个软件模块或需要一个服务的另一个服务。它发起对注册中心中的服务的查询，通过传输绑定服务，并且执行服务功能。服务使用者根据接口契约来执行服务。 </font>
						</li>
						<li>
								<font size="2">服务提供者：服务提供者是一个可通过网络寻址的实体，它接受和执行来自使用者的请求。它将自己的服务和接口契约发布到服务注册中心，以便服务使用者可以发现和访问该服务。 </font>
						</li>
						<li>
								<font size="2">服务注册中心：服务注册中心是服务发现的支持者。它包含一个可用服务的存储库，并允许感兴趣的服务使用者查找服务提供者接口。 </font>
						</li>
				</ul>
				<p>
						<font size="2">面向服务的体系结构中的每个实体都扮演着服务提供者、使用者和注册中心这三种角色中的某一种（或多种）。面向服务的体系结构中的操作包括：</font>
				</p>
				<ul>
						<li>
								<font size="2">发布：为了使服务可访问，需要发布服务描述以使服务使用者可以发现和调用它。 </font>
						</li>
						<li>
								<font size="2">发现：服务请求者定位服务，方法是查询服务注册中心来找到满足其标准的服务。 </font>
						</li>
						<li>
								<font size="2">绑定和调用：在检索完服务描述之后，服务使用者继续根据服务描述中的信息来调用服务。 </font>
						</li>
				</ul>
				<p>
						<font size="2">面向服务的体系结构中的构件包括：</font>
				</p>
				<ul>
						<li>
								<font size="2">服务：可以通过已发布接口使用服务，并且允许服务使用者调用服务。 </font>
						</li>
						<li>
								<font size="2">服务描述：服务描述指定服务使用者与服务提供者交互的方式。它指定来自服务的请求和响应的格式。服务描述可以指定一组前提条件、后置条件和/或服务质量 (QoS) 级别。 </font>
						</li>
				</ul>
				<p>
						<font size="2">除了动态服务发现和服务接口契约的定义之外，面向服务的体系结构还具有以下特征：</font>
				</p>
				<ul>
						<li>
								<font size="2">服务是自包含和模块化的。 </font>
						</li>
						<li>
								<font size="2">服务支持互操作性。 </font>
						</li>
						<li>
								<font size="2">服务是松散耦合的。 </font>
						</li>
						<li>
								<font size="2">服务是位置透明的。 </font>
						</li>
						<li>
								<font size="2">服务是由组件组成的组合模块。 </font>
						</li>
				</ul>
				<p>
						<font size="2">这些特征也是满足电子商务按需操作环境的要求的主要特征，如第 301 页“e-business on demand and Service-oriented architecture”所定义的。</font>
				</p>
				<p>
						<font size="2">最后，我们需要说明的是，面向服务的体系结构并不是一个新的概念。如图 2-8 所示，面向服务的体系结构所涉及的技术至少包括 CORBA、DCOM 和 J2EE。面向服务的体系结构的早期采用者还曾成功地基于消息传递系统（如 IBM WebSphere MQ）创建过他们自己的面向服务企业体系结构。最近，SOA 的活动舞台已经扩展到包括 World Wide Web (WWW) 和 Web 服务。</font>
				</p>
				<p>
						<br />
						<a name="N101BE">
								<b>
										<font size="2">图 2-8 面向服务的体系结构的不同实现</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-8 面向服务的体系结构的不同实现" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-8.jpg" />
								<br />
						</font>
				</p>
				<p>
						<a name="N101CB">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">SOA 范围中的服务</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">在面向服务的体系结构中，映射到业务功能的服务是在业务流程分析的过程中确定的。服务可以是细粒度的，也可以是粗粒度的，这取决于业务流程。每个服务都有定义良好的接口，通过该接口就可以发现、发布和调用服务。 企业可以选择将自己的服务向外发布到业务合作伙伴，也可以选择在组织内部发布服务。服务还可以由其他服务组合而成。</font>
				</p>
				<p>
						<a name="N101D4">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">服务与组件</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">服务是粗粒度的处理单元，它使用和产生由值传送的对象集。它与编程语言术语中的对象不同。相反，它可能更接近于业务事务（如 CICS 或 IMS 事务）的概念而不是远程 CORBA 对象的概念。</font>
				</p>
				<p>
						<font size="2">服务是由一些组件组成的，这些组件一起工作，共同提供服务所请求的业务功能。因此，相比之下，组件比服务的粒度更细。另外，虽然服务映射到业务功能，但是组件通常映射到业务实体和操作它们的业务规则。作为一个示例，让我们看一看 WS-I 供应链管理（WS-I Supply Chain Management）样本的定购单（PurchaseOrder）组件模型，如图 2-9 所示。</font>
				</p>
				<p>
						<br />
						<a name="N101E2">
								<b>
										<font size="2">图 2-9 定购单组件模型</font>
								</b>
						</a>
						<br />
						<font size="2">
								<img alt="图 2-9 定购单组件模型" src="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/figure2-9.jpg" />
								<br />
						</font>
				</p>
				<p>
						<font size="2">在基于组件的设计中，可以创建组件来严格匹配业务实体（如顾客（Customer）、定购单（Purchase Order）、定购项（Order Item）），并且封装匹配这些实体所期望的行为的行为。</font>
				</p>
				<p>
						<font size="2">例如，定购单（Purchase Order）组件提供获取关于已定购的产品列表和定购的总额的信息的功能；定购项（Order Item）组件提供获取关于已定购的产品的数量和价格的信息的功能。每个组件的实现都封装在接口的后面。因此，定购单（Purchase Order）组件的用户不知道定购单（Purchase Order）表的模式、计算税金的算法、以及定单总额中的回扣和/或折扣。</font>
				</p>
				<p>
						<font size="2">在面向服务的设计中，不能基于业务实体设计服务。相反，每个服务都是管理一组业务实体中的操作的完整单元。例如，顾客服务将响应来自任何其他系统或需要访问顾客信息的服务的请求。顾客服务可以处理更新顾客信息的请求；添加、更新、删除投资组合；以及查询顾客的定单历史。顾客服务拥有所有与它管理的顾客有关的数据，并且能够代表调用方进行其他服务查询，以提供统一的顾客服务视图。这意味着服务是一个管理器对象，它创建和管理它的一组组件。</font>
				</p>
				<p>
						<br />
				</p>
				<table cellspacing="0" cellpadding="0" width="100%" border="0">
						<tbody>
								<tr>
										<td>
												<font size="2">
														<img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif" width="100%" />
														<br />
														<img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8" border="0" />
												</font>
										</td>
								</tr>
						</tbody>
				</table>
				<table class="no-print" cellspacing="0" cellpadding="0" align="right">
						<tbody>
								<tr align="right">
										<td>
												<font size="2">
														<img height="4" alt="" src="http://www.ibm.com/i/c.gif" width="100%" />
														<br />
												</font>
												<table cellspacing="0" cellpadding="0" border="0">
														<tbody>
																<tr>
																		<td valign="center">
																				<font size="2"> <br /></font>
																		</td>
																		<td valign="top" align="right">
																				<a class="fbox" href="http://www-128.ibm.com/developerworks/cn/webservices/ws-ovsoa/#main">
																						<b>
																						</b>
																				</a>
																		</td>
																</tr>
														</tbody>
												</table>
										</td>
								</tr>
						</tbody>
				</table>
				<br />
				<br />
				<p>
						<a name="4">
								<span class="atitle">
										<font face="Arial" size="2">第四部分：面向服务的体系结构所带来的好处</font>
								</span>
						</a>
				</p>
				<p>
						<font size="2">如前所述，企业正在处理两个问题：迅速地改变的能力和降低成本的要求。为了保持竞争力，企业必须快速地适应内部因素（如兼并和重组）或外部因素（如竞争能力和顾客要求）。需要经济而灵活的 IT 基础设施来支持企业。</font>
				</p>
				<p>
						<font size="2">我们可以认识到，采用面向服务的体系结构将给我们带来几方面的好处，有助于我们在今天这个动荡的商业环境中取得成功：</font>
				</p>
				<p>
						<a name="N10204">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">利用现有的资产。</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">SOA 提供了一个抽象层，通过这个抽象层，企业可以继续利用它在 IT 方面的投资，方法是将这些现有的资产包装成提供企业功能的服务。组织可以继续从现有的资源中获取价值，而不必重新从头开始构建。</font>
				</p>
				<p>
						<a name="N1020D">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">更易于集成和管理复杂性。</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">在面向服务的体系结构中，集成点是规范而不是实现。这提供了实现透明性，并将基础设施和实现发生的改变所带来的影响降到最低限度。通过提供针对基于完全不同的系统构建的现有资源和资产的服务规范，集成变得更加易于管理，因为复杂性是隔离的。当更多的企业一起协作提供价值链时，这会变得更加重要。</font>
				</p>
				<p>
						<a name="N10216">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">更快的响应和上市速度。</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">从现有的服务中组合新的服务的能力为需要灵活地响应苛刻的商业要求的组织提供了独特的优势。通过利用现有的组件和服务，可以减少完成软件开发生命周期（包括收集需求、进行设计、开发和测试）所需的时间。这使得可以快速地开发新的业务服务，并允许组织迅速地对改变做出响应和减少上市准备时间。</font>
				</p>
				<p>
						<a name="N1021F">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">减少成本和增加重用。</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">通过以松散耦合的方式公开的业务服务，企业可以根据业务要求更轻松地使用和组合服务。这意味资源副本的减少、以及重用和降低成本的可能性的增加。</font>
				</p>
				<p>
						<a name="N10228">
								<span class="smalltitle">
										<strong>
												<font face="Arial" size="2">说到做到</font>
										</strong>
								</span>
						</a>
				</p>
				<p>
						<font size="2">通过 SOA，企业可以未雨绸缪，为未来做好充分的准备。SOA 业务流程是由一系列业务服务组成的，可以更轻松地创建、修改和管理它来满足不同时期的需要。</font>
				</p>
				<p>
						<font size="2">SOA 提供了灵活性和响应能力，这对于企业的生存和发展来说是至关重要的。但是面向服务的体系结构决不是灵丹妙药，而迁移到 SOA 也并非一件可以轻而易举就完成的事情。请别指望一个晚上就将整个企业系统迁移到面向服务的体系结构，我们推荐的方法是，在业务要求出现或露出苗头时迁移企业功能的适当部分。</font>
				</p>
		</div>
<img src ="http://www.blogjava.net/blogpig/aggbug/74769.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/blogpig/" target="_blank">邱恩</a> 2006-10-12 13:05 <a href="http://www.blogjava.net/blogpig/articles/74769.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>分页</title><link>http://www.blogjava.net/blogpig/articles/73926.html</link><dc:creator>邱恩</dc:creator><author>邱恩</author><pubDate>Sun, 08 Oct 2006 16:05:00 GMT</pubDate><guid>http://www.blogjava.net/blogpig/articles/73926.html</guid><wfw:comment>http://www.blogjava.net/blogpig/comments/73926.html</wfw:comment><comments>http://www.blogjava.net/blogpig/articles/73926.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/blogpig/comments/commentRss/73926.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/blogpig/services/trackbacks/73926.html</trackback:ping><description><![CDATA[
		<p>CREATE PROCEDURE  Zkx_Ibcom_DevPage<br />  <br />      @PageSize int,   --每页的记录条数  <br />      @PageNumber int--当前页面 <br />            <br />    <br /> <br /> AS</p>
		<p>   /*<br />SELECT TOP 页大小 * <br />FROM TestTable <br />WHERE (ID &gt; <br />(SELECT MAX(id) <br />FROM (SELECT TOP 页大小*页数 id <br />FROM 表 <br />ORDER BY id) AS T)) <br />ORDER BY ID <br /> */<br />    Declare @SqlTable AS varchar(1000)  --数据表<br />    Declare @SqlFiled AS Varchar(1000)   -- 数据字段<br />    Declare  @SqlWhere AS Varchar(1000) --数据查询条件 <br />    Declare  @SqlText   AS Varchar(1000)    --SQL字符串<br /> IF @PageNumber &gt;1<br />  BEGIN <br /> </p>
		<p>  SET  @SqlTable=' test '</p>
		<p>  SET   @SqlFiled='*'</p>
		<p>  SET   @SqlWhere= ' (ID &lt; (SELECT MIN(id) FROM (SELECT TOP   '+CAST((@PageNumber-1)*@PageSize AS varchar(30)) + '  id  FROM <a href="mailto:'+@SqlTable+'">'+@SqlTable+'</a> ORDER BY id desc) AS T))' <br /> <br />  SET  @SqlText='SELECT TOP  '+CAST(@PageSize AS varchar(30)) +  ' <a href="mailto:'+@SqlFiled+'">'+@SqlFiled+'</a> FROM ' + @SqlTable +' where <a href="mailto:'+@SqlWhere">'+@SqlWhere</a>   +'ORDER BY ID DESC' </p>
		<p>    Exec(@SqlText)<br />  END</p>
		<p>ELSE<br />   BEGIN<br />      SET @SqlText=  'SELECT TOP '+  CAST(@PageSize AS varchar(30))+ '  * FROM TEST ORDER BY ID DESC '<br />      Exec(@SqlText)<br />   END<br />GO<br /></p>
<img src ="http://www.blogjava.net/blogpig/aggbug/73926.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/blogpig/" target="_blank">邱恩</a> 2006-10-09 00:05 <a href="http://www.blogjava.net/blogpig/articles/73926.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>