博客园_智慧掩盖真相我的微博

C# Socket 编程之 TcpListener

2010-12-17T07:59:00Z

以下是Server的代码，最近在学习网络编程，一直在思考如何开发出高并发的服务器端。经常听说对服务器描述为同时10000个连接，就在想能否用C#写个这样的服务器出来呢。同步编程模型就不考虑了，来看看TcpListener的异步编程模型能否满足需求。

public partial class COMService {
		private int maxLink = 100000;
		private int currentLinked;
　　　　　　private ManualResetEvent tcpClientConnected = new ManualResetEvent(false);
		public void Start() {

			Thread thread = new Thread(new ParameterizedThreadStart(ShowStat));
			thread.IsBackground = true;
			thread.Start();
			
			TcpListener server = new TcpListener(new System.Net.IPEndPoint(0, 8090));
			server.Start(100);
			tcpClientConnected.Reset();
			IAsyncResult result = server.BeginAcceptTcpClient(new AsyncCallback(Acceptor), server);
			tcpClientConnected.WaitOne();
		}

		private void ShowStat(object o) {
			while (true) {
				lock (typeof(COMService)) {
					Console.WriteLine("当前连接数:" + currentLinked + "/" + maxLink);
				}
				Thread.Sleep(2000);
			}
		}

		private void Acceptor(IAsyncResult o) {
			TcpListener server = o.AsyncState as TcpListener;
			Debug.Assert(server != null);
			TcpClient client = null;
			try {
				client = server.EndAcceptTcpClient(o);
				System.Threading.Interlocked.Increment(ref currentLinked);
				
			} catch {
				
			}
			IAsyncResult result = server.BeginAcceptTcpClient(new AsyncCallback(Acceptor), server);
			if (client == null) {
				return;
			} else {
				Thread.CurrentThread.Join();
			}
			Close(client);
		}

		private void Close(TcpClient client) {
			if (client.Connected) {
				client.Client.Shutdown(SocketShutdown.Both);
			}
			client.Client.Close();
			client.Close();

			System.Threading.Interlocked.Decrement(ref currentLinked);
		}
	}
}

以下是Client的代码：

public class ClientPool {
		private static List<TcpWork> clients = new List<TcpWork>();

		private static int freeCount;

		private static int workCount;

		private static int maxAllowed =	2;

		private static int minClients = 2;
		/// <summary>
		/// create new instance
		/// </summary>
		private ClientPool() {
		}

		private static ClientPool instance;
		private static readonly object syncInstanceObj = new object();
		public static ClientPool Singleton {
			get {
				if (instance == null) {
					lock (syncInstanceObj) {
						if (instance == null) {
							instance = new ClientPool();
						}
					}
				}
				return instance;
			}
		}

		private static readonly object syncObj = new object();

		public TcpWork GetClient() {
				try {
				TcpWork work = new TcpWork();
				work.Connect("127.0.0.1", 8090);
				work.LingerState = new LingerOption(false, 3);
				work.IsWork = true;
				work.Expired = false;
				workCount++;
				lock (syncObj) {
					clients.Add(work);
				}
				Console.WriteLine(workCount);
				return work;
			} catch (Exception ex){
				Console.WriteLine(ex.Message);
				return null;
			}
		}
	}

Client模拟多线程并发：

class Program {
		static void Main(string[] args) {
			for (int i = 0; i < 1000; i++) {
				ThreadPool.QueueUserWorkItem(new WaitCallback(Work), null);
			}
			Console.ReadKey();
		}

		private static void Work(object o) {
			ClientPool.Singleton.GetClient();
		}
	}

从这个编程模型可以看出，高并发的服务器不光需要满足有多少个并发连接数，每秒创建多少个连接数也是个重要指标～～

实际运行上看看，TcpListener每秒大概能创建两个连接，其他的连接会被拒绝，保持的长连接数1000的样子。很明显，TcpListener要被咔嚓掉了～～

注意，以上代码仅仅是用来测·试连接用的，这种写法会导致服务器端的连接无法释放~~~~

本文链接

