4

我正在使用服务堆栈和 AppHostHttpListenerBase 创建一个自托管的 REST 服务。我想为我的服务（例如“api”）使用基本 URI，如下所示：

http://myserver/api/service1/param
http://myserver/api/service2/param

如何在我的每条路线中不定义“api”的情况下做到这一点。在 IIS 中，我可以设置一个虚拟目录来隔离服务，但是在自托管时如何做到这一点？

4

4 回答 4

4

来吧..（作为奖励，这是您将服务放入插件的方式。

using BlogEngineService;
using ServiceStack.WebHost.Endpoints;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogEngineWinService
{
    public class AppHost : AppHostHttpListenerBase
    {
        public AppHost() : base("Self Host Service", typeof(AppHost).Assembly) { }
        public override void Configure(Funq.Container container)
        {
            Plugins.Add(new BlogEngine());
        }
    }
}

这就是你自动连接它的方式

呼叫 appHost.Routes.AddFromAssembly2(typeof(HelloService).Assembly);就是呼叫自动接线的分机。

using ServiceStack.WebHost.Endpoints;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ServiceStack.ServiceInterface;

namespace BlogEngineService
{
    public class BlogEngine : IPlugin, IPreInitPlugin
    {
        public void Register(IAppHost appHost)
        {

            appHost.RegisterService<HelloService>();
            appHost.Routes.AddFromAssembly2(typeof(HelloService).Assembly);
        }

        public void Configure(IAppHost appHost)
        {

        }
    }
}

这就是您标记服务类以为其提供前缀的方式。只需使用此属性标记类

using ServiceStack.DataAnnotations;
using ServiceStack.ServiceHost;
using ServiceStack.ServiceInterface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BlogEngineService
{
    public class Hello
    {
        [PrimaryKey]
        public string Bob { get; set; }
    }

    public class HelloResponse
    {
        public string Result { get; set; }
    }

    [PrefixedRoute("/test")]
    public class HelloService : Service
    {

        public object Any(Hello request)
        {
            return new HelloResponse { Result = "Hello, " + request.Bob};
        }
    }
}

在您的项目中为扩展创建一个 CS 文件。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using ServiceStack.Common;
using ServiceStack.Common.Utils;
using ServiceStack.Common.Web;
using ServiceStack.Text;
using ServiceStack.ServiceHost;
using ServiceStack.WebHost.Endpoints;
using ServiceStack.ServiceInterface;

namespace ServiceStack.ServiceInterface
{
    public static class ServiceRoutesExtensions
    {
        /// <summary>
        ///     Scans the supplied Assemblies to infer REST paths and HTTP verbs.
        /// </summary>
        ///<param name="routes">The <see cref="IServiceRoutes"/> instance.</param>
        ///<param name="assembliesWithServices">
        ///     The assemblies with REST services.
        /// </param>
        /// <returns>The same <see cref="IServiceRoutes"/> instance;
        ///     never <see langword="null"/>.</returns>
        public static IServiceRoutes AddFromAssembly2(this IServiceRoutes routes,
                                                     params Assembly[] assembliesWithServices)
        {
            foreach (Assembly assembly in assembliesWithServices)
            {

                AddNewApiRoutes(routes, assembly);
            }

            return routes;
        }

        private static void AddNewApiRoutes(IServiceRoutes routes, Assembly assembly)
        {
            var services = assembly.GetExportedTypes()
                .Where(t => !t.IsAbstract
                            && t.HasInterface(typeof(IService)));

            foreach (Type service in services)
            {
                var allServiceActions = service.GetActions();
                foreach (var requestDtoActions in allServiceActions.GroupBy(x => x.GetParameters()[0].ParameterType))
                {
                    var requestType = requestDtoActions.Key;
                    var hasWildcard = requestDtoActions.Any(x => x.Name.EqualsIgnoreCase(ActionContext.AnyAction));
                    string allowedVerbs = null; //null == All Routes
                    if (!hasWildcard)
                    {
                        var allowedMethods = new List<string>();
                        foreach (var action in requestDtoActions)
                        {
                            allowedMethods.Add(action.Name.ToUpper());
                        }

                        if (allowedMethods.Count == 0) continue;
                        allowedVerbs = string.Join(" ", allowedMethods.ToArray());
                    }
                    if (service.HasAttribute<PrefixedRouteAttribute>())
                    {
                        string prefix = "";
                        PrefixedRouteAttribute a = (PrefixedRouteAttribute)Attribute.GetCustomAttribute(service, typeof(PrefixedRouteAttribute));
                        if (a.HasPrefix())
                        {
                            prefix = a.GetPrefix();
                        }
                        routes.AddRoute(requestType, allowedVerbs, prefix);
                    }
                    else
                    {
                        routes.AddRoute(requestType, allowedVerbs);
                    }
                }
            }
        }

