SOA

Service-Oriented Architecture，面向服务架构，粗粒度、开放式、松耦合的服务结构，将应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和契约联系起来。接口采用中立的方式定义，独立于实现服务的硬件平台、操作系统和编程语言（跨平台）。

SOA既是一种编程方式，也是软件开发的一种架构方法，服务层是SOA的基础，核心是“服务”，本质就是将服务组合起来并对外提供接口。SOA架构的技术基础是SOAP（Simple Object Access Protocol，简易对象访问协议）标准，SOAP用XML语言定义一个服务操作方法所发送和接收消息的内容。

实现SOA思想的技术

• Web Service：
• WCF：

参考：对SOA的一点理解；漫谈SOA；

有关 web service 的学习，参见：Web Service - sqh；

关于 Web Service 和 WCF，异同点作简单的说明

• 数据交换/通信方式：Web 服务在HTTP上通过SOAP与端点通信，WCF 服务可以选择使用不同的协议进行通信
• 运行方式：Web 服务总是运行在 IIS 上，WCF 服务可以选择合适宿主

关于WCF与Web Service的区别参见：http://www.cnblogs.com/xiurui12345/archive/2012/03/30/2425445.html。下面主要研究 WCF。

WCF

namespace System.ServiceModel.Desc

{

	// 表示允许服务的客户端查找并与服务通信的服务的终结点

	public class ServiceEndpoint

	{

		public string Name { get; set; } // 服务终结点的名称

		public EndpointAddress Address { get; set; }  // 服务终结点的终结点地址

		public ContractDescription Contract { get; set; } // 服务终结点的协定

		public Binding Binding { get; set; } // 服务终结点的绑定

	}

}

namespace System.ServiceModel

{

    // 提供客户端用来与服务终结点进行通信的唯一网络地址。

    public class EndpointAddress

    {

		public Uri Uri { get; } // 终结点的 URI，服务的唯一标识

		public EndpointIdentity Identity { get; } // 用于验证终结点的标识

		public AddressHeaderCollection Headers { get; } // 获取生成器可以创建的终结点的地址标头的集合

	}

}

// 服务地址

Uri baseAddress = new Uri("http://localhost:8000/MyService"); 

// 服务宿主

using(ServiceHost host = new ServiceHost(typeof(HelloWCFService), baseAddress))

{

	// 添加终结点（地址、绑定、服务协定）

	host.AddServiceEndpoint(typeof(IHelloWCFService), new WSHttpBinding(), "HelloWCFService");  

	// 元数据交换结点，用于元数据交换，并指定启用元数据交换行为

	ServiceMetadataBehavior smb = new ServiceMetadataBehavior();

	smb.HttpGetEnabled = true;

	host.Description.Behaviors.Add(smb);  

	// 启动服务

	host.Open();

	// doSomething(...)

	host.Close();

}

<?xml version="1.0" encoding="utf-8"?>

 <configuration>

   <system.serviceModel>

     <!--配置服务和终结点-->

     <services>

       <service name="服务命名空间.服务协定" behaviorConfiguration="myBehavior">

	     // 宿主服务地址

		 <host>

           <baseAddresses>

             <add baseAddress="wcfURI"/>

           </baseAddresses>

         </host>

         // 服务终结点

		 <endpoint address="xxx" binding="wsHttpBinding" contract="服务命名空间.服务协定接口" bindingConfiguration="myBinding"></endpoint>

	     // 元数据交换结点

		 <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>

	   </service>

     </services>

     <!--配置绑定-->

     <bindings>

       <netTcpBinding>

         <binding name="myBinding"></binding>

       </netTcpBinding>

     </bindings>

     <!--配置行为-->

     <behaviors>

       <serviceBehaviors>

         <behavior name="myBehavior"></behavior>

       </serviceBehaviors>

     </behaviors>

   </system.serviceModel>

 </configuration>

// 数据协定

// 指定该类型要定义或实现一个数据协定，并可由序列化程序（如 System.Runtime.Serialization.DataContractSerializer）进行序列化

// 若要使其类型可序列化，类型作者必须为其类型定义数据协定

[DataContract]

// 数据成员协定

// 当应用于类型的成员时，指定该成员是数据协定的一部分并可由 System.Runtime.Serialization.DataContractSerializer 进行序列化

[DataMember]

// 服务协定

// 指示接口或类在 应用程序中定义服务协定

[ServiceContract]

// 操作协定

// 指示方法定义一个操作，该操作是 应用程序中服务协定的一部分

[OperationContract]

using System.ServiceModel;

using System.Runtime.Serialization;

using SqhWcfFunction;

namespace SqhWcfService

{

    [ServiceContract]  // 服务契约

    public interface ISqhService{

        [OperationContract]   // 操作契约

        QueryOut QueryPersonInfoService(QueryIn inParam);

    }

}

namespace SqhWcfService

{

    public class SqhService : ISqhService

    {

        public QueryOut QueryPersonInfoService(QueryIn inParam)

        {

            QueryOut outParam = new QueryOut();

            try

            {

                outParam = SqhServiceFunction.QueryPersonInfo(inParam);

            }

            catch (Exception e)

            {

                outParam.ErrMsg = "查询person信息时发生异常，" + e.Message;

                outParam.isSuccessed = false;

                return outParam;

            }

            return outParam;

        }

    }

}

using System.ServiceModel;

using System.Runtime.Serialization;

namespace SqhWcfFunction

{

    [DataContract]  // 数据契约

    public class QueryIn{

        [DataMember]   // 数据成员契约，标识类型可序列化

        public string personID;

        [DataMember]

        public string personName;

    }

    [DataContract]

    public class QueryOut{

        [DataMember]

        public string personResInfo;

