博客园_net

mysql 备忘sql

2011-11-25T06:54:00Z

CREATE TABLE table1(SELECT ecuserid,id,PartnerType FROM table2
WHERE PartnerType=4 AND createdate BETWEEN '2011-09-23' AND '2011-10-10')

UPDATE ecuser_cooperationuser AS a
LEFT JOIN ecuser_customer b ON a.KubaUserId = b.EcUserId
SET b.PartnerType = 2
WHERE a.Platform='彩贝'

SELECT COUNT(0) AS '会员数',CASE UserLevelId WHEN 1 THEN '蜗居会员' WHEN 2 THEN '一居会员' WHEN 3 THEN '二居会员' WHEN 4 THEN '三居会员'
WHEN 5 THEN '四居会员' WHEN 6 THEN '复式楼会员' WHEN 7 THEN '别墅会员' END AS '会员级别'
FROM ecuser_customer GROUP BY UserLevelId

CREATE TABLE temp_badip (SELECT ip FROM (SELECT 用户名,MAX(登录时间) AS logintime,MAX(登录ip) AS ip,MAX(会员级别),COUNT(用户名) FROM ecuser_loginuser_201110211430
GROUP BY 用户名) AS t GROUP BY ip HAVING COUNT(*)>20)

本文链接

ActiveMQ 安装

2011-11-25T06:53:00Z

1、环境：

Windows XP

apache-activemq-5.2.0-bin.zip

2、安装（安装前需要有Java环境，先安装JDK）

解压缩到apache-activemq-5.2.0-bin.zip到一个目录，比如C:\apache-activemq-5.2.0

3、配置

配置就在C:\apache-activemq-5.2.0\conf目录下三个文件

activemq.xml

credentials.properties

log4j.properties

4、启动ActiveMQ

运行C:\apache-activemq-5.2.0\bin\activemq.bat

5、测试

ActiveMQ默认使用的TCP连接端口是61616, 通过查看该端口的信息可以测试ActiveMQ是否成功启动 netstat -an|find "61616"

C:\Documents and Settings\Administrator>netstat -an|find "61616"
TCP 0.0.0.0:61616 0.0.0.0:0 LISTENING

6、监控

ActiveMQ5.0版本默认启动时，启动了内置的jetty服务器，提供一个demo应用和用于监控ActiveMQ的admin应用。
admin：http://127.0.0.1:8161/admin/
demo：http://127.0.0.1:8161/demo/

本文链接

【转】j2ee 环境搭建

2011-11-25T06:53:00Z

一。jdk安装与配置
jdk7于3月份刚刚发布，目前eclipse的最新版本中还没有提供对jdk7的编译支持，所以我们只下载jdk6。

下载地址：http://download.java.net/jdk6/

选择适合平台的安装文件，windows32下目前最新版本为：jdk-6u25-ea-bin-b03-windows-i586-27_feb_2011.exe

默认安装即可，安装完成后要配置环境变量。

比如，我的安装目录为：C:\Program Files\Java\jdk1.6。

环境变量配置如下：

XP系统下，右击“我的电脑”--选择“属性”--选择“高级”--点击“环境变量”

在“系统变量(S)”中

新建：JAVA_HOME：C:\Program Files\Java\jdk1.6

新建：CLASS_PATH：.;%JAVA_HOME%\lib

编辑：PATH：在最前面加上%JAVA_HOME%\bin;

创建环境变量后，打开cmd，输入“java -version”验证是否安装成功。

Java code: C:\Documents and Settings\user>java -version java version "1.5.0_11" Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_11-b03) Java HotSpot(TM) Client VM (build 1.5.0_11-b03, mixed mode, sharing)

二。tomcat 安装与配置

tomcat的官方网站：http://tomcat.apache.org/

目前最新版本为7.0，

windows32下目前最新版本下载地址：http://labs.renren.com/apache-mirror/tomcat/tomcat-7/v7.0.11/bin/apache-tomcat-7.0.11-windows-x86.zip

此为解压缩版，下载后解压缩即可，tomcat是需要jdk才能运行的，如果我们配置好了jdk环境变量，那么tomcat会自动从环境变量中读取jdk信息，无需特别的配置。

比如，我们将tomcat解压缩后的目录为：F:\apache-tomcat-7.0.11-windows-x86\apache-tomcat-7.0.11（以下简称%TOMCAT_HOME%）

进入%TOMCAT_HOME%/bin，双击“startup.bat”启动tomcat，如果tomcat正常启动，我们访问“http://localhost:8080/”即可打开tomcat管理页面。

双击“shutdown.bat”，即可关闭tomcat。

管理账户配置：

进入%TOMCAT_HOME%/conf，编辑“tomcat-users.xml”，

因为是开发环境，所以这里我们配置一个超级用户admin ，使其能够管理tomcat，编辑后的内容如下：

Java code: <?xml version='1.0' encoding='utf-8'?><tomcat-users><role rolename="manager-gui"/><role rolename="admin-gui"/><user username="admin" password="admin" roles="manager-gui,admin-gui"/></tomcat-users>

重新启动tomcat，之后就可以使用admin账户对tomcat进行管理了，这里只说明如何配置账户，关于如何使用界面管理tomcat暂不做叙述，具体参考tomcat帮助文档吧，主要原因是在开发环境下几乎用不到这个功能，而且我比较推荐手工配置。

三。eclipse 安装与配置
eclipse的官网地址：http://www.eclipse.org/

我们下载J2EE版本：Eclipse IDE for Java EE Developers

目前最新版本是：Helios Service Release 2

windows32 版本的下载地址：http://www.eclipse.org/downloads/download.php?file=/technology /epp/downloads/release/helios/SR2/eclipse-jee-helios-SR2-win32.zip

此版本为解压缩版本。

比如我们解压缩后的eclipse的路径为：F:\eclipse-jee-helios-SR2-win32\eclipse（以下简称%ECLIPSE_HOME%）