        private static void AddRoute(this IServiceRoutes routes, Type requestType, string allowedVerbs, string prefix = "")
        {
            var newRoutes = new ServiceStack.ServiceHost.ServiceRoutes();
            foreach (var strategy in EndpointHost.Config.RouteNamingConventions)
            {
                strategy(newRoutes, requestType, allowedVerbs);
            }
            foreach (var item in newRoutes.RestPaths)
            {

                string path = item.Path;
                if (!string.IsNullOrWhiteSpace(prefix))
                {
                    path = prefix + path;
                }
                routes.Add(requestType, restPath: path, verbs: allowedVerbs);
            }
        }
    }

    public class PrefixedRouteAttribute : Attribute
    {
        private string _prefix { get; set; }
        private bool _hasPrefix { get; set; }

        public PrefixedRouteAttribute(string path) 
        {
            if (!string.IsNullOrWhiteSpace(path))
            {
                this._hasPrefix = true;
                this._prefix = path;
                //this.Path = string.Format("/{0}{1}", Prefix, Path);
            }
        }
        public bool HasPrefix()
        {
            return this._hasPrefix;
        }
        public string GetPrefix()
        {
            return this._prefix;
        }
    }
}
于 2013-05-09T00:41:58.280 回答
2

ServiceStack 的 HttpListener 主机希望托管在根 / 路径，因为正常的用例是让每个自托管服务在不同的自定义端口上可用。

由于它目前不支持在 /custompath 上托管，因此您必须/api/在所有服务路由上指定前缀。

如果您想在自定义路径中查看对托管的支持，请添加一个问题。

于 2012-07-13T19:17:37.213 回答
2

实际上有一个更简单的解决方案。在您的 web.config 中，将您的 http-handler 更新为：

<httpHandlers>
  <add path="api*" type="ServiceStack.WebHost.Endpoints.ServiceStackHttpHandlerFactory, ServiceStack" verb="*" />
</httpHandlers>

有了上述内容，您的所有服务 api 都必须以“/api/”为前缀。如果你已经在你的任何路由中使用了“/api/”，你现在必须删除它们或者必须在你的调用中指定它两次。

参考： https ://github.com/ServiceStack/SocialBootstrapApi

于 2013-03-25T16:30:40.810 回答
1

我找到了解决方法。我只在自托管下对此进行了测试。

创建一个继承自 RouteAttribute 的“PrefixedRouteAttribute”类

public class PrefixedRouteAttribute : RouteAttribute
{
  public static string Prefix { get; set; }

  public PrefixedRouteAttribute(string path) :
    base(path)
  {
    SetPrefix();
  }

  public PrefixedRouteAttribute(string path, string verbs)
    : base(path, verbs)
  {
    SetPrefix();
  }

  private void SetPrefix()
  {
    if (!string.IsNullOrWhiteSpace(Prefix))
    {
      this.Path = string.Format("/{0}{1}", Prefix, Path);
    }
  }   
}

创建 AppHost 时，您可以设置前缀

PrefixedRouteAttribute.Prefix = "api";

然后，不要使用 [Route] 属性，而是在您的类上使用 [PrefixRoute] 属性

[PrefixedRoute("/echo")]
[PrefixedRoute("/echo/{Value*}")]
public class Echo
{
  [DataMember]
  public string Value { get; set; }
}

然后，这将适用于请求

/api/echo
/api/echo/1

这可能会得到改善。我不太喜欢通过静态属性设置前缀的方式，但在我的设置下我想不出更好的方法。虽然创建覆盖属性的原则似乎很合理，但这是重要的部分。

于 2012-11-29T05:48:51.207 回答