REST还是SOAP？ 实体或运营？

Question

好吧，让我们假设我有一个名为Foo的实体的API，它看起来像这样：

.../api/foo (GET, PUT, POST) or (SELECT, INSERT, UPDATE internally)

这对很多消费者来说都很有效，特别是移动设备，因为它非常简洁轻巧。 现在让我们假设，如果我们坚持使用REST，那么名为ComeForth的操作ComeForth存在，它看起来像这样：

.../api/foo/1/comeforth (POST) or (perform the come forth operation)

好的，所以我们已经有了，但现在我们假设我需要消费者对该操作的更多信息，所以为了保持简洁，我只是要构建一个包含Foo ID和其他信息的新资源。 ，名为ComeForth ，API现在看起来像这样：

.../api/comeforth (POST) or (perform the come forth operation)

现在，以前的API .../api/foo/1/comeforth对我来说似乎没问题，但是第二个感觉就像是我试图将一个方形钉固定在一个圆孔中，只是因为我可以在一个圆孔上创建资源突发奇想并不意味着我应该。 所以，我的问题是：

1. 我真的应该为ComeForth操作发布基于SOAP的服务吗？
2. 如果我确实使用SOAP，那么这对消费者没有影响（即对于像JavaScript或移动设备这样的消费者来说，它还有很多工作要做吗？
3. SOAP是基于操作的，而REST是基于实体的，这真的是一个硬性规则吗？ 如果是这样，那么即使是.../api/foo/1/comeforth也会打破这个规则不会吗？

无论如何，我只是想确保我正在使用正确的技术来满足需求。

Answer 1

在您描述的情况下，正在操作的资源不是Foo，而是一个Transaction（根据您的注释）。 您为特定操作类型（ComeForth）针对T（Foo）类型的实体建模长时间运行的事务。

控制器接受用于处理的事务POST请求，并返回事务的表示，其包括分配给事务的唯一标识符，该标识符可用于跟踪其进度。

客户端执行GET操作以使用在接受事务处理时收到的唯一标识符来检索长时间运行的事务的状态。

我选择使用XML序列化进行演示，但您可以将参与事务的实体序列化为字节数组或任何有意义的数组。

示例Web API：

/交易/ {ID}

• POST：创建一个新事务以进行处理
• GET：检索具有指定标识的事务以验证它是否已完成

Web API服务模型：

[DataContract()]
public class Transaction
{
    public Transaction()
    {
        this.Id = Guid.Empty;
    }

    /// <summary>
    /// Gets or sets the unique identifier for this transaction.
    /// </summary>
    /// <value>
    /// A <see cref="Guid"/> that represents the unique identifier for this transaction.
    /// </value>
    [DataMember()]
    public Guid Id
    {
        get;
        set;
    }

    /// <summary>
    /// Gets or sets a value indicating if this transaction has been completed.
    /// </summary>
    /// <value>
    /// <see langword="true"/> if this transaction has been completed; otherwise, <see langword="false"/>.
    /// </value>
    [DataMember()]
    public bool IsComplete
    {
        get;
        set;
    }

    /// <summary>
    /// Gets or sets the action being performed.
    /// </summary>
    /// <value>The action being performed.</value>
    [DataMember()]
    public string Action
    {
        get;
        set;
    }

    /// <summary>
    /// Gets or sets the serialized representation of the entity participating in the transaction.
    /// </summary>
    /// <value>The serialized representation of the entity participating in the transaction.</value>
    [DataMember()]
    public string Entity
    {
        get;
        set;
    }

    /// <summary>
    /// Gets or sets the assembly qualified name of the entity participating in the transaction.
    /// </summary>
    /// <value>
    /// The <see cref="Type.AssemblyQualifiedName"/> of the <see cref="Entity"/>.
    /// </value>
    [DataMember()]
    public string EntityType
    {
        get;
        set;
    }

    /// <summary>
    /// Returns the <see cref="Entity"/> as a type of <typeparamref name="T"/>.
    /// </summary>
    /// <typeparam name="T">The type to project the <see cref="Entity"/> as.</typeparam>
    /// <returns>
    /// An object of type <typeparamref name="T"/> that represents the <see cref="Entity"/>.
    /// </returns>
    public T As<T>() where T : class
    {
        T result    = default(T);

        var serializer = new XmlSerializer(typeof(T));

        using (var reader = XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(this.Entity))))
        {
            result  = serializer.Deserialize(reader) as T;
        }

        return result;
    }

    /// <summary>
    /// Serializes the specified <paramref name="entity"/>.
    /// </summary>
    /// <typeparam name="T">The type of entity being serialized.</typeparam>
    /// <param name="entity">The entity to serialize.</param>
    public static Transaction From<T>(T entity, string action = null) where T : class
    {
        var transaction = new Transaction();

        transaction.EntityType  = typeof(T).AssemblyQualifiedName;
        transaction.Action      = action;

        var serializer  = new XmlSerializer(typeof(T));
        byte[] data     = null;

        using (var stream = new MemoryStream())
        {
            serializer.Serialize(stream, entity);
            stream.Flush();

            data        = stream.ToArray();
        }

        transaction.Entity = Encoding.UTF8.GetString(data);

        return transaction;
    }
}

