nginx 分布式的使用

cmdWin7停nginx默认80端口被System占用，造成nginx启动报错的解决方案

www.MyException.Cn 网友分享于：2013-10-23 浏览：215次

Win7下nginx默认80端口被System占用，造成nginx启动报错的解决方案

问题：

在win7 32位旗舰版下，启动1.0.8版本nginx，显示如下错误：[plain]2012/04/02 13:55:59 [emerg] 7864#2376: bind() to 0.0.0.0:80 failed (10013: An attempt was made to access a socket in a way forbidden by its access permissions)

解决方案：

在cmd窗口运行如下命令：netstat -aon | findstr :80

看到80端口果真被占用。发现占用的pid是4，名字是System。怎么禁用呢？

1、打开注册表编辑器：regedit

2、 找到HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/services/HTTP

3、 把REG_DWORD类型的项Start，将其改为0

4、重启系统，System进程不会占用80端口

如果还不行的话：

修改conf文件夹下的nginx.conf文件中的监听端口，原先为80，改为8088就OK了

server {

listen 8088;

一、简要介绍

Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和 低系统资源的消耗而闻名。2011年6月1日，nginx 1.0.4发布。

Nginx作为负载均衡服务器：Nginx 既可以在内部直接支持 Rails 和 PHP 程序对外进行服务，也可以支持作为 HTTP代理服务器对外进行服务。Nginx采用C进行编写，不论是系统资源开销还是CPU使用效率都比 Perlbal 要好很多。

　　作为邮件代理服务器：Nginx 同时也是一个非常优秀的邮件代理服务器（最早开发这个产品的目的之一也是作为邮件代理服务器），Last. fm 描述了成功并且美妙的使用经验。

　　Nginx 是一个安装非常的简单，配置文件非常简洁（还能够支持perl语法），Bugs非常少的服务器：Nginx 启动特别容易，并且几乎可以做到7*24不间断运行，即使运行数个月也不需要重新启动。你还能够不间断服务的情况下进行软件版本的升级。

（更多介绍参照百科，更多使用参照GOOGLE，广而告之）

二、下载安装

我们使用nginx 1.0.4 for windows版本，下载解压后放到C:\nginx-1.0.4（官网这样要求的，不知道放其它盘有没有问题）

运行cmd.exe到

有错误啊，也不知道启动成功没有，去看看日志吧。

logs里有出现了两个日志文件access.log,error.log, 打开error.log开到下面提示

2011/06/16 15:23:55 [emerg] 7136#4040: bind() to 0.0.0.0:80 failed (10013: An attempt was made to access a socket in a way forbidden by its access permissions)

2011/06/16 15:24:14 [emerg] 6336#7052: bind() to 0.0.0.0:80 failed (10013: An attempt was made to access a socket in a way forbidden by its access permissions)

去nginx官网搜了一下原因：

1 - Is there any firewall activated (e.g. windows Firewall)?

2 - Is there any program using port 80 (e.g. Skype) ?

Before starting NGINX type in the prompt :

TELNET 127.0.0.1 80

(NOTE: there is a space between the 80)

If it is successfull then there a program using the port.

3 - Have you tried to configure another port? If so, same error happens?

3个原因：

1.防火墙打开了（确实我的WIN7 windows Firewall打开了，但是关了后还是不能启动nginx)

2.80端口被占用了（确实有个默认的站点用的80端口，关闭了后再启动nginx正常了，80后为Nginx默认的配置）

怎么看出来的正常的，看一下logs下面是不是多了一个nginx.pid文件，cmd窗口了输入

C:\nginx-1.0.4>tasklist /fi "imagename eq nginx.exe"

结果如下:

这时说明已经启成功了，有两个进程。按照官方的解释，nginx是守护进程，其中一个是一直处理事件等待中，当有事件被触发时，就启动另外一个进程处理相关请求。

访问成功后可以logs下的access.log看到访问站点的request信息

View Code

如果没有成功可以再查看logs下的error.log原因，以下为其它操作命令

官网提供了详细的windows usage 安装说明，网上大部分写的都很乱。我第一次参照网上其它人没成功过-_-|||，发现官网有安装说明照着操作一遍成功了，所以建议大家以后多看官网说明以及源码，可以少走很多弯路。

三、配置测试

第二环节我们使用了默认的nginx.conf 。Nginx的配置文件都存于目录conf文件下，其中nginx.conf是它的主配置文件。