如果我们配置了jdk环境变量，进入%ECLIPSE_HOME%后，双击“eclipse.exe”，即可启动eclipse，启动时会提示你选择一个workspace。

这里建议大家多创建一些workspace，可以根据实际的需要将不同的project创建在不同的workspace中，以免日后workspace中的 project越来越多，影响eclipse的启动速度（当然，对于近期不使用的project建议将其关闭--右键单击项目名称选择"Close Project"，如果需要开启项目，则右键单击关闭的项目名称选择"Open Project"即可。）。

切换workspace可以在启动是进行选择，也可以等启动后在“File”--"Switch Workapsce"中进行切换。

关于eclipse对workspace的管理也可以参考“http://www.iteye.com/blog/868197 ”。

第一次启动eclipse后，我们需要做一些基本的配置，通常我们需要做如下配置：

1）配置jdk

默认情况下，eclipse会自动关联环境变量中配置的jdk，如果我们安装了多个版本的jdk，也可以手工进行配置，方法如下：

“Window”--"Preferences"--"Java"--"Installed JREs"--“Add”--"Standard VM"--选择jdk安装目录。

2）配置tomcat

“Window”--"Preferences"--"Server"--"Runtime Environments"--“Add”--"Apache"--"Apache Tomcat v7.0"--选择tomcat7的目录，在JRE中选择1）中配置的jdk即可。

配置完成，可以 “Servers”视图中进行验证。默认“Servers”视图”在“Java EE”预设视图的下方是开启的，如果没有开启，可以通过“Window”--"Show View"--“Server”--选择Servers即可打开“Servers”视图。

在“Servers”视图中，右键单击--“New”--"Server"--选择“Tomcat v7.0 Server”，如果在“Server runtime environment”中看到"Apache Tomcat v7.0"，则说明配置成功。

3）启动提速

eclipse启动时会默认加载一些插件，而加载这些插件会增加eclipse的启动时间，实际上有些东东对我们来说并没有什么用，所以可以关闭，方法如下：

“Window”--"Preferences"--“General”--"Startup and Shutdown"--去掉你不想要的插件即可。

4）关闭验证

默认eclipse会对workspace中的项目进行验证，验证的内容包括jsp内容、xml内容，等等，验证过程很消耗内存，所以建议关闭验证功能。关闭方法如下：

“Window”--"Preferences"--“Validation”--"Disable All"。

5）设置“新建”菜单项

eclipse默认的新建内容并不满足需求，好多内容还需要到other中去找，不过我们可以自定义新建菜单项中的内容，方法如下：

右键单击工具栏--“Customize Prespective...”--"Shortcuts"--选择你需要的新建项即可。

6）默认文件编辑器

eclipse默认会自动选择文件的编辑器，也可以在打开文件时右键单击文件--“Open With”中选择编辑器，但有时我们可能更希望让文件使用某种特定的编辑器，此时可以通过如下方法进行配置：

“Window”--"Preferences"--“General”--“Editors”--"File Associations"，上方选择特定的文件名后缀类型，下面选择编辑器，可以通过Add进行添加，通过Default设置默认编辑器。

7）注释风格定义

相信大家都知道注释的重要性，在团队中，统一注释风格更为重要。设置注释风格方法如下：

“Window”--"Preferences"--"Java"--"Code Style"--“Code Templates”--根据需要自己设置吧

比如Comments中

Types：

Java code: /** * * <一句话功能简述> * <功能详细描述> * * @author user * @version [版本号, Aug 29, 2011] * @see [相关类/方法] * @since [产品/模块版本] */

Methods：

Java code: /** * <一句话功能简述> * <功能详细描述> * @param args [参数说明] * * @return void [返回类型说明] * @exception throws [违例类型] [违例说明] * @see [类、类#方法、类#成员] */

可以通过“Alt+Shift+j”自动添加注释。

四。eclipse常用插件安装
之所以eclipse这么受欢迎，原因就是其拥有众多的插件作为支持，这里只介绍几个常用的插件。

1）svn插件

可能有些人更喜欢“小乌龟”，不过这里还是推荐安装svn的eclipse插件。

官方地址：http://subclipse.tigris.org/

目前最新版本是1.6.17

Eclipse update site URL: http://subclipse.tigris.org/update_1.6.x
Zipped downloads: http://subclipse.tigris.org/servlets/ProjectDocumentList?folderID=2240

插件安装方法如下：

“help”--“Install new software”--“add”

name:svn_subclipse

Location:http://subclipse.tigris.org/update_1.6.x

点击“OK”后，只选择“Subclipse”，

点击“next”，accept后点击finish开始安装。安装完成后会提示重启eclipse。

重启eclipse后，在“Window”--"Show View"--"Other"--"SVN"中选择“SVN资源库”，即可打开“SVN资源库”视图。

在视图中右键单击--“新建”--“资源库位置”--输入地址--Finish即可。

本文链接

C#原始类型扩展方法—this参数修饰符

2011-11-25T06:53:00Z

[转]C#原始类型扩展方法—this参数修饰符

扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。对于用 C# 和 Visual Basic 编写的客户端代码，调用扩展方法与调用在类型中实际定义的方法之间没有明显的差异。

扩展方法被定义为静态方法，但它们是通过实例方法语法进行调用的。它们的第一个参数指定该方法作用于哪个类型，并且该参数以 this 修饰符为前缀。仅当您使用 using 指令将命名空间显式导入到源代码中之后，扩展方法才位于范围中。

下面的示例演示为 System.String 类定义的一个扩展方法。请注意，它是在非嵌套、非泛型静态类内部定义的：

1namespace ExtensionMethods
2 {
3publicstaticclass MyExtensions
4 {
5publicstaticint WordCount(this String str)
6 {
7return str.Split(newchar[] { '', '.', '?' }, StringSplitOptions.RemoveEmptyEntries).Length;
8 }
9 }
10 }