选择结构(if..else..,switch,try..catch..)的拆分

2010-12-02T09:17:00Z

编程中经常遇到很多条件，以及条件套条件的情况，以至于一个方法会写得非常地长。有多种方法可以规避这个问题。比如反射，策略模式，表驱动等等。先抛开这些方法不讲，从根本需求来探索这个过程。

一个switch结构可能是这样：

swicth(case)

case 1:

//do1

break;

case 2:

//do2

break;

.....

这里注释的do部分代码可能会是很多很多行，以及嵌套switch,if结构。

进一步，这个模型演化成

swicth(case)

case 1:

do1();

break;

case 2:

do2();

break;

.....

do1(){}

do2(){}

也就是将里面的代码模块化。这个方法有效的减小了一个方法的代码长度。实际上这就是一个映射关系的调用。建立映射关系，用Hash结构和delegate就可以避免使用switch了。

delegate void funtionptr();

Dictionary<int, funtionptr> dict = new Dictionary<int, funtionptr>();

dict.Add(1,do1);

dict.Add(2,do2);

int parm = 0;

if(dict.ContainKey(parm)){

dict[parm].Invoke();
}

do1(){}

do2(){}

这个方法实际上就是表驱动，因为C#中一般不用指针，因此用delegate代替了指针的作用。而java中既没有指针也没有delegate怎么办呢?那就用接口模拟指针。