以下为我加上注释并配置的新的虚拟server

View Code

#号为注释内容，我们在cmd下运行nginx

启动成功，出错的话，可以查询日志（日志路径是配置文件指定的，你可以修改存到其它位置）

一、实战

写一个web项目 发布到IIS上，index.aspx （在IIS上部署两个项目 端口号：8082 、9000）

修改配置文件：

C:\nginx-1.10.0\conf\nginx.conf

配置一个集群：server前面不能有空格，该文件最好不要用记事本打开，否则会自动加上Dom头。导致报错

下面这个文件，执行运行可以启动关闭或者重启nginx

主要内容：@echo off

rem 当前bat的作用

echo ==================begin========================

cls

SET NGINX_PATH=%~d0

SET NGINX_DIR=%~dp0

color 0a

TITLE Nginx 管理程序 Power By Ants (http://leleroyn.cnblogs.com)

CLS

ECHO.

ECHO. * * Nginx 管理程序 Power By Ants (http://leleroyn.cnblogs.com) *

ECHO.

ECHO.

:MENU

ECHO. * nginx 进程list *

tasklist|findstr /i "nginx.exe"

ECHO.

ECHO. [1] 启动Nginx

ECHO. [2] 关闭Nginx

ECHO. [3] 重启Nginx

ECHO. [4] 退 出

ECHO.

ECHO.请输入选择项目的序号:

set /p ID=

IF "%id%"=="1" GOTO start

IF "%id%"=="2" GOTO stop

IF "%id%"=="3" GOTO restart

IF "%id%"=="4" EXIT

PAUSE

:start

call :startNginx

GOTO MENU

:stop

call :shutdownNginx

GOTO MENU

:restart

call :shutdownNginx

call :startNginx

GOTO MENU

:shutdownNginx

ECHO.

ECHO.关闭Nginx......

taskkill /F /IM nginx.exe > nul

ECHO.OK,关闭所有nginx 进程

goto :eof

:startNginx

ECHO.

ECHO.启动Nginx......

IF NOT EXIST "%NGINX_DIR%nginx.exe" ECHO "%NGINX_DIR%nginx.exe"不存在

%NGINX_PATH%

cd "%NGINX_DIR%"

IF EXIST "%NGINX_DIR%nginx.exe" (

echo "start '' nginx.exe"

start "" nginx.exe

)

ECHO.OK

goto :eof

最后直接在浏览器输入：http://127.0.0.1:8088/index.aspx 实现了分布式

Nginx.conf 配置里面默认端口号：80 可自行修改

负载的服务器配置不一样，有的高有的低可不可以让配置高的服务器处理请求多一些

• 这里讲一下，负载均衡有好几种算法 轮转法，散列法， 最少连接法，最低缺失法，最快响应法，加权法。我们这里可以使用加权法来分配请求。

upstream Jq_one{

　　server 127.0.0.1:8082 weight=4;

　　 server 127.0.0.1:9000 weight=1;

　　}

通过weight设置每台服务器分配请求站的权重，值越高分配的越多。

由于请求是经过nginx转发过来的，可以在代码里面获取到用户请求的实际ip地址吗？

• 答案是肯定的，在localtion节点设置如下请求头信息

#设置主机头和客户端真实地址，以便服务器获取客户端真实IP

proxy_set_header Host $host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

代码里面通过Request.Headers["X-Real-IP"]，就能获取到真实ip

二、配置MVC项目

刚安装的版本适合 aspx页面，要想使用mvc,还需要修改一下配置：

1.

添加：

fastcgi_pass 127.0.0.1:8080; #fastcgi的监听端口

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

include fastcgi_params; #由于我把nginx放到C盘的根目录，如果放到其他地方的话 目录#要写对

2.更改另外一个配置文件：

添加

fastcgi_param PATH_INFO "";

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

三、使用Redis实现Session共享

1.redis基本配置

1.1配置

<section

name="RedisConfig" type="Custom_RedisSessionStateStore.RedisConfigInfo,Custom_RedisSessionStateStore

"/>

<RedisConfig WriteServerList="127.0.0.1:6379" ReadServerList="127.0.0.1:6379" MaxWritePoolSize="60" MaxReadPoolSize="60" AutoStart="true" LocalCacheTime="180" RecordeLog="false">

</RedisConfig>

1.2 基本代码

RedisConfigInfo 类：读取以上配置信息

namespace Custom_RedisSessionStateStore

{

public class RedisConfigInfo : ConfigurationSection

{

/// <summary>

/// 可写的Redis链接地址

/// </summary>

[ConfigurationProperty("WriteServerList", IsRequired = false)]

public string WriteServerList

{

get

{

return (string)base["WriteServerList"];

}

set

{

base["WriteServerList"] = value;

}

}

/// <summary>

/// 可读的Redis链接地址

/// </summary>

[ConfigurationProperty("ReadServerList", IsRequired = false)]

public string ReadServerList

{

get

{

return (string)base["ReadServerList"];

}

set

{

base["ReadServerList"] = value;

}

}

/// <summary>

/// 最大写链接数

/// </summary>

[ConfigurationProperty("MaxWritePoolSize", IsRequired = false, DefaultValue = 5)]

public int MaxWritePoolSize

{

get

{

int _maxWritePoolSize = (int)base["MaxWritePoolSize"];

return _maxWritePoolSize > 0 ? _maxWritePoolSize : 5;

}

set

{

base["MaxWritePoolSize"] = value;

}

}

/// <summary>

/// 最大读链接数

/// </summary>

[ConfigurationProperty("MaxReadPoolSize", IsRequired = false, DefaultValue = 5)]

public int MaxReadPoolSize

{

get

{

int _maxReadPoolSize = (int)base["MaxReadPoolSize"];

return _maxReadPoolSize > 0 ? _maxReadPoolSize : 5;

}

set

{

base["MaxReadPoolSize"] = value;

}

}

/// <summary>

/// 自动重启

/// </summary>

[ConfigurationProperty("AutoStart", IsRequired = false, DefaultValue = true)]

public bool AutoStart

{

get

{

return (bool)base["AutoStart"];

}

set

{

base["AutoStart"] = value;

}

}

/// <summary>

/// 本地缓存到期时间，单位:秒

/// </summary>

[ConfigurationProperty("LocalCacheTime", IsRequired = false, DefaultValue = 36000)]

public int LocalCacheTime

{

get

{

return (int)base["LocalCacheTime"];

}

set

{

base["LocalCacheTime"] = value;

}

}

/// <summary>

/// 是否记录日志,该设置仅用于排查redis运行时出现的问题,如redis工作正常,请关闭该项

/// </summary>

[ConfigurationProperty("RecordeLog", IsRequired = false, DefaultValue = false)]

public bool RecordeLog

{

get

{

return (bool)base["RecordeLog"];

}

set

{

base["RecordeLog"] = value;

}

}

public static RedisConfigInfo GetConfigInfo()

{

RedisConfigInfo section = (RedisConfigInfo)ConfigurationManager.GetSection("RedisConfig");

return section;

}

public static RedisConfigInfo GetConfig(string sectionName)

{

RedisConfigInfo section = (RedisConfigInfo)ConfigurationManager.GetSection("RedisConfig");

if (section == null)

throw new ConfigurationErrorsException("Section " + sectionName + " is not found.");

return section;

}

}

}

RedisManager：redis操作类

public class RedisManager

{

private static RedisConfigInfo redisConfig = RedisConfigInfo.GetConfigInfo();

private static PooledRedisClientManager prcm;

static RedisManager()

{

CreateManager();

}

private static void CreateManager()

{

string[] writeServiceList = SplitString(redisConfig.WriteServerList, ",");

string[] readServiceList = SplitString(redisConfig.ReadServerList, ",");

prcm = new PooledRedisClientManager(readServiceList, writeServiceList, new RedisClientManagerConfig() { MaxWritePoolSize = redisConfig.MaxWritePoolSize, MaxReadPoolSize = redisConfig.MaxReadPoolSize, AutoStart = redisConfig.AutoStart });

}

public static IRedisClient GetClient()

{

if (prcm == null)

{

CreateManager();

}

return prcm.GetClient();

}

private static string[] SplitString(string strSource, string split)

{

return strSource.Split(split.ToArray());

}

#region -- Item --

/// <summary>

/// 设置单体

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="t"></param>

/// <param name="timeSpan"></param>

/// <returns></returns>

public static bool Item_Set<T>(string key, T t)

{

try

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.Set<T>(key, t, new TimeSpan(1, 0, 0));

}

}

catch (Exception ex)

{

// LogInfo

}

return false;

}

/// <summary>

/// 设置单体

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="t"></param>

/// <param name="timeSpan"></param>

/// <returns></returns>

public static bool Item_Set<T>(string key, T t, int timeout)

{

try

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.Set<T>(key, t, new TimeSpan(0, timeout, 0));

}

}