可使用以下 using 指令将 WordCount 扩展方法放入范围中：
　　using ExtensionMethods;
　　而且，可以在应用程序中使用以下语法对该扩展方法进行调用：
　　string s = "Hello Extension Methods";
　　int i = s.WordCount();

　　在代码中，可以使用实例方法语法调用该扩展方法。但是，编译器生成的中间语言 (IL) 会将代码转换为对静态方法的调用。因此，并未真正违反封装原则。实际上，扩展方法无法访问它们所扩展的类型中的私有变量。

定义和调用扩展方法：
　1、定义一个静态类以包含扩展方法。该类必须对客户端代码可见。有关可访问性规则的更多信息，请参见访问修饰符（C# 编程指南）。
　2、将该扩展方法实现为静态方法，并使其至少具有与包含类相同的可见性。
　3、该方法的第一个参数指定方法所操作的类型；该参数必须以 this 修饰符开头。
　4、在调用代码中，添加一条 using 指令以指定包含扩展方法类的命名空间。
　5、按照与调用类型上的实例方法一样的方式调用扩展方法。
　　请注意，第一个参数不是由调用代码指定的，因为它表示正应用运算符的类型，并且编译器已经知道对象的类型。您只需通过 n 为这两个形参提供实参。

示例
　　下面的示例在 MyExtensions.StringExtension 类中实现了一个名为 WordCount 的扩展方法。该方法对 String 类进行操作，而该类被指定为第一个方法参数。MyExtensions 命名空间被导入到应用程序命名空间中，并且该方法是在 Main 方法内调用的。

1 using System.Linq;
2 using System.Text;
3 using System;
4
5 namespace CustomExtensions
6 {
7 //Extension methods must be defined in a static class
8 publicstaticclass StringExtension
9 {
10 // This is the extension method.
11 // The first parameter takes the "this" modifier
12 // and specifies the type for which the method is defined.
13 publicstaticint WordCount(this String str)
14 {
15 return str.Split(newchar[] {'', '.','?'}, StringSplitOptions.RemoveEmptyEntries).Length;
16 }
17 }
18 }
19 namespace Extension_Methods_Simple
20 {
21 //Import the extension method namespace.
22 using CustomExtensions;
23 class Program
24 {
25 staticvoid Main(string[] args)
26 {
27 string s ="The quick brown fox jumped over the lazy dog.";
28 // Call the method as if it were an
29 // instance method on the type. Note that the first
30 // parameter is not specified by the calling code.
31 int i = s.WordCount();
32 System.Console.WriteLine("Word count of s is {0}", i);
33 }
34 }
35 }

本文链接

消息队列（Message Queue）简介及其使用

2011-11-25T06:53:00Z

利用 MSMQ（Microsoft Message Queue），应用程序开发人员可以通过发送和接收消息方便地与应用程序进行快速可靠的通信。消息处理为您提供了有保障的消息传递和执行许多业务处理的可靠的防故障方法。

MSMQ与XML Web Services和.Net Remoting一样，是一种分布式开发技术。但是在使用XML Web Services或.Net Remoting组件时，Client端需要和Server端实时交换信息，Server需要保持联机。MSMQ则可以在Server离线的情况下工作，将Message临时保存在Client端的消息队列中，以后联机时再发送到Server端处理。

显然，MSMQ不适合于Client需要Server端及时响应的这种情况，MSMQ以异步的方式和Server端交互，不用担心等待Server端的长时间处理过程。

虽然XML Web Services和.Net Remoting都提供了[OneWay]属性来处理异步调用，用来解决Server端长方法调用长时间阻碍Client端。但是不能解决大量Client负载的问题，此时Server接受的请求快于处理请求。

一般情况下，[OneWay]属性不用于专门的消息服务中。

1. 基本术语和概念（Basic terms and concepts）

“消息”是在两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串；也可以更复杂，可能包含嵌入对象。

消息被发送到队列中。“消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。

“消息队列”是 Microsoft 的消息处理技术，它在任何安装了 Microsoft Windows 的计算机组合中，为任何应用程序提供消息处理和消息队列功能，无论这些计算机是否在同一个网络上或者是否同时联机。

“消息队列网络”是能够相互间来回发送消息的任何一组计算机。网络中的不同计算机在确保消息顺利处理的过程中扮演不同的角色。它们中有些提供路由信息以确定如何发送消息，有些保存整个网络的重要信息，而有些只是发送和接收消息。

“消息队列”安装期间，管理员确定哪些服务器可以互相通信，并设置特定服务器的特殊角色。构成此“消息队列”网络的计算机称为“站点”，它们之间通过“站点链接”相互连接。每个站点链接都有一个关联的“开销”，它由管理员确定，指示了经过此站点链接传递消息的频率。

“消息队列”管理员还在网络中设置一台或多台作为“路由服务器”的计算机。路由服务器查看各站点链接的开销，确定经过多个站点传递消息的最快和最有效的方法，以此决定如何传递消息。

2. 队列类型（Queue Type）

有两种主要的队列类型：由您或网络中的其他用户创建的队列和系统队列。

用户创建的队列可能是以下任何一种队列：

“公共队列”在整个“消息队列”网络中复制，并且有可能由网络连接的所有站点访问。

“专用队列”不在整个网络中发布。相反，它们仅在所驻留的本地计算机上可用。专用队列只能由知道队列的完整路径名或标签的应用程序访问。

“管理队列”包含确认在给定“消息队列”网络中发送的消息回执的消息。指定希望 MessageQueue 组件使用的管理队列（如果有的话）。

“响应队列”包含目标应用程序接收到消息时返回给发送应用程序的响应消息。指定希望 MessageQueue 组件使用的响应队列（如果有的话）。

系统生成的队列一般分为以下几类：

“日记队列”可选地存储发送消息的副本和从队列中移除的消息副本。每个“消息队列”客户端上的单个日记队列存储从该计算机发送的消息副本。在服务器上为每个队列创建了一个单独的日记队列。此日记跟踪从该队列中移除的消息。