(这里就用C#的语法了，不使用JAVA了)

interface FactionFace{

void do();
}

class FactionFaceImpl1 : FactionFace{

public void do(){}
}

class FactionFaceImpl2 : FactionFace{

public void do(){}
}

Dictionary<int, FactionFace> dict = new Dictionary<int, FactionFace>();

dict.Add(1,new FactionFaceImpl1());

dict.Add(2,new FactionFaceImpl2());

int parm = 0;

if(dict.ContainKey(parm)){

dict[parm].do();
}

可以看出，实际上，上面的代码就是策略模式的简单实现了。（OH~~原理策略模式这么就来的～～）

可以看出，这里实际上是依靠一个字典来维护条件和调用的关系的。那如果没有这个字典来维护怎么办呢？代码再次演化：

interface FactionFace{

void do();
}

class FactionFaceImpl1 : FactionFace{

public void do(){}
}

class FactionFaceImpl2 : FactionFace{

public void do(){}
}

string parm = "FactionFaceImpl2";

FactionFace ff = Type.GetType(parm) as FactionFace;

ff.do();

OH~~这就是简单的反射了。再复杂一些就可以搞成工厂模式，插件模式了。

可以看出，用字典来维护映射关系就可以避免使用反射。（这个是不是一般规律，贫道没本事证明，起码这里是适应的。）

再来看try...catch...

delegate void forException(Exception ex);

public void forAException(Exception ex) {Console.WriteLine("AException");}
public void forAAException(Exception ex) {Console.WriteLine("AAException");}
public void forBException(Exception ex) {Console.WriteLine("BException");}

public void test() {

Dictionary<int, forException> dict = new Dictionary<int, forException>();

dict.Add(0, forAException);

dict.Add(1, forAException);

dict.Add(11, forAAException);

dict.Add(2, forBException);

try {

throw new AAException();

} catch (Exception ex)

{

if (ex is OException) {

OException eex = ex as OException;

if (dict.ContainsKey(eex.Index)) {

dict[eex.Index].Invoke(ex);

}

public class OException : Exception {public virtual int Index { get { return 0; } }}
public class AException : OException {public override int Index {get {return 1;}}}
public class AAException : AException {public override int Index {get {return 11;}}}
public class BException : OException {public override int Index {get {return 2;}}

这里为啥要有个Index属性呢？其实就是建立个对应的关系，而不是靠名字去维护。去掉这个属性，直接使用ex.GeType()然后获取名字类名也一样可以建立对应关系。

本文链接

该省代码的地方要省，反之亦然。

2010-06-24T17:46:00Z

意大利输球了，睡不着阿！现在就剩下德国和阿根廷是比较喜欢的球队了。

还是聊聊代码上的事情吧。什么地方该省代码？在我参与、开发和接触到的很多项目中，曾经都很喜欢在开始阶段做一个设计。这本身没有错，问题在于，经常在还没有用户或者网站总用户才几十万的场景下，去考虑高并发，去考虑高负载，去设计能够跑在N台服务器上的架构。现在想来这都没有错，不去尝试，不去思考就不会进步。当然，所考虑绝不是仅仅这一个问题，而是言必谈扩展性。积极地去考虑扩展性的问题，我一直认为是个好事情，假如我是老板，我一定会适当放松项目周期，以期让开发人员有更多的思考。事实上在我以期考虑这些问题的时候，我经常会把下班时间也用上，对公司其实并不一定吃亏。

但现在想来是一个极端的表现。现在想来应该是当时对使用到的技术的各个方面：比如I/O吞吐能力、线程并发能力、网络并发能力、事物处理等等，对他们都一知半解或者干脆就不了解。另外两个最重要的方面在于对需求定位不清，以及总想一步到位。不要试图说你对需求的定位很清晰，实际上需求方都不一定完全把握。就比如项目的生命周期，整个项目组真的清楚了么？对使用的技术缺乏整体上的理论理解，才会让人不之所措，以至于过分关注性能等问题。出现性能问题也不能立刻把握瓶颈。

跑题了，继续说说我对省代码和多写代码的理解。我认为，开发任何一个项目，只要不是一锤子买卖，都需要从整体进行把握。不但能有效地进行业务的后期扩展，也可以在协同中少走很多弯路。我认为只要不是自己能够把握的代码，都可以能省则省。那什么是自己不能把握的代码？举个离子，我开发一个项目需要用到B部门开发的一个系统，那么调用B部门系统的方式就是我不能把握的代码。更极端地说，如果B部门的系统还要依赖C部门开发的组件，那B不能都不能把握给我调用的方式，那自然我就更加不好把握。这种情况，就需要和需求方多沟通，让需求方于B、C部门保持沟通才能让我在开发时更加省力。这种情况一般把B给你的接口和你实际的调用方式分开更好。可以根据需求方的业务要求，制定自己需要的接口，然后再拿自己定义的接口和B部门提供的接口做适配。这样做有两个好处，没有他们的系统你也可以很方便地模拟数据进行单元测试，或者说是即便没有他们的系统，你的系统依然可以运行，只是不能用而已。另外一个好处是如果B部门的接口不影响你的接口调用的方式，就可以隔离掉对你的系统的影响。这样就将对B部门系统的依赖降到最低。一定要把整个过程当成两件事情，当整个团队确定要做一件事情，那先要保证你的事情做好了，然后再去看别人的事情做好没有。当然如果需求方在保持沟通过程中发现事情根本不能做，大家都放弃，那是最坏的打算。但不能因为这个理由而拖延项目的开发，以致项目延期。在这种场合就要多做设计，多写点代码，哪怕最后没用上都没关系。我做过的项目，没有中途不变更的，所以还是先考虑设计要紧。

刚才说了不要过分关注对未来的扩展，因为你也不能保证你的设计就能符合未来的场景。但是有一些设计还是可以做的，比如，可以将你认为会影响性能的地方抽象化，先做简单的实现。如果在项目上线后发现确实是这里拖了后腿，改动的化也只要改实现而不用重新架构项目。

那什么时候可以省代码呢？对那样根本不要重用或者很难重用的东西，可以考虑省代码，省设计。比如一个页面要以5种样子显示，老老实实地做5个页面就行了，不用过分地去设计。A页面显示10条数据3个字段，B页面显示.....如果做抽象设计会绕进去，我尝试过很多次，没有做到一个可以让我满意的方案出来。当然你也可以去尝试，我做不出不代表你做不出，呵呵。

一般来说不需要做多种解决方案的也不要过渡地去设计。比如做个日志，你不是要把日志存储到N种设备上就不用考虑设备相关。诚然，做得象log4j那样确实很牛，但common-logging中也提供的简单的实现。一般来说，一个团队形成的积累不用过渡考虑你们根本用不上的场景，那只是增加负担。

本文链接

dell笔记本的Broadcom 802.11b/g 无线网卡ubuntu 9.10下安装

2010-03-21T10:29:00Z

本本的无线网卡驱动一直安装不上，搞的很不方便。查阅了大量资料，dell和broadcom官方都没有提供linux下的驱动。现有的驱动是b43,参考http://linuxwireless.org/en/users/Drivers/b43

不过说明都是英文的不说，按照上面的方式安装最后出现了问题。汗~~~~~~~~反正就是没搞定.............

这下没辙了。又仔细查看了自己的网卡芯片类型：

$sudo lshw

*-network

description: Wireless interface

product: BCM4312 802.11b/g

vendor: Broadcom Corporation

physical id: 0

bus info: pci@0000:0e:00.0

logical name: eth1

version: 01

serial: 70:1a:04:42:87:1c

width: 64 bits

clock: 33MHz

capabilities: pm msi pciexpress bus_master cap_list ethernet physical wireless

*-network

description: Wireless interface

product: BCM4312 802.11b/g

vendor: Broadcom Corporation

physical id: 0

bus info: pci@0000:0e:00.0

....

芯片类型是BCM4312 802.11b/g，对照b43的资料发现

14e4:4312	supported (802.11g only)	BCM4312	a/b/g	G	b43
14e4:4312	not supported - ID is duplicated	BCM4312	b/g	G	b43

我的额网卡是b/g，而支持的是a/b/g。不知道我的理解是不是正确，汗~~~~都是4312型号的，还搞这么复杂.....

最后无意中发现，我的无线网卡实际上已经装了驱动了，只是不正确而已。于是在“新立得软件包管理器”里搜索broadcom。发现里面一共有四项，已经安装了两项。

把那两项去掉，然后选

b43-fwcutter

Broadcom 43xx 固件提取工具

bcmwl-kernel-source

Broadcom 802.11 Linux STA 无线驱动源

这两项。不知道还能不能省略一项，重启后，网卡就好了。

注意：

bcmwl-kernel-source

的说明：

这些软件包包含了 Broadcom 802.11 Linux STA 无线驱动来使用

Broadcom 的基于 BCM4311， BCM4312， BCM4321，和 BCM4322

的硬件。

而还有个Broadcom 的 bcm5700 以太网驱动用到的模块源代码

我估计bcm5700要装这个，不过我就没办法试验了。

总算给本本搞的无线驱动，方便多了，一口气能上六楼~~~~

本文链接

四步完成跨平台调用——thrift的开发应用

2010-03-16T07:48:00Z

一、安装thrift

首先，你要有个Linux平台，反正安装好了就行，用不着太多的东西。

thrift这个东东可以在http://www.thrift-rpc.org/下载。

具体在http://www.thrift-rpc.org/?p=thrift.git;a=shortlog;h=refs/misc/instant，一般点第一个snapshot就行了，这是最新的。版本几个小时更新一个，太牛叉了。

接下来，安装thrift。到thrift的解压目录，执行命令：

#chmod +x * //设置执行权限

#./bootstrap.sh

#./configure

#make

#make install

二、确定接口

平台与平台的方法调用或数据交换，需要依赖一组结构和一些方法。需要定义好这个方法，才可以进行接下来的开发。比如，我现在需要通过C#调用Java。如果说Java的服务端已经开发好了，那就非常像是适配器模式了。

现在书写一个简单的接口：

service ThriftTest

{

void work();

i32 test(1:string s);

}

service ThriftTest

{

void work();

i32 test(1:string s);

}

（注：复杂一些的接口可以参考下载来包里的thrift\test目录下的*.thrift文件。）

现在开始生成代码：

# /home/xieping/thrift/compiler/cpp/thrift -gen java test.thrift

# /home/xieping/thrift/compiler/cpp/thrift -gen csharp test.thrift

分别生成了java和csharp的应用，在gen-java和gen-csharp目录下。

三、开发服务端

把Java下的ThriftTest类拷贝到项目中，注意添加package。定义服务类ThriftServer，实现ThriftTest.Iface接口。（项目需要引用thrift\lib\java\src里的项目。同时需要引用slf4j-log4j12-1.5.11.jar，slf4j-api-1.5.11.jar，log4j-1.3alpha-8.jar三个包。）

import org.apache.thrift.TException;

public class ThriftServer implements ThriftTest.Iface {

@Override

public int test(String s) throws TException {

// TODO Auto-generated method stub

return Integer.parseInt(s);

}

@Override

public void work() throws TException {

// TODO Auto-generated method stub

System.out.println("ccc");

}

在main方法中写入：

try {

ThriftServer t = new ThriftServer();

ThriftTest.Processor p = new ThriftTest.Processor(t);

TServerTransport serverTransport = new TServerSocket(9090);

TServer server = new TThreadPoolServer(p, serverTransport);

// Use this for a multithreaded server

// server = new TThreadPoolServer(processor, serverTransport);

System.out.println("Starting the server...");

server.serve();

} catch (Exception x) {

x.printStackTrace();

}

System.out.println("done.");

这里的Server有好几种，我使用了TThreadPoolServer.运行，服务端就OK了。

四、客户端调用

客户端把gen-csharp里的类，拷贝到项目中。引用thrift\lib\csharp\src里的项目。

然后编写代码：

static void Main(string[] args) {

TTransport transport = new TSocket("localhost",9090);

TProtocol protocol = new TBinaryProtocol(transport);

ThriftTest.Client client = new ThriftTest.Client(protocol);

transport.Open();

int val = client.test("1213");

client.work();

transport.Close();

Console.WriteLine(val);

}

运行，出结果了。

四步就完成了通过Thrift跨平台调用的目的。Java和C#还好些，php调用Java的相对来说使用上更广泛一些。

本文链接

facebookde 的 NoSQL数据库cassandra的配置与调用(java&&c#)

2010-03-12T08:08:00Z

上次说了安装的问题，可以参考《VirtualBox 虚拟机 Debian系统上安装Cassandra步骤及遇到的问题》。当然，在windows下也可以使用，但是要设置JAVA_HOME参数，然后启动目录bin里的cassandra.bat。编辑cassandra.bat看到

if NOT DEFINED CASSANDRA_HOME set CASSANDRA_HOME=%CD%

改成

if NOT DEFINED CASSANDRA_HOME set CASSANDRA_HOME=F:\apache-cassandra-0.5.1

“F:\apache-cassandra-0.5.1”是我的安装目录。

一、cassandra的单节点服务器配置

先说下cassandra的配置，还是讲Linux下的。需要配置的文件一共有三个，当然，也可以使用默认配置。

这个三个文件分别是：

bin/cassandra.in.sh

conf/log4j.properties

conf/storage-conf.xml

其中，log4j.properties是日志的配置，其它两个是配置的运行环境。

cassandra.in.sh文件一般不需要调整，当然，加入你没有使用alternatives调整java的默认环境，而你又需要使用jre6.0,这种情况下，可以设置cassandra.in.sh中

#JAVA_HOME=/usr/local/jdk6

为

JAVA_HOME=/usr/local/jre6 #这里是你的jre解压缩的路径

log4j.properties的配置网上讲的很多，就不说了。

storage-conf.xml的配置是最重要的。

第一个是Keyspaces，这个默认只设置了Keyspace1，可以增加另外的Keyspaces。客户端调用需要使用这个名字。

Keyspace节点中的KeysCachedFraction设置的键索引的内存大小。说明上也写了，假如键的数量较少，长度较长，可以增加这个值。而设置为0，则是禁用。

接下来是设置ColumnFamily，这里配置的名称，在客户端调用时候也要是有。另外还指定了列的类型。

ReplicationFactor设置了副本的数目，这个是在分布式部署中有用，保持数据的冗余，以至于某几台服务坏掉，能保证数据完整。

CommitLogDirectory以及接下来的几行都是设置目录的，这个就不说了。

Seeds也是和分部署主从服务器部署方式有关的，本文不准备讲这个。

ThriftAddress是比较重要的，这个是设置客户端访问的，而ThriftPort是设置访问的端口。接下来的部分是和性能有关的，这些说明可以仔细阅读。贫道对下面的设置也理解不深入，就不献丑了。

二、如何编程访问cassandra

从http://incubator.apache.org/cassandra/找了好久，找到了http://github.com/rantav/hector （java）。这个是一个访问cassandra的包装。很遗憾的是，我使用这个包装访问时候，读取一个Key的值需要7～8秒！！！晕倒。我开始以为是虚拟机的原因，结果部署到其他两台linux服务器上还是一样。当然这些机器和我的机器都不在同一个网段，我不知道这点是不是会对性能有很大的影响。后来，我放到自己机器上，以及把写好的程序当道目标机器上，读取速度变成了20MS每条。性能相差也太大了。一个是速度慢得和蚂蚁一样，而第二次则是坐上乌龟了。

其它语言的访问包装可以在http://wiki.apache.org/cassandra/ClientExamples 这里找到。当然，没有C#的。

三、用C#和Java访问cassandra

cassandra用到了另外一个好用的东西：thrift。这个东东可以在http://www.thrift-rpc.org/下载。

具体在http://www.thrift-rpc.org/?p=thrift.git;a=shortlog;h=refs/misc/instant，一般点第一个snapshot就行了，这是最新的。版本几个小时更新一个，太牛叉了。

下载完后，搞到Linux上，解压。进入目录后进行安装。

#chmod +x * //设置执行权限

#./bootstrap.sh

#./configure

#make

#make install

安装好了，接下来，开始生成操作。

切换到cassandra的interface目录。

然后，使用/home/xieping/thrift/ompiler/cpp/thrift -gen csharp cassandra.thrift 命令生成。运行该命令后，在interface目录增加了gen-csharp目录。把它搞到你的机器，然后，切换到/home/xieping/thrift/lib/csharp目录。把src目录搞下来。打开Thrift.csproj文件，右键Thrift项目，设置编译符号为NET_2_0。新建个C#项目，把gen-csharp目录下的东西添加进去，然后，引用Thrift项目，就可以写以下代码调用：

using System;
using Thrift.Transport;
using Thrift.Protocol;
using Apache.Cassandra;

namespace TestCa {
    class Program {
        static void Main(string[] args) {
            TTransport transport = new TSocket("192.168.93.30", 9160);
            TProtocol protocol = new TBinaryProtocol(transport);
            Cassandra.Client client = new Cassandra.Client(protocol);

            transport.Open();

            System.Text.Encoding utf8Encoding = System.Text.Encoding.UTF8;

            long timeStamp = DateTime.Now.Millisecond;
            ColumnPath nameColumnPath = new ColumnPath() {
                Column_family = "Standard1",
                Column = utf8Encoding.GetBytes("name")
            };

            client.insert("Keyspace1",
                          "1",
                          nameColumnPath,
                          utf8Encoding.GetBytes("测试输入1"),
                          timeStamp,
                          ConsistencyLevel.ONE);

            client.insert("Keyspace1",
                          "2",
                          nameColumnPath,
                          utf8Encoding.GetBytes("测试输入2"),
                          timeStamp,
                          ConsistencyLevel.ONE);

            ColumnOrSuperColumn returnedColumn = client.get("Keyspace1", "1", nameColumnPath, ConsistencyLevel.ONE);
            Console.WriteLine("Keyspace1/Standard1 列值: 键: {0}, 值: {1}",
                              utf8Encoding.GetString(returnedColumn.Column.Name),
                              utf8Encoding.GetString(returnedColumn.Column.Value));
            transport.Close();

            Console.ReadKey();
        }

    }
}

而Java的就变成

/home/xieping/thrift/ompiler/cpp/thrift -gen java cassandra.thrift

java相应的代码

import static me.prettyprint.cassandra.utils.StringUtils.bytes;

import java.io.UnsupportedEncodingException;
import org.apache.cassandra.service.Cassandra;
import org.apache.cassandra.service.ColumnOrSuperColumn;
import org.apache.cassandra.service.ColumnPath;
import org.apache.cassandra.service.ConsistencyLevel;
import org.apache.cassandra.service.InvalidRequestException;
import org.apache.cassandra.service.NotFoundException;
import org.apache.cassandra.service.TimedOutException;
import org.apache.cassandra.service.UnavailableException;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.*;


public class Program {
    public class s{
        
    }
    
    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        Long startTime = System.currentTimeMillis(); 
        for(int i = 0;i < 10000;i++){
            run();
        }

        Long endTime = System.currentTimeMillis(); 
        System.out.println("程序运行到此处计算机当前毫秒数 " + startTime);
        System.out.println("程序共计运行 "+ (endTime-startTime)+" 毫秒"); 
    }
    
    static void run() throws InvalidRequestException, UnavailableException, TimedOutException, TException, NotFoundException, UnsupportedEncodingException{
        TTransport transport = new TSocket("192.168.93.30",9160);
        TProtocol protocol = new TBinaryProtocol(transport);
        Cassandra.Client client = new Cassandra.Client(protocol);

        transport.open();
        Long timeStamp = System.currentTimeMillis(); 
        
        ColumnPath nameColumnPath = new ColumnPath("Standard1",null,bytes("name"));


        client.insert("Keyspace1",
                      "1",
                      nameColumnPath,
                      bytes("测试数据1"),
                      timeStamp,
                      ConsistencyLevel.ONE);

        client.insert("Keyspace1",
                      "2",
                      nameColumnPath,
                      bytes("测试数据2"),
                      timeStamp,
                      ConsistencyLevel.ONE);


        ColumnOrSuperColumn returnedColumn = client.get("Keyspace1", "1", nameColumnPath, ConsistencyLevel.ONE);
        
        System.out.println(String.format("key:%s;value:%s", 
                new String(returnedColumn.column.name),
                new String(returnedColumn.column.value,"utf-8")));

        transport.close();
    }
    
}

本文链接

VirtualBox 虚拟机 Debian系统上安装Cassandra步骤及遇到的问题

2010-03-10T10:51:00Z

本文记录一下我在VirtualBox 虚拟机 Debian系统上安装Cassandra步骤及遇到的问题。其它Linux系统碰到的问题应该大同小异。

一、网络问题

Sun的VirtualBox中文界面，而且开源，有什么理由不用呢？最近想看看各种Linux操作系统的差异，和RHEL系列的比，果然有很大的差别。下载Debian,第一张盘就行了，因为习惯自己编译了，不用本地源，常用的东西都是下载好了的。接下来，安装好Debian,无论是中文也好英文也罢。

下面就是配置网络的问题，由于Debian默认的网段是10.10.*.*的，我本机还访问不了，因此需要修改IP地址。修改了很多次才成功。记录下成功的这次。

安装完VirtualBox虚拟机后，会多一个网卡——VirtualBox Host-Only Network，默认IP是192.168.56.1。启动VirtualBox时，网络连接选择Host-only Adapter。这种模式是主机和虚拟机能够互相通信，但是虚拟机不能上网。对开发环境来说已经足够了。至于Nat和Bridged没有去尝试，Nat的要做端口映射，Bridged要占用主机网段IP，可能会抢同事的IP，就不尝试了。

下面是配置网络。Debian的网络设置和RHEL的不一样。设置网卡是在/etc/network/interfaces文件，设置DNS是在/etc/resolv.conf 文件。现在设置如下：

首先通过命令 # ifconfig -a 查看到当前外网网卡标识。我前几次操作错误，现在的标识是eth2。

在/etc/network/interfaces 文件加入：

auto eth2

iface eth2 inet dhcp

auto eth2

iface eth2 inet dhcp

然后通过

#ifdown eth2

#ifup eth2

重新载入设置。现在网络就OK了。

二、Java安装

Cassandra是基于Java的程序，先去下载和Jre，我下载的Jre1.6 update18——“jre-6u18-linux-i586.bin”。把文件传过去，然后在虚拟机运行：

#cd ~ //我的是root帐号，我的文件就传到了/root目录

#chmod +x jre-6u18-linux-i586.bin

#./jre-6u18-linux-i586.bin

#cp jre1.6.0_18/ /usr/local/ -r

现在就把jre的文件拷贝到了/usr/local/jre1.6.0_18/目录。

现在要设置Java了，在RHEL使用alternatives命令，而在Debian使用update-alternatives命令，语法一样的。

Debian默认是没装Java的，现在开始设置：

#update-alternatives --install /usr/bin/java java /usr/local/jre1.6.0_18/bin/java 300

如果要是已经安装了java要换版本，可以用update-alternatives --display java查看当前安装的java,使用update-alternatives --config java进行版本切换。

现在输入

#java -version

java version "1.6.0_18"

Java(TM) SE Runtime Environment (build 1.6.0_18-b07)

Java HotSpot(TM) Client VM (build 16.0-b13, mixed mode)

OK了，一切正常。

三、安装和启动

先到http://incubator.apache.org/cassandra/页面下载Cassandra。

我下载的是 apache-cassandra-0.5.1-bin.tar.gz

然后传到虚拟机上。

执行命令

#tar zxvf apache-cassandra-0.5.1-bin.tar.gz //解压缩

#cd apache-cassandra-0.5.1/bin

#./cassandra

输出

Listening for transport dt_socket at address: 8888

INFO - Replaying /var/lib/cassandra/commitlog/CommitLog-1268246662083.log

INFO - LocationInfo has reached its threshold; switching in a fresh Memtable

INFO - Enqueuing flush of Memtable(LocationInfo)@19897293

INFO - Sorting Memtable(LocationInfo)@19897293

INFO - Writing Memtable(LocationInfo)@19897293

INFO - Completed flushing /var/lib/cassandra/data/system/LocationInfo-1-Data.db

INFO - Log replay complete

INFO - Saved Token found: 59927080841113489954773621748862915294

INFO - Starting up server gossip

成功了，呵呵。

当然，要用到生产环境的话可能还需要做很多工作。比如配置啊，开发啊什么的。自己弄来看看的话，这已经是第一步了，呵呵。

本文链接

大道化简，重构的艺术

2010-02-10T11:10:00Z

这个题目貌似很大，有成为标题党人的嫌疑。其实我想说的是一些小事，就是我小时候经常去小渠里抓鱼。而抓鱼的方式也很简单，就是拿砖块，泥巴把小渠的两头堵起来，然后把中间的水舀出去。软件为什么要重构？那是因为你感觉不够好。之所以感觉不够好，原因可能会很多。我想，最严重的一个可能就是设计混乱。设计混乱牵扯的方面很多，有依赖上的，有调用上的。也有根本实现不了目的，或者很难扩展。有很多人重构时候干脆就是把代码重...

读自己的书，走自己的路

2010-02-08T08:20:00Z

本文只是阐述我自己的想法。而我在思考，如何寻求编程的道理，而不是仅仅掌握技术。在我的观点中，术是最初级的东西，由术形成学，而最终总是能反映为道。道是什么东西？在我看来，道并不复杂。术要远比道复杂。目前讲各种各样技术的书籍非常多，相信没有一个人全部读过。但是这些书说阐述的道却不是太多，也有可能根本就没有讲到道。各种各样从入门到精通之类的书籍就不说了，这些书籍很少涉及到道，基本上全部是讲术。是教你如何...

厨师炒菜与网站反爬虫问题

2010-02-07T14:47:00Z

上周部门同事中午一起吃饭时，有同事提到一个问题。具体这个问题干啥的忘记了，只记得是要你设计一个餐馆的工作流程。工作流程就啥也不说了，只是那天中午，我想到到的是合并炒菜。合并炒菜就是指，当某段时间内，如果有人要了同样的菜，那个这个菜就优先炒。当时就想，这在编程中和连接池很相似。而12月份在公司的挖宝任务中，就有一个关于反某IP在单位时间内访问次数的任务。当时想到的方法是在内存中建立一个列表，每次访问...