catch (Exception ex)

{

}

return false;

}

/// <summary>

/// 获取单体

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <returns></returns>

public static T Item_Get<T>(string key) where T : class

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.Get<T>(key);

}

}

/// <summary>

/// 移除单体

/// </summary>

/// <param name="key"></param>

public static bool Item_Remove(string key)

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.Remove(key);

}

}

/// <summary>

/// 设置缓存过期

/// </summary>

/// <param name="key"></param>

public static bool Item_SetExpire(string key, int timeout)

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.ExpireEntryIn(key, new TimeSpan(0, timeout, 0));

}

}

#endregion

#region -- List --

public static void List_Add<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient =redis.As<T>();

redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);

}

}

public static bool List_Remove<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient = redis.As<T>();

return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;

}

}

public static void List_RemoveAll<T>(string key)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient = redis.As<T>();

redisTypedClient.Lists[key].RemoveAll();

}

}

public static int List_Count(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

return (int)redis.GetListCount(key);

}

}

public static List<T> List_GetRange<T>(string key, int start, int count)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

var c = redis.As<T>();

return c.Lists[key].GetRange(start, start + count - 1);

}

}

public static List<T> List_GetList<T>(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

var c = redis.As<T>();

return c.Lists[key].GetRange(0, c.Lists[key].Count);

}

}