“死信队列”存储无法传递或已过期的消息的副本。如果过期或无法传递的消息是事务性消息，则被存储在一种特殊的死信队列中，称为“事务性死信队列”。死信存储在过期消息所在的计算机上。有关超时期限和过期消息的更多信息，请参见默认消息属性。

“报告队列”包含指示消息到达目标所经过的路由的消息，还可以包含测试消息。每台计算机上只能有一个报告队列。

“专用系统队列”是一系列存储系统执行消息处理操作所需的管理和通知消息的专用队列。

在应用程序中进行的大多数工作都涉及访问公共队列及其消息。但是，根据应用程序的日记记录、确认和其他特殊处理需要，在日常操作中很可能要使用几种不同的系统队列。

3. 同步和异步通信（Synchronous VS. Asynchronous Communication）

队列通信天生就是异步的，因为将消息发送到队列和从队列中接收消息是在不同的进程中完成的。另外，可以异步执行接收操作，因为要接收消息的人可以对任何给定的队列调用 BeginReceive 方法，然后立即继续其他任务而不用等待答复。这与人们所了解的“同步通信”截然不同。

在同步通信中，请求的发送方在执行其他任务前，必须等待来自预定接收方的响应。发送方等待的时间完全取决于接收方处理请求和发送响应所用的时间。

4. 同消息队列交互（Interacting with Message Queues）

消息处理和消息为基于服务器的应用程序组件之间的进程间通信提供了强大灵活的机制。同组件间的直接调用相比，它们具有若干优点，其中包括：

稳定性 — 组件失败对消息的影响程度远远小于组件间的直接调用，因为消息存储在队列中并一直留在那里，直到被适当地处理。消息处理同事务处理相似，因为消息处理是有保证的。
消息优先级 — 更紧急或更重要的消息可在相对不重要的消息之前接收，因此可以为关键的应用程序保证足够的响应时间。
脱机能力 — 发送消息时，它们可被发送到临时队列中并一直留在那里，直到被成功地传递。当因任何原因对所需队列的访问不可用时，用户可以继续执行操作。同时，其他操作可以继续进行，如同消息已经得到了处理一样，这是因为网络连接恢复时消息传递是有保证的。
事务性消息处理 — 将多个相关消息耦合为单个事务，确保消息按顺序传递、只传递一次并且可以从它们的目标队列中被成功地检索。如果出现任何错误，将取消整个事务。
安全性 — MessageQueue 组件基于的消息队列技术使用 Windows 安全来保护访问控制，提供审核，并对组件发送和接收的消息进行加密和验证。

5. 在.Net环境下编写简单的Message Queue程序

（1）先安装Message Queuing Services

通过Control Panel，“Add/Remove Programs” – “Add/Remove Windows Components”步骤安装MSMQ。

MSMQ可以安装为工作组模式或域模式。如果安装程序没有找到一台运行提供目录服务的消息队列的服务器，则只可以安装为工作组模式，此计算机上的“消息队列”只支持创建专用队列和创建与其他运行“消息队列”的计算机的直接连接。

（2）配置MSMQ

打开Computer Management – Message Queuing，在Private Queues下创建MSMQDemo队列

（3）编写代码－简单演示MSMQ对象

MessageQueue 类是“消息队列”周围的包装。MessageQueue 类提供对“消息队列”队列的引用。可以在 MessageQueue 构造函数中指定一个连接到现有资源的路径，或者可在服务器上创建新队列。在调用 Send、Peek 或 Receive 之前，必须将 MessageQueue 类的新实例与某个现有队列关联。

MessageQueue 支持两种类型的消息检索：同步和异步。同步的 Peek 和 Receive 方法使进程线程用指定的间隔时间等待新消息到达队列。异步的 BeginPeek 和 BeginReceive 方法允许主应用程序任务在消息到达队列之前，在单独的线程中继续执行。这些方法通过使用回调对象和状态对象进行工作，以便在线程之间进行信息通讯。

// Send Message

private void btnSendMessage_Click(object sender, System.EventArgs e)

{

// Open queue

System.Messaging.MessageQueue queue = new System.Messaging.MessageQueue(".\\Private$\\MSMQDemo");

// Create message

System.Messaging.Message message = new System.Messaging.Message();

message.Body = txtMessage.Text.Trim();

message.Formatter = new System.Messaging.XmlMessageFormatter(new Type[] {typeof(string)});

// Put message into queue

queue.Send(message);

}

// Receive Message

private void btnReceiveMessage_Click(object sender, System.EventArgs e)

{

// Open queue

System.Messaging.MessageQueue queue = new System.Messaging.MessageQueue(".\\Private$\\MSMQDemo");

// Receive message, 同步的Receive方法阻塞当前执行线程，直到一个message可以得到

System.Messaging.Message message = queue.Receive();

message.Formatter = new System.Messaging.XmlMessageFormatter(new Type[] {typeof(string)});

txtReceiveMessage.Text = message.Body.ToString();

}

MSMQ是微软消息队列的英文缩写。关于消息队列的定义在网上有相关资料，这里不在过多的解释。

一、MSMQ介绍和安装消息队列

使用消息队列的优点：稳定、消息优先级、脱机能力以及安全性。

消息队列分为用户创建的队列(专用队列)和系统队列，用户队列分为，。我是Windows XP,看下图所示(myQueue为自己创建的消息队列,msmqtriggersnotifiations为通用队列)：

对消息队列有了简单的了解后，使用MSMQ进行软件开发需要安装MSMQ，安装完后就该进入实际的开发阶段。具体的安装过程就是在控制面板里“添加/删除程序”下“添加/删除Windows组件”，完成添加就OK。安装完成后就可以通过交互界添加新的消息队列，详细如下图：