[DataContract()]
public class Foo
{
    public Foo()
    {

    }

    [DataMember()]
    public string PropertyA
    {
        get;
        set;
    }

    [DataMember()]
    public int PropertyB
    {
        get;
        set;
    }

    [DataMember()]
    public Foo PropertyC
    {
        get;
        set;
    }
}

TransactionsController：

public class TransactionsController : ApiController
{
    public TransactionsController() : base()
    {

    }

    private static ConcurrentDictionary<Guid, Transaction> _transactions = new ConcurrentDictionary<Guid, Transaction>();

    /// <summary>
    /// Using to initiate the processing of a transaction
    /// </summary>
    /// <param name="transaction"></param>
    /// <returns></returns>
    [HttpPost()]
    public HttpResponseMessage Post(Transaction transaction)
    {
        if(transaction == null)
        {
            return this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, new HttpError("Unable to model bind request."));
        }

        transaction.Id  = Guid.NewGuid();

        // Execute asynchronous long running transaction here using the model.
        _transactions.TryAdd(transaction.Id, transaction);

        // Return response indicating request has been accepted fro processing
        return this.Request.CreateResponse<Transaction>(HttpStatusCode.Accepted, transaction);

    }

    /// <summary>
    /// Used to retrieve status of a pending transaction.
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet()]
    public HttpResponseMessage Get(Guid id)
    {
        Transaction transaction = null;

        if(!_transactions.TryGetValue(id, out transaction))
        {
            return this.Request.CreateErrorResponse(HttpStatusCode.NotFound, new HttpError("Transaction does not exist"));
        }

        return this.Request.CreateResponse<Transaction>(HttpStatusCode.OK, transaction);
    }
}

示例客户端调用事务控制器：

var foo = new Foo()
{
    PropertyA   = "ABC",
    PropertyB   = 123,

    PropertyC   = new Foo()
    {
        PropertyA   = "DEF",
        PropertyB   = 456
    }
};

var transaction = Transaction.From<Foo>(foo, "ComeForth");

Guid pendingTransactionId = Guid.Empty;

// Initiate a transaction
using(var client = new HttpClient())
{
    client.BaseAddress  = new Uri("http://localhost:12775/api/", UriKind.Absolute);

    using (var response = client.PostAsJsonAsync<Transaction>("transactions", transaction).Result)
    {
        response.EnsureSuccessStatusCode();

        pendingTransactionId = response.Content.ReadAsAsync<Transaction>().Result.Id;
    }
}

// Retrieve status of transaction
Transaction pendingTransaction = null;

using (var client = new HttpClient())
{
    client.BaseAddress = new Uri("http://localhost:12775/api/", UriKind.Absolute);

    var requestUri = String.Format(null, "transactions\\{0}", pendingTransactionId.ToString());

    using (var response = client.GetAsync(requestUri).Result)
    {
        response.EnsureSuccessStatusCode();

        pendingTransaction = response.Content.ReadAsAsync<Transaction>().Result;
    }
}

// Check if transaction has completed
if(pendingTransaction.IsComplete)
{

}

因此，您仍然可以使用REST和ASP.NET Web API来模拟长时间运行的进程的启动，您只需将操作表示为其自己的独立资源即可。 希望这有助于您的开发工作。

Answer 2

对我来说，这听起来像一个非常开放的问题，需要考虑很多因素。

当您的呼叫与CRUD（创建，检索，更新，删除）匹配时，REST非常棒，以Twitter为例，您可以创建，回复，更新和删除Twitter帖子。

现在考虑一个处理交易的支付处理器，你可以创建一个（即传递一个cc＃），它会有条件地做一些事情，然后可能返回一个交易结果（成功或失败）。 您无法真正“更新”某个交易，而“转发”该交易并不会真正检索您发送的数据。 您当然不能“删除”交易，您可能无效，或执行退款（部分或全部）。 对于这个例子，REST没有意义。

这并不是说你不能混合使用REST和操作。 某些实体符合REST，但还有其他方法（如处理付款），其中REST不适合。

选择应由目标受众确定的REST或SOAP，WCF服务（使用SOAP）的决定在.NET中比REST更容易实现，如果消费技术是红宝石，则反之亦然。