public static List<T> List_GetList<T>(string key, int pageIndex, int pageSize)

{

int start = pageSize * (pageIndex - 1);

return List_GetRange<T>(key, start, pageSize);

}

/// <summary>

/// 设置缓存过期

/// </summary>

/// <param name="key"></param>

/// <param name="datetime"></param>

public static void List_SetExpire(string key, DateTime datetime)

{

using (IRedisClient redis = prcm.GetClient())

{

redis.ExpireEntryAt(key, datetime);

}

}

#endregion

#region -- Set --

public static void Set_Add<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient = redis.As<T>();

redisTypedClient.Sets[key].Add(t);

}

}

public static bool Set_Contains<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient = redis.As<T>();

return redisTypedClient.Sets[key].Contains(t);

}

}

public static bool Set_Remove<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

var redisTypedClient = redis.As<T>();

return redisTypedClient.Sets[key].Remove(t);

}

}

#endregion

#region -- Hash --

/// <summary>

/// 判断某个数据是否已经被缓存

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="dataKey"></param>

/// <returns></returns>

public static bool Hash_Exist<T>(string key, string dataKey)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

return redis.HashContainsEntry(key, dataKey);

}

}

public static int Hash_GetCount(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

return (int)redis.GetHashCount(key);

}

}

/// <summary>

/// 存储数据到hash表

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="dataKey"></param>

/// <returns></returns>

public static bool Hash_Set<T>(string key, string dataKey, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);

return redis.SetEntryInHash(key, dataKey, value);

}

}

/// <summary>

/// 移除hash中的某值

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="dataKey"></param>

/// <returns></returns>

public static bool Hash_Remove(string key, string dataKey)

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.RemoveEntryFromHash(key, dataKey);

}

}

/// <summary>

/// 移除整个hash

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="dataKey"></param>

/// <returns></returns>

public static bool Hash_Remove(string key)

{

using (IRedisClient redis = prcm.GetClient())

{

return redis.Remove(key);

}

}

/// <summary>

/// 从hash表获取数据

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="dataKey"></param>

/// <returns></returns>

public static T Hash_Get<T>(string key, string dataKey)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

string value = redis.GetValueFromHash(key, dataKey);

return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);

}

}

/// <summary>

/// 获取整个hash的数据

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <returns></returns>

public static List<T> Hash_GetAll<T>(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

var list = redis.GetHashValues(key);

if (list != null && list.Count > 0)

{

List<T> result = new List<T>();

foreach (var item in list)

{

var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);

result.Add(value);

}

return result;

}

return null;

}

}

/// <summary>

/// 设置缓存过期

/// </summary>

/// <param name="key"></param>