出了上面这种交互界面来创建MSMQ外，也可以通过编程来完成，.NET框架里的MessageQueue类下有一静态方法Create，用来完成消息队列的创建，其定义如下：

1//
2// 摘要:
3//    在指定的路径中创建非事务性“消息队列”队列。
4//
5// 参数:
6//   path:
7//     要创建的队列的路径。
8//
9// 返回结果:
10//     表示新队列的 System.Messaging.MessageQueue。
11public static MessageQueue Create(string path);
12//
13// 摘要:
14//     在指定的路径中创建事务性或非事务性“消息队列”队列。
15//
16// 参数:
17//   transactional:
18//     如果创建事务性队列，为 true；如果创建非事务性队列，则为 false。
19//
20//   path:
21//     要创建的队列的路径。
22//
23// 返回结果:
24//     表示新队列的 System.Messaging.MessageQueue。
25public static MessageQueue Create(string path, bool transactional);

实现消息队列的创建简单代码(C#)，创建一个名为"myQueue"的非事务性"消息队列"，如下：

　MessageQueue.Create(@".\private$\myQueue");

二、创建、删除和管理队列

在.NET环境下编写Message Queue程序的前提就是需要先安装MSMQ，本文之前已经作了详细的介绍。要开发MSMQ程序就必须学习一个很重要的类(MessageQueue)，该类位于名称空间System.Messageing下。其中有几个常用的方法必须掌握：

--Create方法:创建使用指定路径的新消息队列。

--Delete方法：删除现有的消息队列。

--Existe方法：查看指定消息队列是否存在。

--GetAllMessages()方法:得到队列中的所有消息。

--GetPublicQueues方法：在“消息队列”网络中定位消息队列。

--Peek/BeginPeek方法：查看某个特定队列中的消息队列，但不从该队列中移出消息。

--Receive/BeginReceive方法：检索指定消息队列中最前面的消息并将其从该队列中移除。

--Send方法：发送消息到指定的消息队列。

--Purge方法：清空指定队列的消息。

上述列举的方法在此就不作详细介绍，大家可以通过下面的示例程序中来体会他们各自的功能。

三、发送和序列化消息

MSMQ消息队列中定义的消息由一个主体(body)和若干属性构成。消息的主体可以由文本、二进制构成，根据需要还可以被加密。在MSMQ 中消息的大小不能够超过4MB。发送消息是通过Send方法来完成的，需要一个Message参数。

1、发送消息：

步骤：连接队列-->指定消息格式-->提供要发送的数据(主体)-->调用Send()方法将消息发送出去。详细见后面的示例程序。

2、序列化消息：

消息序列化可以通过.NET Framework附带的三个预定义格式化程序来完成：

-- XMLMessageFormatter对象----MessageQueue组件的默认格式化程序设置。

-- BinaryMessageFormatter对象;

-- ActiveXMessageFormatter对象;

由于后两者格式化后的消息通常不能为人阅读，所以我们经常用到的是XMLMessageFormatter对象。该对象构造方法有三种重载：

1public XmlMessageFormatter();
　　2public XmlMessageFormatter(string[] targetTypeNames);
　　3public XmlMessageFormatter(Type[] targetTypes);

如我们后面的示例程序中用到的序列化语句：

1//序列化为字符串
2XmlMessageFormatter formatter = new XmlMessageFormatter(new Type[] { typeof(string) });

四、读取和接收消息

1、读取消息：

也就是从指定队列中获取消息，详细请查看本文前面的关于消息操作的方法介绍。

2、接收消息有两种方式：

--> 通过Receive方法--具体功能请返回本文前面有详细介绍。

--> 通过Peek方法--具体功能请返回本文前面有详细介绍。

五、消息使用实例

通过上面一系列的介绍，了解了MessageQueue类和常用的方法后，下面我们通过一个简单的示例程序来分析消息队列的创建、发送消息以及接收消息等相关知识点：

1、通过Create方法创建使用指定路径的新消息队列

1/**//// <summary>
2/// 通过Create方法创建使用指定路径的新消息队列
3/// </summary>
4/// <param name="queuePath"></param>
5public static void Createqueue(string queuePath)
6{
7    try
8    {
9        if (!MessageQueue.Exists(queuePath))
10        {
11            MessageQueue.Create(@".\private$\myQueue");
12        }
13        else
14        {
15            Console.WriteLine(queuePath + "已经存在！");
16        }
17    }
18    catch (MessageQueueException e)
19    {
20        Console.WriteLine(e.Message);
21    }
22}

2、连接消息队列并发送消息到队列

1/**//// <summary>
2/// 连接消息队列并发送消息到队列
3/// </summary>
4public static void SendMessage()
5{
6    try
7    {
8        //连接到本地的队列
9        MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
10
11        Message myMessage = new Message();
12        myMessage.Body = "消息内容";
13        myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
14        //发送消息到队列中
15        myQueue.Send(myMessage);
16    }
17    catch (ArgumentException e)
18    {
19        Console.WriteLine(e.Message);
20    }
21}

3、连接消息队列并从消息队列中接收消息

1/**//// <summary>
2/// 连接消息队列并从队列中接收消息
3/// </summary>
4public static void ReceiveMessage()
5{
6    //连接到本地队列
7    MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
8    myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
9    try
10    {
11        //从队列中接收消息
12        Message myMessage = myQueue.Receive();
13        string context = (string)myMessage.Body; //获取消息的内容
14        Console.WriteLine("消息内容为：" + context);
15    }
16    catch (MessageQueueException e)
17    {
18        Console.WriteLine(e.Message);
19    }
20    catch (InvalidCastException e)
21    {
22        Console.WriteLine(e.Message);
23    }
24}

4、连接队列并清空队列的全部消息

1/**//// <summary>
2/// 清空指定队列的消息
3/// </summary>
4public static void ClearMessage()
5{
6 MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
7 myQueue.Purge();
8}

5、连接队列并获取队列的全部消息

1/**//// <summary>
2/// 连接队列并获取队列的全部消息
3/// </summary>
4public static void GetAllMessage()
5{
6    //连接到本地队列
7    MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
8    Message[] message = myQueue.GetAllMessages();
9    XmlMessageFormatter formatter = new XmlMessageFormatter(new Type[] { typeof(string) });
10    for (int i = 0; i < message.Length; i++)
11    {
12        message[i].Formatter = formatter;
13        Console.WriteLine(message[i].Body.ToString());
14    }
15}

上面依次的列举出来5个方法，这里我就不做测试了。上述方法全部通过测试的。

六、复杂消息发送实例

通过上面一系列的介绍，对于简单消息的发送和接收及消息的管理应该都不会有什么问题了，下面我在介绍一下关于复杂的消息处理，现在有这样一个需求，要求通过消息队列将一本图书信息发送到队列里，然后从消息队列里读取出来。图书的基本信息包括图书编号、图书名称、图书作者以及图书定价，这样的一个复杂的对象类型怎么来传输呢?详细如下：

1namespace MSMQ.App
2{
3    public class MsgQueue
4    {
5        /**//// <summary>
6        /// 通过Create方法创建使用指定路径的新消息队列
7        /// </summary>
8        /// <param name="queuePath"></param>
9        public static void Createqueue(string queuePath)
10        {
11            try
12            {
13                if (!MessageQueue.Exists(queuePath))
14                {
15                    MessageQueue.Create(@".\private$\myQueue");
16                    MessageBox.Show("创建队列成功！");
17                }
18                else
19                {
20                    MessageBox.Show(queuePath + "已经存在！");
21                }
22            }
23            catch (MessageQueueException e)
24            {
25                MessageBox.Show(e.Message);
26            }
27        }
28
29        /**//// <summary>
30        /// 连接消息队列并发送消息到队列
31        /// </summary>
32        public static bool SendMessage(Book book)
33        {
34            bool flag = false;
35            try
36            {
37                //连接到本地的队列
38                MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
39
40                System.Messaging.Message myMessage = new System.Messaging.Message();
41                myMessage.Body = book;
42                myMessage.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQ.App.Book) });
43                //发送消息到队列中
44                myQueue.Send(myMessage);
45                flag = true;
46            }
47            catch (ArgumentException e)
48            {
49                MessageBox.Show(e.Message);
50            }
51            return flag;
52        }
53
54        /**//// <summary>
55        /// 连接消息队列并从队列中接收消息
56        /// </summary>
57        public static string ReceiveMessage()
58        {
59            //连接到本地队列
60            MessageQueue myQueue = new MessageQueue(".\\private$\\myQueue");
61            myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(MSMQ.App.Book) });
62            try
63            {
64                //从队列中接收消息
65                System.Messaging.Message myMessage = myQueue.Receive();
66                Book book = (Book)myMessage.Body; //获取消息的内容
67                return string.Format("编号：{0},书名：{1},作者：{2},定价：{3}",
68                    book.BookId,
69                    book.BookName,
70                    book.BookAuthor,
71                    book.BookPrice);
72            }
73            catch (MessageQueueException e)
74            {
75                MessageBox.Show(e.Message);
76            }
77            catch (InvalidCastException e)
78            {
79                MessageBox.Show(e.Message);
80            }
81            return null;
82        }
83    }
84}