        [DataMember]

        public bool isSuccessed;

    }

}

[1]. 右键项目，生成部署包

[2]. ...\obj\Debug\Package\PackageTmp\ 目录下的文件就是待部署的文件

[3]. PackageTmp 下的文件全部拷贝到 IIS 下的相关文件夹中即可

问题1：

“/SQHWCFSERVICE”应用程序中的服务器错误。

配置错误

 说明: 在处理向该请求提供服务所需的配置文件时出错。请检查下面的特定错误详细信息并适当地修改配置文件。

 分析器错误消息: 无法识别的属性“targetFramework”。请注意属性名称区分大小写。

源错误:

     <compilation debug="true" targetFramework="4.0"/>

版本信息: Microsoft .NET Framework 版本:2.0.50727.4961; ASP.NET 版本:2.0.50727.4955

问题2：

应用程序“NET/CRM”中的服务器错误  Internet Information Services 7.5

错误摘要：HTTP 错误 404.2 - Not Found

由于 Web 服务器上的“ISAPI 和 CGI 限制”列表设置，无法提供您请求的页面。

问题3：

通过IIS直接浏览页面时报错：HTTP 错误 404.3 - Not Found 由于扩展配置问题而无法提供您请求的页面。

如果该页面是脚本，请添加处理程序。如果应下载文件，请添加 MIME 映射。

文件扩展名：.json

MIME 类型：application/json

using System.ServiceModel;

using System.Runtime.Serialization;

using SqhWcfFunction;

namespace SqhWcfService{

    public class SqhService : ISqhService

    {

        public QueryOut QueryPersonInfoService(QueryIn inParam)

        {

            QueryOut outParam = new QueryOut();

            try{

                outParam = SqhServiceFunction.QueryPersonInfo(inParam);

            }

            catch (Exception e){

                outParam.ErrMsg = "查询person信息时发生异常，" + e.Message;

                outParam.isSuccessed = false;

                return outParam;

            }

            return outParam;

        }

    }

}

namespace SqhWcfFunction{

    public class SqhServiceFunction

    {

        public static QueryOut QueryPersonInfo(QueryIn inParam)

        {

            QueryOut outParam = new QueryOut();

            try{

                // 动态SQL、访问数据库等其他各种操作

                outParam.isSuccessed = true;

                outParam.personResInfo = string.Format("My WCF Service：{0}-{1}", inParam.personID, inParam.personName);

            }

            catch (Exception e){

                outParam.ErrMsg = "查询失败" + e.Message;

                outParam.isSuccessed = false;

                return outParam;

            }

            return outParam;

        }

    }

}

using System.ServiceModel;

using System.Runtime.Serialization;

using SqhWcfClient.SqhService;

namespace SqhWcfClient

{

    public class Program{

        static void Main(string[] args){

            SqhServiceClient SqhClient = new SqhServiceClient();  // 客户端

            QueryIn inParam = new QueryIn(){ personID = "001", personName = "sqh" };

            QueryOut outParam = SqhClient.QueryPersonInfoService(inParam);

            if(outParam.isSuccessed)

                Console.WriteLine(outParam.personResInfo);

            SqhClient.Close();   // 关闭客户端

        }

    }

}　

 namespace RVC.WCF.Calculate

 {

     [ServiceContract]

     public interface ICalculateService

     {

         [OperationContract]

         double Add(double a, double b);

         [OperationContract]

         double Minus(double a, double b);

         [OperationContract]

         double Multiple(double a, double b);

         [OperationContract]

         double Divide(double a, double b);

     }

 }

 namespace RVC.WCF.Calculate

 {

     public class CalculateService : ICalculateService

     {

         public double Add(double a, double b) {

             return a + b;

         }

         public double Minus(double a, double b) {

             return a - b;

         }

         public double Multiple(double a, double b) {

             return a * b;

         }

         public double Divide(double a, double b) {

             if ((int)b == ){

                 return double.MaxValue;

             }

             return a * 1.0 / b;

         }

     }

 }

 namespace RVC.WCF.Certificate

 {

     [ServiceContract]

     public interface ICertificateService

     {

         [OperationContract]

         string CertificateUser(string userName, string passWord);

         [OperationContract]

         UserInfo GetUserInfo(string userID);

         [OperationContract]

         bool CancelUser(string userID);

     }

 }

namespace RVC.WCF.Certificate

{

    public class CertificateService : ICertificateService

    {

        private static Dictionary<string, UserInfo> UserDic = new Dictionary<string, UserInfo>();

        public string CertificateUser(string userName, string passWord)

        {

            string userID = DateTime.Now.ToShortTimeString() + passWord;

            UserInfo user = new UserInfo() {

                UserID = userID,

                UserName = userName,

                Password = passWord,

                CertTime = DateTime.Now

            };

            if (UserDic.ContainsKey(user.UserID)) {

                throw new Exception("该用户已存在");

            }

            UserDic.Add(user.UserID, user);

            return userID;

        }

        public UserInfo GetUserInfo(string userID)

        {

            UserInfo ret = new UserInfo();

            if (!UserDic.ContainsKey(userID)){

                throw new Exception("该用户不存在");

            }

            ret = UserDic[userID];

            return ret;

        }

        public bool CancelUser(string userID)

        {

            if (!UserDic.ContainsKey(userID)){

                throw new Exception("该用户不存在");

            }

            UserDic.Remove(userID);

            return true;

        }

    }

}

 namespace RVC.WCF.Certificate

 {

     [DataContract]

     public class UserInfo

     {

         [DataMember]

         public string UserID;

         [DataMember]

         public string UserName;

         [DataMember]

         public string Password;

         [DataMember]

         public DateTime CertTime;

     }

 }