/// <param name="datetime"></param>

public static void Hash_SetExpire(string key, DateTime datetime)

{

using (IRedisClient redis = prcm.GetClient())

{

redis.ExpireEntryAt(key, datetime);

}

}

#endregion

#region -- SortedSet --

/// <summary>

/// 添加数据到 SortedSet

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="t"></param>

/// <param name="score"></param>

public static bool SortedSet_Add<T>(string key, T t, double score)

{

using (IRedisClient redis = prcm.GetClient())

{

string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);

return redis.AddItemToSortedSet(key, value, score);

}

}

/// <summary>

/// 移除数据从SortedSet

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="t"></param>

/// <returns></returns>

public static bool SortedSet_Remove<T>(string key, T t)

{

using (IRedisClient redis = prcm.GetClient())

{

string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);

return redis.RemoveItemFromSortedSet(key, value);

}

}

/// <summary>

/// 修剪SortedSet

/// </summary>

/// <param name="key"></param>

/// <param name="size">保留的条数</param>

/// <returns></returns>

public static int SortedSet_Trim(string key, int size)

{

using (IRedisClient redis = prcm.GetClient())

{

return (int)redis.RemoveRangeFromSortedSet(key, size, 9999999);

}

}

/// <summary>

/// 获取SortedSet的长度

/// </summary>

/// <param name="key"></param>

/// <returns></returns>

public static int SortedSet_Count(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

return (int)redis.GetSortedSetCount(key);

}

}

/// <summary>

/// 获取SortedSet的分页数据

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="pageIndex"></param>

/// <param name="pageSize"></param>

/// <returns></returns>

public static List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);

if (list != null && list.Count > 0)

{

List<T> result = new List<T>();

foreach (var item in list)

{

var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);

result.Add(data);

}

return result;

}

}

return null;

}

/// <summary>

/// 获取SortedSet的全部数据

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="key"></param>

/// <param name="pageIndex"></param>

/// <param name="pageSize"></param>

/// <returns></returns>

public static List<T> SortedSet_GetListALL<T>(string key)

{

using (IRedisClient redis = prcm.GetReadOnlyClient())

{

var list = redis.GetRangeFromSortedSet(key, 0, 9999999);

if (list != null && list.Count > 0)

{

List<T> result = new List<T>();

foreach (var item in list)

{

var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);

result.Add(data);

}

return result;

}

}

return null;

}

/// <summary>

/// 设置缓存过期

/// </summary>

/// <param name="key"></param>

/// <param name="datetime"></param>

public static void SortedSet_SetExpire(string key, DateTime datetime)

{

using (IRedisClient redis = prcm.GetClient())

{

redis.ExpireEntryAt(key, datetime);

}

}

#endregion

}

2.mode="InProc"

这里配置不需要改，默认的就行

设置Cookies

public static string GetSessionID(HttpRequestBase request, HttpResponseBase response, bool IsReadOnly, int Timeout)