其实发送复杂的消息也就是在消息序列化上有些差别，别的地方与发送普通文本消息没什么大的变化，上面类里提供了创建队列，发送消息到队列，从队列获取消息三个方法，测试结果如下：

上述中，完成了一个复杂类型的消息发送到队列及从队列中读取的示例。

下面啰嗦哈消息队列的路径配置的问题(即上面的类中的path参数)：偷了个懒，哈哈

举个简单的例子来说明哈吧:

view plain

//本机消息队列
/*公共队列，消息队列名为myQueue*/
./myQueue
/*专用队列，消息队列名为myQueue*/
./private$/myQueue
/*Format格式，计算机名为zhang，消息队列名为myQueue*/
FormatName:DIRECT=OS:zhang/Private$/myQueue
//远程消息队列
/*配置为Ip为192.168.101.130的服务器的专用消息队列，队列名为myQueue*/
FormatName:DIRECT=TCP:192.168.101.130/Private$/myQueue

OK，下面的小demo来测试哈我们的消息队列是否可用：

view plain

class Order
{
public string Id { get; set; }
public DateTime Time { get; set; }
}
class Program
{
string path="FormatName:DIRECT=OS:zhang/Private$/myQueue";//队列路径
int timeout=20;//超时时间
Queue mq = new Queue(path,timeout);//生成消息队列对象
static void Main(string[] args)
{
Program p = new Program();
p.SendQueue();
p.Recive();
}
void SendQueue()
{
Order o = new Order
{
Id = "123456",
Time = DateTime.Now
};
mq.Send(o, MessageQueueTransactionType.Automatic);
}
void Recive()
{
Message m = mq.Receive();
Order o = (Order)m.Body;
Console.WriteLine(o.Id);
}
}

本文链接

IE中同一个url第二次AJAX调用无法触发onreadystatechange事件

2011-11-25T06:53:00Z

如果第二次通过XMLHttpRequest去请求一个URL，则不会触发onreadystatechange时间，虽然从调试插件来看，ie是进行了这次请求。

后来发现，这个是因为在ie下，如果请求的URL已经被浏览器cache，则调用send方法以后，xhr的readyState已经成为了4，即一开始就是请求完成的状态，当然以后readystate不会再被赋值，也不会触发onreadystatechange事件。

解决办法：在调用send后立即检查xhr的readystate，如果已经结束，则直接处理，不必再等待onreadystatechange事件。