{

// Response.Cookies("MyCookie").Path = "/"

HttpCookie cookies = request.Cookies[SessionName];

if (cookies == null || string.IsNullOrEmpty(cookies.Value))

{

string newSessionID = Guid.NewGuid().ToString();

HttpCookie httpCookies = new HttpCookie(SessionName, newSessionID);

httpCookies.HttpOnly = IsReadOnly;

httpCookies.Path = "/";

httpCookies.Expires = DateTime.Now.AddMinutes(Timeout);

RedisManager.Hash_SetExpire(newSessionID, DateTime.Now.AddMinutes(Timeout));

response.AppendCookie(httpCookies);

return "Session_" + newSessionID;

}else

{

return "Session_" + cookies.Value;

}

3.mode="Custom"

3.1 RedisSessionStateStore类：

/// <summary>

/// 使用Cookie实现SessionStateStoreProviderBase

/// 注意：它只适合保存简单的基元类型数据。

/// </summary>

public class RedisSessionStateStore:SessionStateStoreProviderBase

{

public override SessionStateStoreData CreateNewStoreData(HttpContext context, int timeout)

{

return CreateLegitStoreData(context, null, null, timeout);

}

internal static SessionStateStoreData CreateLegitStoreData(HttpContext context, ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)

{

if (sessionItems == null)

sessionItems = new SessionStateItemCollection();

if (staticObjects == null && context != null)

staticObjects = SessionStateUtility.GetSessionStaticObjects(context);

return new SessionStateStoreData(sessionItems, staticObjects, timeout);

}

public override void CreateUninitializedItem(HttpContext context, string id, int timeout)

{

RedisSessionState state = new RedisSessionState(null, null, timeout);

RedisManager.Item_Set<string>(id, state.ToJson(), timeout);

}

private SessionStateStoreData DoGet(HttpContext context, string id, bool exclusive, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags)

{

locked = false;

lockId = null;

lockAge = TimeSpan.Zero;

actionFlags = SessionStateActions.None;

RedisSessionState state = RedisSessionState.FromJson(RedisManager.Item_Get<string>(id));

if (state == null)

{

return null;

}

RedisManager.Item_SetExpire(id, state._timeout);

return CreateLegitStoreData(context, state._sessionItems, state._staticObjects, state._timeout);

}

public override void Dispose()

{

}

public override void EndRequest(HttpContext context)

{

}

public override SessionStateStoreData GetItem(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags)

{

return this.DoGet(context, id, false, out locked, out lockAge, out lockId, out actionFlags);

}

public override SessionStateStoreData GetItemExclusive(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actionFlags)

{

return this.DoGet(context, id, true, out locked, out lockAge, out lockId, out actionFlags);

}

public override void InitializeRequest(HttpContext context)

{

}

public override void ReleaseItemExclusive(HttpContext context, string id, object lockId)

{

}

public override void RemoveItem(HttpContext context, string id, object lockId, SessionStateStoreData item)

{

RedisManager.Item_Remove(id);

}

public override void ResetItemTimeout(HttpContext context, string id)

{

}

public override void SetAndReleaseItemExclusive(HttpContext context, string id, SessionStateStoreData item, object lockId, bool newItem)

{

ISessionStateItemCollection sessionItems = null;

HttpStaticObjectsCollection staticObjects = null;

if (item.Items.Count > 0)

sessionItems = item.Items;

if (!item.StaticObjects.NeverAccessed)

staticObjects = item.StaticObjects;

RedisSessionState state2 = new RedisSessionState(sessionItems, staticObjects, item.Timeout);

RedisManager.Item_Set<string>(id, state2.ToJson(), item.Timeout);

}

public override bool SetItemExpireCallback(SessionStateItemExpireCallback expireCallback)

{

return true;

}

}

internal sealed class SessionStateItem

{

public Dictionary<string, object> Dict;

public int Timeout;

}

internal sealed class RedisSessionState

{

internal ISessionStateItemCollection _sessionItems;

internal HttpStaticObjectsCollection _staticObjects;

internal int _timeout;

internal RedisSessionState(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)

{

this.Copy(sessionItems, staticObjects, timeout);

}

internal void Copy(ISessionStateItemCollection sessionItems, HttpStaticObjectsCollection staticObjects, int timeout)

{

this._sessionItems = sessionItems;

this._staticObjects = staticObjects;

this._timeout = timeout;

}

public string ToJson()

{

// 这里忽略_staticObjects这个成员。

if (_sessionItems == null || _sessionItems.Count == 0)

{

return null;

}

Dictionary<string, object> dict = new Dictionary<string, object>(_sessionItems.Count);

string key;

NameObjectCollectionBase.KeysCollection keys = _sessionItems.Keys;

for (int i = 0; i < keys.Count; i++)

{

key = keys[i];

dict.Add(key, _sessionItems[key]);

}

SessionStateItem item = new SessionStateItem { Dict = dict, Timeout = this._timeout };

return JsonConvert.SerializeObject(item);

}

public static RedisSessionState FromJson(string json)

{

if (string.IsNullOrEmpty(json))

{

return null;

}

try

{

SessionStateItem item = JsonConvert.DeserializeObject<SessionStateItem>(json);

SessionStateItemCollection collections = new SessionStateItemCollection();

foreach (KeyValuePair<string, object> kvp in item.Dict)

{

collections[kvp.Key] = kvp.Value;

}

return new RedisSessionState(collections, null, item.Timeout);

}

catch

{

return null;

}

}

}

3.2 配置

<sessionState mode="Custom" customProvider="RedisSessionStateStore">

<providers>

<add name="RedisSessionStateStore" type="Custom_RedisSessionStateStore.RedisSessionStateStore"/>

</providers>

</sessionState>