getJSON : function(url, callback, onerror) { // 处理ajax get请求
var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
onerror = $X.isFunction(onerror) ? onerror : null;
xhr.open('GET', url, true);
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
xhr.send();
var f = function() {
if (xhr.readyState == 4) {
if (xhr.status == 200) {
try {
var data = eval('('+xhr.responseText+')');
} catch (e){
onerror && onerror(); // 处理json解析错误
xhr = null;
return;
};
callback(data);
} else {
onerror && onerror();
}
xhr = null; // fix memory leaks
}
};
if (xhr.readyState == 4) { // for the stupid ie
f();
} else {
xhr.onreadystatechange = f;
}
}

http://www.iteye.com/topic/467019

本文链接

Web Service 身份验证

2011-11-25T06:53:00Z

转自：http://www.cnblogs.com/Andy_Qin/archive/2009/08/04/1538844.html

解决方案一：通过通过SOAP Header身份验证。

1.我们实现一个用于身份验证的类，文件名MySoapHeader.cs

MySoapHeader类继承自 System.Web.Services.Protocols.SoapHeader。且定义了两个成员变量，UserName和PassWord，还定义了一个用户认证的函数ValideUser。它提供了对UserName和PassWord检查的功能

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.Services;
using System.Web.Services.Protocols;
/// <summary>
///MySoapHeader 的摘要说明
/// </summary>
public class MySoapHeader:SoapHeader
{
    public MySoapHeader()
    {
        //
        //TODO: 在此处添加构造函数逻辑
        //
    }
    public string UserName;
    public string PassWord;
    public bool ValideUser(string in_UserName, string in_PassWord)
    {
        if ((in_UserName == "zxq") && (in_PassWord == "123456"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

2.下面我们创建WebService.asmx WebService.cs代码如下:

using System;
using System.Collections;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;

/// <summary>
///WebService 的摘要说明
/// </summary>
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class WebService : System.Web.Services.WebService
{

    public WebService()
    {

        //如果使用设计的组件，请取消注释以下行
        //InitializeComponent();
    }
    public MySoapHeader header; ////定义用户身份验证类变量header
    [WebMethod(Description = "用户验证测试")]
    [System.Web.Services.Protocols.SoapHeader("header")]//用户身份验证的soap头
    public string HelloWorld(string contents)
    {
        //验证是否有权访问
        if (header.ValideUser(header.UserName, header.PassWord))
        {
            return contents + "执行了";
        }
        else
        {
            return "您没有权限访问";
        }
    }
}

3.客户端创建个Default.aspx

Default.aspx .cs代码

using System;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        com.cn1yw.WebService test = new com.cn1yw.WebService();//web引用(改成您自己的)
        com.cn1yw.MySoapHeader Header = new com.cn1yw.MySoapHeader();//web引用创建soap头对象(改成您自己的)
        //设置soap头变量
        Header.UserName = "zxq";
        Header.PassWord = "123456";
        test.MySoapHeaderValue = Header;
        //调用web 方法
        Response.Write(test.HelloWorld("我是强"));
    }
}

解决方案二：通过集成windows身份验证。

1. 将web服务程序设为集成windows身份验证

2.客户端web引用代码
Test.WebReference.Service1 wr = new Test.WebReference.Service1(); //生成web service实例
wr.Credentials = new NetworkCredential("guest","123"); //guest是用户名，该用户需要有一定的权限
lblTest.Text = wr.Add(2,2).ToString(); //调用web service方法
该方案的优点是比较安全，性能较好，缺点是不便于移植，部署工作量大。

本文链接

sql 索引

2011-11-25T06:53:00Z

主键和唯一索引的区别

主键和唯一索引的一些总结

唯一索引

唯一索引不允许两行具有相同的索引值。如果现有数据中存在重复的键值,则大多数数据库都不允许将新创建的唯一索引与表一起保存。当新数据

将使表中的键值重复时,数据库也拒绝接受此数据。例如,如果在 employee 表中的职员姓氏 (lname) 列上,创建了唯一索引,则所有职员不能同姓。

主键索引

主键索引是唯一索引的特殊类型,数据库表通常有一列或列组合,其值用来唯一标识表中的每一行。该列称为表的主键。在数据库关系图中为表定义一个主键将自动创建主键索引,主键索引是唯一索引的特殊类型。主键索引要求主键中的每个值是唯一的。当在查询中使用主键索引时,它还允许快速访问数据。

它们的一些比较：
(1)对于主健/unique constraint oracle/sql server/mysql等都会自动建立唯一索引
(2)主键不一定只包含一个字段,所以如果你在主键的其中一个字段建唯一索引还是必要的
(3)主健可作外健,唯一索引不可,
(4)主健不可为空,唯一索引可,
(5)主健也可是多个字段的组合.
(6)主键不同的是
a.有not null属性
b.每个表只能有一个

1，创建索引
对于查询占主要的应用来说，索引显得尤为重要。很多时候性能问题很简单的就是因为我们忘了添加索引而造成的，或者说没有添加更为有效的索引导致。如果不加索引的话，那么查找任何哪怕只是一条特定的数据都会进行一次全表扫描，如果一张表的数据量很大而符合条件的结果又很少，那么不加索引会引起致命的性能下降。但是也不是什么情况都非得建索引不可，比如性别可能就只有两个值，建索引不仅没什么优势，还会影响到更新速度，这被称为过度索引。

2，复合索引
比如有一条语句是这样的：select * from users where area=’beijing’ and age=22;
如果我们是在area和age上分别创建单个索引的话，由于mysql查询每次只能使用一个索引，所以虽然这样已经相对不做索引时全表扫描提高了很多效率，但是如果在area、age两列上创建复合索引的话将带来更高的效率。如果我们创建了(area, age, salary)的复合索引，那么其实相当于创建了(area,age,salary)、(area,age)、(area)三个索引，这被称为最佳左前缀特性。因此我们在创建复合索引时应该将最常用作限制条件的列放在最左边，依次递减。

3，索引不会包含有NULL值的列
只要列中包含有NULL值都将不会被包含在索引中，复合索引中只要有一列含有NULL值，那么这一列对于此复合索引就是无效的。所以我们在数据库设计时不要让字段的默认值为NULL。

4，使用短索引
对串列进行索引，如果可能应该指定一个前缀长度。例如，如果有一个CHAR(255)的列，如果在前10 个或20 个字符内，多数值是惟一的，那么就不要对整个列进行索引。短索引不仅可以提高查询速度而且可以节省磁盘空间和I/O操作。

5，排序的索引问题
mysql查询只使用一个索引，因此如果where子句中已经使用了索引的话，那么order by中的列是不会使用索引的。因此数据库默认排序可以符合要求的情况下不要使用排序操作；尽量不要包含多个列的排序，如果需要最好给这些列创建复合索引。

6，like语句操作
一般情况下不鼓励使用like操作，如果非使用不可，如何使用也是一个问题。like “%aaa%” 不会使用索引而like “aaa%”可以使用索引。

7，不要在列上进行运算
select * from users where YEAR(adddate)<2007;

将在每个行上进行运算，这将导致索引失效而进行全表扫描，因此我们可以改成

select * from users where adddate<‘2007-01-01’;

8，不使用NOT IN和<>操作

NOT IN和<>操作都不会使用索引将进行全表扫描。NOT IN可以NOT EXISTS代替，id<>3则可使用id>3 or id<3来代替。

普通索引就是非聚集索引，建非聚集索引必须在有聚集索引的前提下

--建普通索引createindex 索引名 on 表(字段)
--唯一索引create unqiue index 索引名 on 表(字段)
--聚集索引createclusteredindex 索引名 on 表(字段)

本文链接

redis

2011-11-25T06:52:00Z

下载地址：https://github.com/dmajkic/redis/downloads

　redis-server.exe：服务程序

redis-check-dump.exe：本地数据库检查

redis-check-aof.exe：更新日志检查

redis-benchmark.exe：性能测试，用以模拟同时由N个客户端发送M个 SETs/GETs 查询 (类似于 Apache 的ab 工具).

启动Redis服务（conf文件指定配置文件，若不指定则默认）：

D:\redis-2.0.2>redis-server.exe redis.conf

启动cmd窗口要一直开着，关闭后则Redis服务关闭。

这时服务开启着，另外开一个窗口进行，设置客户端：

D:\redis-2.0.2>redis-cli.exe -h 202.117.16.133 -p 6379

然后可以开始玩了：

配置文件参数说明 :

1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

daemonize no

2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定

pidfile /var/run/redis.pid

3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字

port 6379

4. 绑定的主机地址

bind 127.0.0.1

5.当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能

timeout 300

6. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose

loglevel verbose

7. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null

logfile stdout

8. 设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id

databases 16

9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合

save <seconds> <changes>

Redis默认配置文件中提供了三个条件：

save 900 1

save 300 10

save 60 10000

分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

10. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大

rdbcompression yes

11. 指定本地数据库文件名，默认值为dump.rdb

dbfilename dump.rdb

12. 指定本地数据库存放目录

dir ./

13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步

slaveof <masterip> <masterport>

14. 当master服务设置了密码保护时，slav服务连接master的密码

masterauth <master-password>

15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH <password>命令提供密码，默认关闭

requirepass foobared

16. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

maxclients 128

17. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区

maxmemory <bytes>

18. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no

appendonly no

19. 指定更新日志文件名，默认为appendonly.aof

appendfilename appendonly.aof

20. 指定更新日志条件，共有3个可选值：
no ：表示等操作系统进行数据缓存同步到磁盘（快）
always ：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec ：表示每秒同步一次（折衷，默认值）

appendfsync everysec

21. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）

vm-enabled no

22. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享

vm-swap-file /tmp/redis.swap

23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0

vm-max-memory 0

24. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不确定，就使用默认值

vm-page-size 32

25. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。

vm-pages 134217728

26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4

vm-max-threads 4

27. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启

glueoutputbuf yes

28. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法

hash-max-zipmap-entries 64

hash-max-zipmap-value 512

29. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）

activerehashing yes

30. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件

include /path/to/local.conf

本文链接

Memcached、MongoDB、Redis和tokyotyrant

2011-11-25T06:52:00Z

MongoDB实际上是一个简化版的MySQL，Mongodb的接口实际上就是类似给SQL做个封装而已。Mongodb只能支持简单的单一查询语句，不能join，不能子查询。实际性能MySQL和Mongodb差不多，MySQL在高并发的情况下性能不太好，MongoDB会好很多。

Redis读写性能都非常强悍，但是存储数据的容量受限于内存容量。支持Lists类型和Sets类型的数据，2.0增加了更多数据类型。相当于是一个支持持久存储的memcache。

tokyotyrant也是是一个高性能的存储引擎，性能非常出色，每秒可以处理4-5万次读写操作。TT不是内存映射的模式，主要是文件系统存储为主。吃内存少一些。TC除了支持Key-Value存储之外，还支持保存Hashtable数据类型，表结构TokyoTyrantTable，支持列，表，字段，索引，支持query查询。

memcached：设定最大内存占用，最久不使用自动过期，高读写性能，适合最缓存。

redis：拥有memcached的优点，储存数据支持list，适合做队列。是否可以替代memcached我还在考虑。

mongodb：模式自由，容易搭建分布式群集，适合做储存。

MongoDB

添加到服务:mongod.exe --dbpath d:\mongodb\work\db -- logpath d:\mongodb\work\log\log.log --install

启动服务监听:mongod.exe --dbpath d:\mongodb\work\db -- logpath d:\mongodb\work\log\log.log

测试:mongo.exe命令，之后进行操作

注：dppath和logpath必须存在，默认端口为27017

编译redis

启动src / redis - server

客户端连接:src / redis - cli，连接成功后可进行操作

停止服务:src / redis - cli shutdown

以配置文件启动:src / redis - server redis.conf

本文链接