<![CDATA[超群的博客]]> 2014-02-10T13:37:03+08:00 http://colalife.com/ Octopress <![CDATA[[转]Code Kata：编码套路]]> 2013-12-03T10:39:05+08:00 http://colalife.com/blog/2013/12/zhuan-code-kata-bian-ma-tao-lu 来自happydeer
[正文] 最近，我大量阅读了Steve Yegge的文章。其中有一篇叫“Practicing Programming”（练习编程），写成于2005年，读后令我惊讶不已：

与你所相信的恰恰相反，单纯地每天埋头于工作并不能算是真正意义上的锻炼——参加会议并不能锻炼你的人际交往能力；回复邮件并不能提高你的打字水平。你必须定期留出时间，集中锻炼，这样才能把事情做得更好。

我认识很多杰出的程序员——这是在亚马逊工作最好的额外“福利”之一。如果仔细观察他们，你会发现他们时时都在锻炼。他们已经很优秀了，但他们仍然不忘锻炼。他们锻炼的方法林林总总，而我在这篇文章中只会介绍其中的几种。

据我了解，这些杰出程序员之所以如此成功，就是因为他们一直在锻炼。完美的身材要靠定期的锻炼才能获得，而且必须坚持锻炼才能保持，否则身材就会走形。对于编程和软件工程来说，道理是一样的。

这是一个重要的区别——我每天都开车去上班，但我的驾驶水平远远不如专业车手；类似的情况，天天编程可能并不足以使你成为一名专业的程序员。那么，什么才能把一个普通人变成一名专业车手或者专业程序员呢？你需要锻炼什么呢？

答案就在《科学美国人》的一篇名为“The Expert Mind”（专家思维）的文章里：

爱立信提出，重要的并不是经验本身，而是“努力的学习”，也就是要不断地挑战自身能力之外的东西。一些狂热的爱好者花费了大量的时间去下棋、打高尔夫球或者玩乐器，但他们可能始终停留在业余水平上，而一个训练有素的学生却可以在相对较短的时间里超越他们，原因就在这里。值得注意的是，在提高水平方面，花费在下棋上的大量时间（即使参加各种比赛）似乎还是比不过专门的训练来得更为有效。训练的主要价值在于发现弱点，并有针对性地进行提高。

“努力的学习”意味着，要常常去处理那些刚好在你能力极限上的问题，也就是那些对你来说有很大可能失败的事情。如果不经历一些失败的话，你可能就不会成长。你必须不断地挑战自我，超越自己的极限。

那样的挑战有时会在工作中碰到，但也未必。将锻炼从职业工作中分离出来，这在编程领域常被人称为“编码套路”（Code Kata）。

Code Kata的概念是由David Thomas提出的，他是《程序员修炼之道：从小工到专家》的作者之一。这个概念主要指的是，针对某一种特定技术或技能进行重复性的练习，从而将其熟练掌握。——译者注

所谓套路，就是一系列的招式。这个概念借鉴于武术。

如果你想要看一些编码套路的例子（也就是努力学习和磨练编程技能的方法），SteveYegge的文章里倒是提出了一些不错的建议。他把它们称作为“实践演练”： 1.写一份自己的简历。把自己所有的相关技能都罗列出来，然后把那些在100年后还用得到的标出来。给每个技能打分，满分为10分。

2.罗列出你所景仰的程序员。尽量包括那些与你一起工作的人，因为你会在工作中从他们身上获取一些技能。记录下他们身上的1 ~ 2个闪光点，也就是你希望自己有所提高的方面。

3.查看维基百科上的“计算机科学”栏目，找到“计算机领域先驱者”这个分类，从这个列表中挑选一个人，阅读他的事迹，并且在阅读时打开任何你感兴趣的链接。

4.花20分钟通读别人的代码。读出色的代码和读糟糕的代码都是有益的，两者都要读，轮流切换。如果你无法感觉出它们之间的区别，可以求助于一位你尊敬的程序员，让他给你展示一下什么是出色的代码、什么是糟糕的代码。把你读过的代码给别人也看看，问问他们的看法。

5.罗列出你最喜欢的10个编程工具——那些你觉得你用得最多、非有不行的工具。随机挑选其中的一个工具，花一个小时去阅读它的文档。在这一个小时里，努力去学习这个工具的某个你不曾意识到的新功能，或者发现某种新的使用方法。

6.想一想，除了编程之外你最擅长什么事情？再想一想，你是通过怎样的锻炼才变得如此熟练和专业的？这对于你的编程工作又有什么启发呢？（怎么把这些经验应用到编程方面？）

7.拿出一叠简历，并和一组面试官在同一个房间里待上一个小时。确保每份简历都至少被3个面试官看过，并且要给出1 ~ 3分的评分。针对那些不同面试官评判大相径庭的简历展开讨论。

8.参与一个电话面试。事后写下你的反馈，抛出你的观点，然后与主持电话面试的人聊一聊，看看你们是否达成了一致的结论。

9.进行一次技术面试，并且被面试的人应该是某个你不太了解的领域里的专家。让他假定听众在该领域里一无所知，因此请他从最基础的讲起。努力去理解他所说的，必要时问一些问题。

10.有机会参与别人的技术面试。期间，你只是认真地听、认真地学。在应聘者努力解决技术问题的同时，你也要在自己脑子里尝试解决这些问题。

11.找到一个能和你交换实际问题的人，每隔一周，相互交流编程问题。花10 ~ 15分钟来尝试解决这些问题，再用10 ~ 15分钟进行讨论（无论能否解决）。

12.当你听到任何你一时之间也无法解决的面试问题时，赶紧回到你的座位上，把这个问题用电子邮件发给自己，以留作日后的提醒。在那一周里找出点时间，用自己最喜欢的编程语言来解决它。

我之所以喜欢Steve开出的这个清单，是因为它看上去很全面。有些程序员一想到“锻炼”，总认为就是一些编码上的难题。但在我看来，编程更在于人，而不是代码。因此，通过解决世上所有的、并且晦涩的编程面试题目，在提高你的个人能力方面，这种方法是有局限的。

关于“努力的学习”，我也很喜欢Peter Norvig在“Teach Yourself Programming in TenYears”（花10年时间自学编程）一文中提出的诸多建议：

1.与别的程序员交流。读别人的代码。这比任何书籍或培训课程都更重要。

2.动手写程序！最好的学习方法就是边做边学。

3.在本科或研究生的课程中学习编程课程。

4.找一些项目来做，并且需要与其他程序员形成团队来合作。在项目的进行过程中，学会辨别最出色的程序员以及最糟糕的程序员。

5.在项目中跟随别的程序员一起工作，了解如何维护那些不是你写的代码，并且学习如何写出利于他人维护的代码。

6.学习多种不同的编程语言，特别是那些与你现在所熟悉的语言有着不同的世界观和编程模型的。

7.了解硬件对软件的影响。知道你的电脑执行一条指令需要多少时间，从内存中取出一个字（在有缓存或没缓存的情况下）需要多少时间，在以太网（或者因特网）上传输数据需要多少时间，从磁盘中读取连续的数据或者在磁盘上跳转到另一个位置需要多少时间，等等。

你还可以从Dave Thomas的21种实用的编码套路中获取灵感（CodeKata.com），或者你更愿意加入一个你家当地的“编程武馆”（CodingDojo.org）。

对于“努力的学习”，我无法像Steve，Peter或者Dave那样提供一个长长的建议列表。我远不如他们有耐心。实际上，在我看来，“编程套路”只需两个招式：

1.写博客。我在2004年初创办了CodingHorror.com博客，作为我自己努力学习的一种形式。它在一开始很不起眼，到后来成为我职业生涯中做过的最重要的一件事。所以，你也应该写博客。最后“闻达于天下”的人，往往就是那些能够有效书写和沟通的人。他们的声音最响亮，是他们在制定游戏规则，并且引领世界的潮流。

2.积极参与著名的开源项目。所有的高谈阔论听起来都很好，但是，你是一个大话王还是一名实干家呢？别光说不练，这个非常重要，因为人们会用你的行动来衡量你，而不是你的言论。努力在公众面前留下些实实在在有用的东西吧，到时候你就可以说，“我在那个项目中出过力。”

当你能编写精彩的代码、并且能用精彩的言辞向世人解释那些代码时，到那时候，我会觉得你已经掌握了最牛的编码套路！

原文地址： http://colalife.com/blog/2013/12/zhuan-code-kata-bian-ma-tao-lu.html/
 written by  wang chaoqun  posted at  http://colalife.com

]]> <![CDATA[MongoDB replSet集群和shard分片]]> 2013-11-17T16:11:35+08:00 http://colalife.com/blog/2013/11/mongodb-replsetji-qun-he-shardfen-pian mongodb的集群有两种：1.主从(master, slave) 2.副本集(Replica Set)
区别是副本集没有固定的”主节点”, 有一个活跃节点(primary)和 一个或多个备份节点(secondary), 而且可以在活跃节点有问题时自动切换（仲裁\选举方式）
本文内容的结果是：建立2个分片，每个分片3个备份节点（端口1000x,2000x），2个选举节点（端口10000,20000），1个路由(端口7701，想选7000被占了)，3个config节点(端口660x，想选6000也被占了)，总共12个

1. MongoDB集群

将mongodb的zip解压到不同的文件夹（本文是windows下，linux类似），建立3个节点（1000X是myshard1分片的），注意端口号，启动：

1
2
3

c:\mongo10001\bin\mongod -f c:\mongo10001\config
c:\mongo10002\bin\mongod -f c:\mongo10002\config
c:\mongo10003\bin\mongod -f c:\mongo10003\config

使用config文件配置，mongo10001节点的内容如下，其他相应修改即可：

1
2
3
4
5
6
7

port=10001
dbpath=C:\mongo10001\data\
logpath=C:\mongo10001\log\mongo.log
replSet=myshard1/127.0.0.1:10002,127.0.0.1:10003
shardsvr=true
logappend=true
rest=true

仲裁节点（可选，要的话后面还有要addArb）

1
2
3

c:\mongo10000\bin\mongod -f c:\mongo10000\config
or
c:\mongo10000\bin\mongod --dbpath=c:\mongo10000\data --port 10000 --replSet myshard1/127.0.0.1:10001

将各节点启动后，cmd下连接并执行初始化命令：

1
2

mongo 127.0.0.1:10001/admin
db.runCommand({"replSetInitiate":{ "_id":"myshard1", "members":[{ "_id":1, "host":"127.0.0.1:10001"}, { "_id":2, "host":"127.0.0.1:10002"}, { "_id":3, "host":"127.0.0.1:10003"}] }})

这个2000X是myshard2分片的3个节点，需要像前面一样配好、启动、执行，不分片可忽略

1
2

mongo 127.0.0.1:20001/admin
db.runCommand({"replSetInitiate":{ "_id":"myshard2", "members":[{ "_id":1, "host":"127.0.0.1:20001"}, { "_id":2, "host":"127.0.0.1:20002"}, { "_id":3, "host":"127.0.0.1:20003"}] }})

查看状态

1

rs.status()

仲裁节点（可选，前面没配置就不要add了）

1

rs.addArb("127.0.0.1:10000")

测试在一个节点导入数据后，查看其他节点数据也有了

1

mongorestore -h 127.0.0.1:10001 --directoryperdb b:\mongo\dump

注意：关于节点的读写操作 在primary节点中添加数据: db.xxxx.insert 如果在secondary备份节点查询，会出现错误:

1

error: { "$err" : "not master and slaveok=false", "code" : 13435 }

执行如下语句:

1

db.getMongo().setSlaveOk();

这是因为对于replica set中的secondary节点默认是不可读的，由Secondary来分担读的压力，Primary只承担写操作，通过在连接时指定或者在主库指定slaveOk即可

spring data mongodb的集群配置（未分片）

原来使用单一mongo的，现在要用集群，就把spring xml配置和properties做相应修改：

1
2
3

<mongo:mongo replica-set="${mongo.replica.set}"/>

mongo.replica.set=127.0.0.1:10001,127.0.0.1:10002,127.0.0.1:10003

2. MongoDB分片

[摘录]基本思想就是将集合切分成小块，这些块分散到若干片里面，每个片只负责总数据的一部分；应用程序不必知道 哪片对应哪些数据，甚至不需要知道数据已经被拆分了，所以在分片之前要运行一个路由进程，进程名mongos，这个路由器知道 所有数据的存放位置，所以应用可以连接它来正常发送请求；对应用来说，它仅知道连接了一个普通的mongod；路由器知道和片的 对应关系，能够转发请求到正确的片上；如果请求有了回应，路由器将其收集起来回送给应用。

所以，在下面的分片完成后，上面spring data mongodb的集群配置就要改回单一mongo的，注意要连接的是mongos，不是原来那个

好了，这里要有路由节点和config节点
开启config服务器（我配了3个，为了测试有节点挂掉的情况，这只是第1个），使用参数或config文件启动

1
2

c:\mongo6001\bin\mongod --dbpath=c:\mongo6001\data --port 6001 --configsvr
c:\mongo6001\bin\mongod -f c:\mongo6001\config

config文件：

1
2
3
4
5
6

port=6001
dbpath=C:\mongo6001\data\
logpath=C:\mongo6001\log\mongo.log
configsvr=true
logappend=true
rest=true

开启mongos服务器，使用参数或config文件启动

1
2

c:\mongo7701\bin\mongos --port 7701 --configdb=127.0.0.1:6001
c:\mongo7701\bin\mongos -f c:\mongo7701\config

config文件：

1
2
3
4
5

port=7701
logpath=C:\mongo7701\log\mongo.log
#configdb说明：一个就写一个，多个就写多个，这里是3个
configdb=127.0.0.1:6001,127.0.0.1:6002,127.0.0.1:6003 
logappend=true

启动mongod服务器，上面集群配了3个，启动即可（2000X是myshard2分片的，也启动）

1
2
3
4
5
6

c:\mongo10001\bin\mongod -f c:\mongo10001\config
c:\mongo10002\bin\mongod -f c:\mongo10002\config
c:\mongo10003\bin\mongod -f c:\mongo10003\config
c:\mongo20001\bin\mongod -f c:\mongo20001\config
c:\mongo20002\bin\mongod -f c:\mongo20002\config
c:\mongo20003\bin\mongod -f c:\mongo20003\config

连接mongos服务器

1
2
3

C:\Users\wangchaoqun>mongo 127.0.0.1:7701/admin
MongoDB shell version: 2.4.8
connecting to: 127.0.0.1:7701/admin

然后将10001，10002，10003的mongod交给mongos,添加分片也就是addshard()
两个分片的集群，每个分片3个备份节点

1
2

db.runCommand({addshard:"myshard1/127.0.0.1:10001,127.0.0.1:10002,127.0.0.1:10003",allowlocal:true})
db.runCommand({addshard:"myshard2/127.0.0.1:20001,127.0.0.1:20002,127.0.0.1:20003",allowlocal:true})

片已经集群了，但是mongos不知道该如何切分数据，要在mongos设置片键：
1. 开启数据库分片功能

1
2

mongos> db.runCommand({"enablesharding":"mytestdb"})
{ "ok" : 1 }

2. 指定集合中分片的片键，这里使用users里的name

1
2

mongos> db.runCommand({shardcollection:"mytestdb.users",key:{name:1}})
{ "collectionsharded" : "mytestdb.users", "ok" : 1 }

3. 测试

通过mongos向mongodb插入10w记录

1
2
3
4
5
6
7
8
9

use mytestdb
for(var i=0;i<100000;i++){
  var x="poiuytrewqasdfghjklmnbvcxz";
  var c=x.charAt(Math.ceil(Math.random() * 25));
  var t=Math.ceil(Math.random() * 100000);
  var content=c+t;
  var time=new Date().getTime()-Math.ceil(Math.random() * 100)*t;
  db.users.insert({"content":content,"creatorId":""+i%7,"createtime":time});
}

通过printShardingStatus命令查看mongodb的数据分片情况

1

db.printShardingStatus();

每个节点都看看，是不是数据都有了

4. 参考

http://blog.sina.com.cn/s/blog_498e79cc0101115v.html http://www.cnblogs.com/huangxincheng/archive/2012/03/04/2379755.html http://www.cnblogs.com/refactor/archive/2012/08/13/2600140.html

原文地址： http://colalife.com/blog/2013/11/mongodb-replsetji-qun-he-shardfen-pian.html/
 written by  wang chaoqun  posted at  http://colalife.com

]]> <![CDATA[Mongodb, Mysql导出备份至ftp]]> 2013-11-03T17:10:32+08:00 http://colalife.com/blog/2013/11/mongodb-he-mysql-dao-chu-bei-fen-bing-shang-chuan-zhi-ftp 前提是mongodb和mysql已经安装使用，先安装vsftp，配置完成后，在编写shell脚本，使用计划任务执行
1. 安装vsftp

1
2

rpm -q vsftpd
yum -y install vsftpd

设置开机启动

1

chkconfig vsftpd on

启动vsftpd服务

1

service vsftpd start

增加新用户ftpuser，设置权限和密码

1
2
3
4

useradd -d /home/ftpuser -s /sbin/nologin ftpuser
chown -R ftpuser /home/ftpuser
chmod 777 -R /home/ftpuser
passwd ftpuser

配置vsftp

1

vi /etc/vsftpd/vsftpd.conf

内容删掉换成以下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

anonymous_enable=NO
local_enable=YES
write_enable=YES
local_umask=022
dirmessage_enable=YES
xferlog_enable=YES
connect_from_port_20=YES
xferlog_std_format=YES
chroot_list_enable=YES
chroot_list_file=/etc/vsftpd/chroot_list
listen=YES
pam_service_name=vsftpd
userlist_enable=YES
tcp_wrappers=YES
pasv_min_port=10000 
pasv_max_port=10030

添加chroot_list文件

1

vi /etc/vsftpd/chroot_list

内容ftpuser
重启服务service vsftpd restart
防火墙开放21端口

1
2

service iptables stop
vi /etc/sysconfig/iptables

添加

1

-A INPUT -m state --state NEW -m tcp -p tcp --dport 21 -j ACCEPT

重启防火墙服务

1

service iptables start

解决用户无法进入目录问题，终端执行：

1

setsebool -P ftp_home_dir 1

然后重启FTP服务：

1

service vsftpd restart

2. mongodb导出、压缩、上传脚本，删除过期文件

先定义好服务器、数据库、各目录、用户名、密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#!/bin/bash
MONGO_HOST="127.0.0.1:27017"
MONGO_DB="mydbname"
MONGO_DUMP="/usr/local/mongo/bin/mongodump"
MONGO_BACKUP="/usr/local/mongo/backup"
NEW_TIMESTAMP=$(date +%F-%H%M)
OLD_TIMESTAMP=$(date -d '-5 days' "+%F-%H%M")
NEW_BACKUP_FILE="$MONGO_DB.$NEW_TIMESTAMP.tar.gz"
OLD_BACKUP_FILE="$MONGO_DB.$OLD_TIMESTAMP.tar.gz"

# 0.temp dir
if [ ! -d $MONGO_BACKUP/$MONGO_DB.$NEW_TIMESTAMP ]
then
 mkdir $MONGO_BACKUP/$MONGO_DB.$NEW_TIMESTAMP
fi

# 1.mongodump then delete old dir and file
$MONGO_DUMP -h $MONGO_HOST -d $MONGO_DB -o $MONGO_BACKUP/$MONGO_DB.$NEW_TIMESTAMP
cd $MONGO_BACKUP/$MONGO_DB.$NEW_TIMESTAMP && tar -zcf $MONGO_BACKUP/$NEW_BACKUP_FILE */
rm -rf $MONGO_BACKUP/$MONGO_DB.$NEW_TIMESTAMP
rm -rf $MONGO_BACKUP/$OLD_BACKUP_FILE

# 2.upload new and delte old files
#!/bin/sh
FTP_HOST="192.168.100.119"
FTP_PORT="21"
FTP_USER="ftpuser"
FTP_PSWD="123456"
FTP_DIR="mongo-backup"

ftp -nv <<!
open $FTP_HOST $FTP_PORT
user $FTP_USER $FTP_PSWD
binary
prompt
cd $FTP_DIR
mdelete $OLD_BACKUP_FILE
lcd $MONGO_BACKUP
mput $NEW_BACKUP_FILE
close
bye
!
echo "============== $MONGO_DB backup ends at $NEW_TIMESTAMP =============="

3. mysql导出、压缩、上传脚本 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#! /bin/bash
MYSQL_HOST="192.168.100.119"
MYSQL_PORT='3306'
MYSQL_USER='myuser'
MYSQL_PSWD='mypass'
MYSQL_DB='mydbname'
MYSQL_DUMP="/usr/bin/mysqldump"
MYSQL_BACKUP="/usr/local/mysql/backup"
NEW_TIMESTAMP=$(date +%F-%H%M)
OLD_TIMESTAMP=$(date -d '-5 days' "+%F-%H%M")
GZIP="$(which gzip)"

# 1.mysql dump and delete old files
$MYSQL_DUMP -h $MYSQL_HOST -P $MYSQL_PORT -u $MYSQL_USER -p$MYSQL_PSWD $MYSQL_DB | $GZIP -9 > $MYSQL_BACKUP/$MYSQL_DB.$NEW_TIMESTAMP.gz
rm -rf $MYSQL_BACKUP/$MYSQL_DB.$OLD_TIMESTAMP.gz
echo "============== mysqldump ends at $NEW_TIMESTAMP =============="

# 2.upload new and delete old files
FTP_HOST="192.168.100.119"
FTP_PORT="21"
FTP_USER="ftpuser"
FTP_PSWD="123456"
FTP_DIR="mysql-backup"

ftp -nv <<!
open $FTP_HOST $FTP_PORT
user $FTP_USER $FTP_PSWD
binary
prompt
cd $FTP_DIR
lcd $MYSQL_BACKUP
mput $MYSQL_DB.$NEW_TIMESTAMP.gz
mdelete $MYSQL_DB.$OLD_TIMESTAMP.gz
close
bye
!
echo "============== mysql upload ends at $NEW_TIMESTAMP =============="

4. 添加计划任务

1
2
3

crontab -e
#every day at 00m
00 * * * * /bin/bash /usr/local/mongo/cmd/mongo_backup.sh

原文地址： http://colalife.com/blog/2013/11/mongodb-he-mysql-dao-chu-bei-fen-bing-shang-chuan-zhi-ftp.html/
 written by  wang chaoqun  posted at  http://colalife.com

]]> <![CDATA[[转]Tomcat 生产服务器性能优化]]> 2013-07-25T10:08:06+08:00 http://colalife.com/blog/2013/07/zhuan-tomcat-sheng-chan-fu-wu-qi-xing-neng-you-hua tomcat优化+eclipse优化之类的文章网上有很多，这个收藏当作就手的工具。
来自oschina : 参与翻译(4人)：Garfielt, Lesus, MtrS, 大志darcy
[正文]考虑一下这种场景，你开发了一个应用，它有十分优秀的布局设计，最新的特性以及其它的优秀特点。但是在性能这方面欠缺，不管这个应用如何都会遭到客户拒绝。客户总是期望它们的应用应该有更好的性能。如果你在产品中使用了Tomcat服务器，那么这篇文章就会给你几方面来提升Tomcat服务器的性能。
感谢ITWorld article给本文提供资源。经过沉思我已经知道了和早期版本相比最新的Tomcat提供更好的性能和稳定性。所以一直使用最新的Tomcat版本。现在本文使用下面几步来提高Tomcat服务器的性能。 1. 增加JVM堆内存大小 2. 修复JRE内存泄漏 3. 线程池设置 4. 压缩 5. 数据库性能调优 6. Tomcat本地库 7. 其它选项

第一步 – 提高JVM栈内存Increase JVM heap memory

你使用过tomcat的话，简单的说就是“内存溢出”. 通常情况下，这种问题出现在实际的生产环境中.产生这种问题的原因是tomcat使用较少的内存给进程,通过配置TOmcat的配置文件(Windows 下的catalina.bat或Linux下的catalina.sh)可以解决这种问题.这种解决方法是通过增加JVM的栈内存实现的.也就是说，JVM通常不去调用垃圾回收器，所以服务器可以更多关注处理web请求，并要求尽快完成。要更改文件(catalina.sh) 位于”\tomcat server folder\bin\catalina.sh”，下面，给出这个文件的配置信息，

1
2
3
4

JAVA_OPTS="-Djava.awt.headless=true -Dfile.encoding=UTF-8
-server -Xms1024m -Xmx1024m
-XX:NewSize=512m -XX:MaxNewSize=512m -XX:PermSize=512m
-XX:MaxPermSize=512m -XX:+DisableExplicitGC"

-Xms – 指定初始化时化的栈内存
-Xmx – 指定最大栈内存
在重启你的Tomcat服务器之后，这些配置的更改才会有效。下面将介绍如何处理JRE内存泄漏.

第二步 – 解决JRE内存泄露

性能表现不佳的另一个主要原因是内存泄漏，正如我之前说过：始终使用最新的tomcat服务器以获得更好的性能和可伸缩性。现在，这句话变成真的。如果我们使用最新的tomcat版本6.0.26及以上就可以解决这个错误，因为它包含了一个监听器来处理JRE和PermGen的内存泄漏。使用的监听器是，

1

<Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />

你可以在server.xml文件中找到这个监听器的配置，server.xml位置在“tomcat project folder/conf/server.xml”。接下来，我们将看看如何调整连接属性“maxThreads”。

第三步 – 线程池设置

线程池指定Web请求负载的数量，因此，为获得更好的性能这部分应小心处理。可以通过调整连接器属性“maxThreads”完成设置。maxThreads的值应该根据流量的大小，如果值过低，将有没有足够的线程来处理所有的请求，请求将进入等待状态，只有当一个的处理线程释放后才被处理；如果设置的太大，Tomcat的启动将花费更多时间。因此它取决于我们给maxThreads设置一个正确的值。

1
2
3
4
5

<Connector port="8080" address="localhost"
maxThreads="250" maxHttpHeaderSize="8192"
emptySessionPath="true" protocol="HTTP/1.1"
enableLookups="false" redirectPort="8181" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" />

在上述配置中，maxThreads值设定为“250”，这指定可以由服务器处理的并发请求的最大数量。如果没有指定，这个属性的默认值为“200”。任何多出的并发请求将收到“拒绝连接”的错误提示，直到另一个处理请求进程被释放。错误看起来如下，

1
2

org.apache.tomcat.util.threads.ThreadPool logFull SEVERE: All threads (250) are
currently busy, waiting. Increase maxThreads (250) or check the servlet status

如果应用提示上述错误，务必检查上述错误是否是由于单个请求花费太长时间造成的，这个问题的原因是这样的，有时候如果数据库连接不释放的话，进程将不会处理其它请求。
根据我的经验，准确值的设定可以通过将应用在在各种环境中测试得出。接下来，我们来看看如何压缩的MIME类型。

第4步- 压缩

Tomcat有一个通过在server.xml配置文件中设置压缩的选项。压缩可以在connector像如下设置中完成，

1
2
3
4

<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8181" compression="500"
compressableMimeType="text/html,text/xml,text/plain,application/octet-stream" />

在前面的配置中，当文件的大小大于等于500bytes时才会压缩。如果当文件达到了大小但是却没有被压缩，那么设置属性compression=“on”。否则Tomcat默认设置是“off”。接下来我们将看看如何调优数据库。

第五步- 数据库性能调优

Tomcat性能在等待数据库查询被执行期间会降低。如今大多数应用程序都是使用可能包含“命名查询”的关系型数据库。如果是那样的话，Tomcat会在启动时默认加载命名查询，这个可能会提升性能。另一件重要事是确保所有数据库连接正确地关闭。给数据库连接池设置正确值也是十分重要的。我所说的值是指Resource要素的最大空闲数（maxIdle），最大连接数（maxActive）,最大建立连接等待时间（maxWait）属性的值。因为配置依赖与应用要求，我也不能在本文指定正确的值。你可以通过调用数据库性能测试来找到正确的值。

第6步 – Tomcat原生库

Tomcat的原生库基于Apache可移植运行时（Apache Portable Runtime简称APR），给程序员提供了超强的扩展性和性能，在产品运作中帮助融合原生的服务器技术以展现最佳的性能。想知道安装说明的朋友请参考Tomcat Native Library – (APR) Installation。

第7步 – 其他选项

这些选项是： 开启浏览器的缓存，这样读取存放在webapps文件夹里的静态内容会更快，大大推动整体性能。 每当开机时，Tomcat服务器应当自动地重启。 一般情况下HTTPS请求会比HTTP请求慢。如果你想要更好的安全性，即使慢一点我们还是要选择HTTPS。

就这么多啦。在这篇文章里，我教给了大家一些提高Tomcat服务器性能的方法。如果你觉得这篇文章有用，或者你对提高Tomcat服务器性能有别的看法，请不要忘记留下宝贵的评论。祝你今天编程愉快！

原文地址： http://colalife.com/blog/2013/07/zhuan-tomcat-sheng-chan-fu-wu-qi-xing-neng-you-hua.html/
 written by  wang chaoqun  posted at  http://colalife.com

]]> <![CDATA[Cygwin & Wine & Ruby 记录]]> 2013-01-16T16:03:36+08:00 http://colalife.com/blog/2013/01/cygwin-and-wine-and-ruby-ji-lu cygwin是一个在windows平台上运行的unix模拟环境, wine则可以安装在Linux，再对应到Windows相应的函数来调用DLL以运行Windows程序。这两个就是利器，windows下不想用虚拟机（占用资源还挺多）或双系统，就可以用用cygwin；服务器上想搞点exe的东西就安装个wine。至于ruby，是因为octopress要用，开个虚拟机写博客很不爽，windows下折腾安装配置，却中文编码没解决，还是cygwin搞定。

cygwin的安装

官网下载setup-x86_64.exe，运行，下一步，到download site选第一个163的镜像，速度快些；下一步到select packages页面，不选不点，直接下一步，会下载安装默认配置的相关包；安装完默认，重新运行setup，选择要用的包，比如下面这些基本需要： 摘录自blog.developwithpassion.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Archive  
    unzip – Unzipping zip files  
Net  
    openssl – bin and sources
    openssh – Only if you are not going to compile openssh yourself
    curl – download internet resources
Devl
    colorgcc
    gcc
    gcc-core – compiler
    git
    git-completion
    git-gui
    git-svn
    gitk
    libtool – Shared library generation tool. You’ll need it when trying to compile rubies
    libncurses-devel – Used when compiling several other tools I use
    make
    mercurial
    openssl-devel – Required for compiling openssh (not necessarily required for rvm, but I always install it to compile openssh myself)
    readline
    Libs
    zlib
    zlib-devel
Utils
    ncurses – Enabling better handling of terminal
    patch – Apply a diff file to an original.

wine的安装，centos6.x

1
2
3
4
5

wget http://mirrors.sohu.com/fedora-epel/6/i386/epel-release-6-8.noarch.rpm
rpm -ivh epel-release-6-8.noarch.rpm
rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL-6
yum makecache
yum install wine

安装完成后，应用程序（application）->wine->wine configure稍作配置，也可能会提示download gecko，install 完成即可 把windows/system32下的MFC42.dll msxml.dll msvcp60.dll riched20.dll riched32.dll 这几个文件复制到 ~/.wine/drive_c/windows/system32里，再输入命令：winecfg
安装exe，英文系统会有中文乱码情况

1

wine whatever.exe

安装Ruby

我虚拟了两个centos，一个用make install安装并配置octopress环境，另一个同样方法却不成功，后来用rvm可行，不用yum install ruby 是因为版本过低。

RVM安装：

1

curl -L https://get.rvm.io | bash -s stable --ruby
1

ruby --version

显示版本即成功

make install：

1
2
3
4
5
6
7

wget ftp://ftp.ruby-lang.org//pub/ruby/2.1/ruby-2.1.0.tar.gz
tar -zxvf ruby-2.1.0.tar.gz
cd ruby-2.1.0
./configure --prefix=/usr/local/ruby
make
make test
make install

windows7下简直是个悲剧：

下载rubyinstaller安装，devkit解压，然后cmd下 cdd到DevKit path

1
2
3

ruby dk.rb init
ruby dk.rb review
ruby dk.rb install

出现utf-8错误，使用chcp 1252，再进行上三句，done
然后配置octopress环境，英文下rake成功，有中文（比如文章分类、标签带中文的）不成;
摘录自txgcwm.github.io

在实际使用（rake generate/rake preview）的时候，若blog整体采用了非ascii码的编码格式（比如utf-8）就会出现类似这样的错误：
Liquid error: incompatible encoding regexp match (ascii-8bit regexp with utf-8 string)
其实是由于插件文件plugins/category_list_tag.rb本身是ascii编码所致:

1
2

$ chardet category_list_tag.rb
category_list_tag.rb: ascii (confidence: 1.00)

category_list_tag.rb中很多地方用到了ruby的正则表达式，而ruby的正则表达式在匹配的时候，默认是按照“代码源文件”的编码格式(在这里是ascii)进行匹配的，而如果blog是utf-8编码的话就会出现上述错误。有两种解决办法： 1. 将category_list_tag.rb转成utf-8格式。
2. 更改category_list_tag.rb中所有的正则表达式声明，加上u选项（u的意思就是以utf-8编码格式来进行匹配）。例如，若原正则表达式是/regexp/, 则改成/regexp/u。

原文地址： http://colalife.com/blog/2013/01/cygwin-and-wine-and-ruby-ji-lu.html/
 written by  wang chaoqun  posted at  http://colalife.com

]]> <![CDATA[安装git, 建立Octopress博客]]> 2013-01-07T14:34:24+08:00 http://colalife.com/blog/2013/01/an-zhuang-git-create-octopress-blog 本文参考了若干网络日志（谢过~）, 配置个人博客后整理而成

安装git 

1
2

yum -y install git
git --version

在本机使用git创建SSH Key

1
2

ssh-keygen -C "username" -t rsa  
ssh -v git@github.com

//if denied, use ssh-add ~/.ssh/id_rsa to fix this.
备注: useremail为你注册github用户时的邮箱地址 这时，在系统目录下就会生成一个.ssh文件夹，里面为对应的SSH Key，其中id_rsa.pub是Gighub需要的SSH公钥文件。 将id_ras.pub文件里内容拷贝到Github的Account Settings里的key中。 这样你就可以直接使用Git和Github了.

安装ruby 

1
2
3
4
5
6
7

wget ftp://ftp.ruby-lang.org/pub/ruby/2.1/ruby-2.1.0.tar.gz  
tar -zxvf ruby-2.1.0.tar.gz
cd ruby-2.1.0
./configure --prefix=/usr/local/ruby
make
make test
make install

安装OctoPress

通过Git从Github上克隆一份Octopress

1
2
3
4

git clone git://github.com/imathis/octopress.git octopress
cd octopress  
gem install bundler  
bundle install

安装Octopress默认的Theme

1

rake install

//if error: rake aborted!
//You have already activated rake 10.1.0, but your Gemfile requires rake 0.9.2.2. delete your Gemfile.lock and edit the version of rake specified in your Gemfile to 10.1. Job done

通过_config.yml来配置博客

创建一个博客

1

rake new_post["Hello World"]

创建一个博客页面

1

rake new_page["blog"]

预览效果：

1
2

rake generate  
rake preview

然后在浏览器中打开http://localhost:4000

发布Octopress到Github

1
2
3

cd octopress  
rake setup_github_pages  
Repository url: git@github.com:username/username.github.com.git

将博客发布到Github上，输入下面命令：

1

rake deploy

这样，生成的内容将会自动发布到master分支，并且可以使用 http://username.github.com 访问内容。

将source提交：

1
2
3

git add .  
git commit -m "blog init"  
git push origin source

删除之前的添加信息 (配置文件在 ~/octopress/.git/config)

1
2

git remote rm origin  
git remote add origin git@github.com:username/username.github.com.git

添加多说评论

在_config.yml尾部添加如下行：

1
2

# Duoshuo Comments  
duoshuo_show_comment_count: true

在source/_layouts/post.html尾部添加如下代码：

1
2
3
4
5
6

创建source/_includes/post/duoshuo.html文件，将从多说获得的代码放入其中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!-- Duoshuo Comment BEGIN -->
    <div class="ds-thread"></div>
<script type="text/javascript">
var duoshuoQuery = {short_name:"username"};
  (function() {
      var ds = document.createElement('script');
      ds.type = 'text/javascript';ds.async = true;
      ds.src = 'http://static.duoshuo.com/embed.js';
      ds.charset = 'UTF-8';
      (document.getElementsByTagName('head')[0] 
      || document.getElementsByTagName('body')[0]).appendChild(ds);
  })();
  </script>
<!-- Duoshuo Comment END -->

将AddThis更换为JiaThis

打开source/_includes/post/sharing.html，注释掉<div class="share">...</div>中的AddThis相关语句,然后在</div>前加入从JiaThis获得的代码。

Octopress写作

1
2

cd octopress  
rake new_post["new blog"]

another pc

1
2
3

git clone -b source git@github.com:username/username.github.com.git octopress  
cd octopress  
git clone git@github.com:username/username.github.com.git _deploy

增加category_list插件

保存以下代码到plugins/category_list_tag.rb：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

module Jekyll
  class CategoryListTag < Liquid::Tag
    def render(context)
      html = ""
      categories = context.registers[:site].categories.keys
      categories.sort.each do |category|
        posts_in_category = context.registers[:site].categories[category].size
        category_dir = context.registers[:site].config['category_dir']
        category_url = File.join(category_dir, category.gsub(/_|\P{Word}/, '-').gsub(/-{2,}/, '-').downcase)
        html << "<li class='category'><a href='http://colalife.com/#{category_url}/'>#{category} (#{posts_in_category})</a></li>\n"
      end
      html
    end
  end
end

Liquid::Template.register_tag('category_list', Jekyll::CategoryListTag)

将category加入到侧边导航栏，需要增加一个aside 复制以下代码到source/_includes/asides/category_list.html。

1
2
3
4
5
6

<section>
  <h1>文章分类</h1>
  <ul id="categories">
    
  • ftp (1)
    • 

  • hibernate (1)
    • 

  • java (6)
    • 

  • linux (2)
    • 

  • mongodb (2)
    • 

  • mysql (1)
    • 

  • tech (16)
    • 

  • tomcat (1)
    • 

  • web (2)
    • 

  • 代码 (3)
    • 

  • 其他 (1)
    • 

  • 架构 (1)
    • 

  • 生活 (7)
    • 

  • 算法 (1)
    • 

  • 职业 (2)
    • 

  • 设计模式 (1)
    • 

  • 读书 (3)
    • 

      </ul>
</section>

    配置侧边栏需要修改_config.yml文件，修改其default_asides项： default_asides: […, asides/category_list.html, …]

    中文分类支持

    侧边栏添加了文章分类后，英文分类没有问题，点击打开是分类下的文章列表；但中文分类，如云计算、设计模式之类就不行了，网上有各种解决办法，复杂了点；而且我发现新建日志的文件名如果是中文则会转成拼音，文章分类也是，你可以看下public/blog/categories下的文件名；所以如果能把边栏的链接地址改成拼音就行了，rakefile里有rake new_post代码；查看分析发现和plugins/category_list_tag.rb的处理类似，
    category.gsub(/_|\P{Word}/, '-').gsub(/-{2,}/, '-').downcase是转换为单词‘-’分隔并且小写，rakefile里是 mkdir_p "#{source_dir}/#{posts_dir}" filename = "#{source_dir}/#{posts_dir}/#{Time.now.strftime('%Y-%m-%d')}-#{title.to_url}.#{new_post_ext}"
    注意:title多了.to_url，原来如此，将category_list_tag.rb里改成
    category.gsub(/_|\P{Word}/, '-').gsub(/-{2,}/, '-').downcase.to_url， 然后rake generate rake preview
    done！

    原文地址： http://colalife.com/blog/2013/01/an-zhuang-git-create-octopress-blog.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[Excel导出工具类]]> 2013-01-01T16:32:42+08:00 http://colalife.com/blog/2013/01/excel-dao-chu-gong-ju-lei 前端使用jquery easyui，datagrid添加导出按钮（另外的js逻辑）即可将当前页或所有页数据(支持查询条件的导出)导出到excel，支持office excel 2003和2007+;
    使用apache poi（+ooxml）实现，主要代码片段如下：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

    package com.colalife.core.util.excel;

public class ExcelExportUtil {
    private static Logger logger = LoggerFactory.getLogger(ExcelExportUtil.class);
  private static Map<String, CellStyle> styles;
  /**
  * sheetName Excel导出文档里的标签页名，默认为Sheet1
  */
  public static final String DEFAULT_SHEET_NAME = "Sheet1";
  /**
  * excel导出时文件名，默认为"导出excel.xls"
  */
  public static final String DEFAULT_EXCEL_FILE_NAME = "导出excel.xls";

  /**
  * Excel导出,sheetName默认为Sheet1
  * @param dataList 数据，可用bean list
  * @param columns 字段和字段显示名的键值对
  */
  public static void export(List<?> dataList, Map<String, String> columns, HttpServletResponse response)
          throws IOException {
      String[] fields = columns.keySet().toArray(new String[0]);
      String[] titles = columns.values().toArray(new String[0]);
      export(dataList, fields, titles, response);
  }

  /**
  * Excel导出,sheetName默认为Sheet1
  * @param dataList 数据，可用bean list
  * @param EasyuiDataGrid 用来获取fields titles 字段和字段显示名的数组
  */
  public static void export(List<?> dataList, EasyuiDataGrid dg, HttpServletResponse response)
          throws IOException {
      String[] fields = dg.getFields().split(",");
      String[] titles = dg.getTitles().split(",");
      Workbook excel = ExcelExportUtil.getExcel(dataList, fields, titles);
      ExcelExportUtil.setResponseForExcel(response);
      excel.write(response.getOutputStream());
      response.getOutputStream().flush();
      response.getOutputStream().close();
  }

  /**
  * Excel导出,sheetName默认为Sheet1
  * @param dataList 数据，可用bean list
  * @param fields titles 字段和字段显示名的数组
  */
  public static void export(List<?> dataList, String[] fields, String[] titles, HttpServletResponse response)
          throws IOException {
      Workbook excel = ExcelExportUtil.getExcel(dataList, fields, titles);
      ExcelExportUtil.setResponseForExcel(response);
      excel.write(response.getOutputStream());
      response.getOutputStream().flush();
      response.getOutputStream().close();
  }

  /**
  * Excel导出的实现,sheetName默认为Sheet1
  * @param data 数据，可用bean list
  * @param columns 字段和字段显示名的键值对
  */
  public static Workbook getExcel(List<?> data, Map<String, String> columns) {
      return getExcel(data, DEFAULT_SHEET_NAME, columns);
  }

  /**
  * Excel导出的实现,sheetName默认为Sheet1
  * @param data 数据，可用bean list
  * @param columns 字段和字段显示名的键值对
  */
  public static Workbook getExcel(List<?> data, String[] fields, String[] titles) {
      return getExcel(data, DEFAULT_SHEET_NAME, fields, titles);
  }

  /**
  * Excel导出的实现
  * @param data 数据，可用bean list
  * @param sheetName 导出文档里的标签页名
  * @param columns 字段和字段显示名的键值对
  */
  public static Workbook getExcel(List<?> data, String sheetName, Map<String, String> columns) {
      String[] fields = columns.keySet().toArray(new String[0]);
      String[] titles = columns.values().toArray(new String[0]);
      return getExcel(data, sheetName, fields, titles);
  }

  /**
  * Excel导出的实现
  * @param data 数据，可用bean list
  * @param sheetName 导出文档里的标签页名
  * @param fields titles 字段和字段显示名的数组
  */
  public static Workbook getExcel(List<?> data, String sheetName, String[] fields, String[] titles) {
      Workbook workbook = new HSSFWorkbook();
      //创建所有Cell Style
      createStyles(workbook);
      Sheet sheet = workbook.createSheet(sheetName);
      // 创建第一行,为excel表头
      Row row = sheet.createRow(0);
      // 序号列
      Cell numHeader = row.createCell(0);
      numHeader.setCellValue(new HSSFRichTextString("序号"));
      numHeader.setCellStyle(styles.get("header"));
      for (int i = 1; i <= titles.length; i++) {
          Cell header = row.createCell(i);
          header.setCellValue(new HSSFRichTextString(titles[i - 1]));
          header.setCellStyle(styles.get("header"));
      }
      // 创建其他各数据行
      if (!data.isEmpty()) {
          for (int j = 0; j < data.size(); j++) {
              Object bean = data.get(j);
              Row dataRow = sheet.createRow(j + 1);
              // 序号列
              Cell num = dataRow.createCell(0);
              num.setCellValue(new HSSFRichTextString(String.valueOf(j + 1)));
              num.setCellStyle(styles.get("normal"));
              for (int k = 1; k <= fields.length; k++) {
                  Cell cell = dataRow.createCell(k);
                  Object value = null;
                  boolean isDate = false;
                  try {
                      value = PropertyUtils.getSimpleProperty(bean, fields[k - 1]);
                      if (value instanceof Date) {
                          value = DateUtil.formatDate((Date) value);
                          isDate = true;
                      }
                  } catch (Exception e) {
                      logger.error("Excel导出，获取属性值异常：" + e.getMessage());
                  }
                  HSSFRichTextString cellValue = new HSSFRichTextString(ObjectUtils.toString(value));
                  cell.setCellValue(cellValue);
                  cell.setCellStyle(isDate ? styles.get("dateCell") : styles.get("normal"));
              }
          }
      }
      for (int i = 0; i < titles.length; i++) {
          // 自适应宽度
          sheet.autoSizeColumn(i);
      }
      return workbook;
  }

  /**
  * excel导出时用到的方法，直接调用
  */
  public static void setResponseForExcel(HttpServletResponse response) {
      setResponseForExcel(response, DEFAULT_EXCEL_FILE_NAME);
  }

  /**
  * excel导出时用到的方法，直接调用
  * @throws UnsupportedEncodingException
  */
  public static void setResponseForExcel(HttpServletResponse response, String fileName) {
      response.setContentType("application/vnd.ms-excel;charset=UTF-8");
      try {
          // 解决excel文件乱码问题
          response.setHeader("Content-Disposition", "attachment;filename="
                  + new String(fileName.getBytes("GB2312"), "ISO8859-1"));
      } catch (UnsupportedEncodingException e) {
          logger.error("Excel导出，转码异常：" + e.getMessage());
      }
      response.setHeader("Cache-Control", "must-revalidate, post-check=0, pre-check=0");
      response.setHeader("Pragma", "public");
      response.setDateHeader("Expires", 0);
  }

  private static Map<String, CellStyle> createStyles(Workbook wb) {
      styles = Maps.newHashMap();
      DataFormat df = wb.createDataFormat();

      // --字体设定 --//

      //普通字体
      Font normalFont = wb.createFont();
      normalFont.setFontName("宋体");
      normalFont.setFontHeightInPoints((short) 12);

      //加粗字体
      Font boldFont = wb.createFont();
      boldFont.setFontHeightInPoints((short) 12);
      boldFont.setBoldweight(Font.BOLDWEIGHT_BOLD);

      //蓝色加粗字体
      Font blueBoldFont = wb.createFont();
      blueBoldFont.setFontHeightInPoints((short) 12);
      blueBoldFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
      blueBoldFont.setColor(IndexedColors.BLUE.getIndex());

      // --Cell Style设定-- //
      //普通格式
      CellStyle normalStyle = wb.createCellStyle();
      normalStyle.setFont(normalFont);
      styles.put("normal", normalStyle);

      //标题格式
      CellStyle headerStyle = wb.createCellStyle();
      headerStyle.setFont(boldFont);
      // 指定单元格居中对齐
      headerStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        // 指定单元格垂直居中对齐
      headerStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
      styles.put("header", headerStyle);

      //日期格式
      CellStyle dateCellStyle = wb.createCellStyle();
      dateCellStyle.setFont(normalFont);
      dateCellStyle.setDataFormat(df.getFormat("yyyy-MM-dd HH:mm:ss"));
//       setBorder(dateCellStyle);
      styles.put("dateCell", dateCellStyle);

      //数字格式
      CellStyle numberCellStyle = wb.createCellStyle();
      numberCellStyle.setFont(normalFont);
      numberCellStyle.setDataFormat(df.getFormat("#,##0.00"));
      setBorder(numberCellStyle);
      styles.put("numberCell", numberCellStyle);

      //合计列格式
      CellStyle totalStyle = wb.createCellStyle();
      totalStyle.setFont(blueBoldFont);
      totalStyle.setWrapText(true);
      totalStyle.setAlignment(CellStyle.ALIGN_RIGHT);
      setBorder(totalStyle);
      styles.put("total", totalStyle);

      return styles;
  }

  private static void setBorder(CellStyle style) {
      //设置边框
      style.setBorderRight(CellStyle.BORDER_THIN);
      style.setRightBorderColor(IndexedColors.BLACK.getIndex());

      style.setBorderLeft(CellStyle.BORDER_THIN);
      style.setLeftBorderColor(IndexedColors.BLACK.getIndex());

      style.setBorderTop(CellStyle.BORDER_THIN);
      style.setTopBorderColor(IndexedColors.BLACK.getIndex());

      style.setBorderBottom(CellStyle.BORDER_THIN);
      style.setBottomBorderColor(IndexedColors.BLACK.getIndex());
  }

}

    页面调用

    在相应页面的toolbar里添加导出按钮，调用js function，例如：

    1
2
3
4
5
6
7
8

    function exportData() {
//       默认导出
//       jsUtil.doDefaultExport('<%=request.getContextPath()%>/core/operlog/export', datagrid);

//       支持查询条件的导出
  var inputs = $("#searchForm input").clone();
  jsUtil.doExport('<%=request.getContextPath()%>/core/operlog/export', datagrid, inputs);
}

    jsUtil里的js逻辑：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

    /**
 * 提交导出form
 */
jsUtil.submitExportForm = function(form) {
    form.submit();
  form.remove();
}
/**
 * 导出方法，input为其他查询条件
 */
jsUtil.doExport = function(url, dg, inputs) {
  $.messager.defaults = { ok:"当前页数据", cancel:"所有页数据" };
  //导出当前页的数据?导出符合条件的所有数据?
  $.messager.confirm('导出', '选择导出查询结果里的：', function(isCurrent){
      var form = jsUtil.getDefaultExportForm(url, dg, isCurrent);
      if (inputs != null) {
          // 其他查询条件
          for (var i = 0; i < inputs.length; i++) {
              form.append(inputs[i]);
          }
      }
      jsUtil.submitExportForm(form);
  });
  $.messager.defaults = { ok:"确定", cancel:"取消" };
}
/**
 * 导出方法，无其他附加条件，按后台逻辑导出数据
 */
jsUtil.doDefaultExport = function(url, dg) {
   var form = jsUtil.getDefaultExportForm(url, dg);
   jsUtil.submitExportForm(form);
}
/**
 * 构造导出form，默认提交分页信息，列表字段和字段显示名信息
 */
jsUtil.getDefaultExportForm = function(url, dg, isCurrent) {
  var form = $("<form>");
  form.attr('style', 'display:none');
  form.attr('target', '');
  form.attr('method', 'post');
  form.attr('action', url);
  $('body').append(form);
  var defaultInputs = jsUtil.getDefaultInputs(url, dg, isCurrent);
  for (var i = 0; i < defaultInputs.length; i++) {
      form.append(defaultInputs[i]);
  }
  return form;
}
/**
 * 导出form的默认提交参数，包括分页信息，列表字段和字段显示名信息
 */
jsUtil.getDefaultInputs = function(url, dg, isCurrent) {
  var inputs = [];
  var page = $('<input>');
  page.attr('type', 'hidden');
  page.attr('name', 'page');
  var rows = $('<input>');
  rows.attr('type', 'hidden');
  rows.attr('name', 'rows');
  //导出当前页的数据?导出符合条件的所有数据?
  if (isCurrent) {
      page.attr('value', dg.datagrid('options').pageNumber);
      rows.attr('value', dg.datagrid("options").pageSize);
  } else {
      page.attr('value', 1);
      rows.attr('value', 2147483647);
  }

  var sort = $('<input>');
  sort.attr('type', 'hidden');
  sort.attr('name', 'sort');
  sort.attr('value', dg.datagrid('options').sortName);

  var order = $('<input>');
  order.attr('type', 'hidden');
  order.attr('name', 'order');
  order.attr('value', dg.datagrid('options').sortOrder);

  var fields = $('<input>');
  fields.attr('type', 'hidden');
  fields.attr('name', 'fields');
  fields.attr('value', jsUtil.getFields(dg));

  var titles = $('<input>');
  titles.attr('type', 'hidden');
  titles.attr('name', 'titles');
  titles.attr('value', jsUtil.getTitles(dg));

  inputs.push(page);
  inputs.push(rows);
  inputs.push(sort);
  inputs.push(order);
  inputs.push(fields);
  inputs.push(titles);
  return inputs;
};
/**
 * 导出form的列表字段
 */
jsUtil.getFields = function(dg) {
  var columns = dg.datagrid("options").columns[0];
  var json = '';
  if (columns) {
      for (var i = 0; i < columns.length; i++) {
          var field = columns[i].field;
          var title = columns[i].title;
          var hidden = columns[i].hidden;
          if (!hidden) {
              json += field + ','
          }
      }
      if (json != '') {
          json = json.substring(0, json.length - 1);
      }
  }
  return json;
};
/**
 * 导出form的列表字段显示名称
 */
jsUtil.getTitles = function(dg) {
  var columns = dg.datagrid("options").columns[0];
  var json = '';
  if (columns) {
      for (var i = 0; i < columns.length; i++) {
          var field = columns[i].field;
          var title = columns[i].title;
          var hidden = columns[i].hidden;
          if (!hidden) {
              json += title + ','
          }
      }
      if (json != '') {
          json = json.substring(0, json.length - 1);
      }
  }
  return json;
};

    原文地址： http://colalife.com/blog/2013/01/excel-dao-chu-gong-ju-lei.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[Htmlparser和httpclient解析页面并下载]]> 2012-12-18T03:05:41+08:00 http://colalife.com/blog/2012/12/htmlparserhe-httpclientjie-xi-ye-mian-bing-xia-zai 如果你想抓取某个网页（如新浪、csdn之类）获取最新资讯列表，或者到某个站点下载文件、图片之类，就需要html解析例如htmlparser,jsoup之类的jar包，下载可用httpclient。如果想更高效率可以搞线程池，抓取解析线程和下载线程，类似消费者和生产者模型（此处不涉及，仅演示使用），代码如下：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    public static Set<String> digLinks(String address) throws Exception {
  Set<String> result = new HashSet<String>();
  URL url = new URL(address);
  Parser parser = new Parser((HttpURLConnection) url.openConnection());
  NodeFilter filter = new HasAttributeFilter("id", "someid");
  NodeList nodes = parser.extractAllNodesThatMatch(filter);
  Node root = nodes.elementAt(0);
  String html = root.getChildren().toHtml();
  parser = Parser.createParser(html, "utf-8");
  nodes = parser.extractAllNodesThatMatch(new TagNameFilter("li"));
  parser = Parser.createParser(html, "utf-8");
  nodes = parser.extractAllNodesThatMatch(new TagNameFilter("a"));
  add(result, nodes);
  return result;
}

private static void add(Set<String> result, NodeList nodes) {
  for (int i = 0; i < nodes.size(); i++) {
      Node child = nodes.elementAt(i);
      if (child instanceof LinkTag) {
          LinkTag linknode = (LinkTag) child;
          String href = linknode.getLink();
          result.add(href);
      }
  }
}

    httpclient 下载 

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

    /**
 * 读出文件中的url，连接下载保存
 * @param file
 */
public static void doSave(String file) {
  List<String> files = FileUtil.readLines(file);
  for (String url : files) {
      String fileName = StringUtils.substringAfterLast(url, "/");
      download(url, fileName);
  }
}

private static void download(String url, String fileName) {
  OutputStream out = null;
  InputStream in = null;
  HttpURLConnection connection = null;
  URL server = null;
  try {
      server = new URL(url);
      connection = (HttpURLConnection) server.openConnection();
      connection.connect();
      in = connection.getInputStream();

      File file = new File(dir + fileName);
      if (file.exists()) {
          return;
      }
      out = new FileOutputStream(file);
      int b = in.read();
      while (b != -1) {
          out.write(b);
          b = in.read();
      }
      in.close();
      out.close();
  } catch (Exception e) {
  }
}

    原文地址： http://colalife.com/blog/2012/12/htmlparserhe-httpclientjie-xi-ye-mian-bing-xia-zai.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[[转]深入理解浏览器兼容性模式]]> 2012-11-02T01:27:53+08:00 http://colalife.com/blog/2012/11/zhuan-shen-ru-li-jie-liu-lan-qi-jian-rong-xing-mo-shi web开发人员遇到浏览器兼容简直就是噩梦，尤其各种ie内核的浏览器，还有搜狗、360等；这篇文章讲得比较详细，转了来自图灵社区
    正文 ——
    关于各种浏览器模式，网上已经有许多文档和资料了，但是很少有能够完全将几个概念阐述清楚的。大部分的资料稍显过时，有些内容可能已经不再适用了。本文中笔者将尽可能将几个概念阐述清楚，并去掉一些过时的内容，仅保留必要的干货。

    想必你一定知道浏览器有个标准（Standards）模式和一个怪异（Quirks）模式，或许你还听说过有个“准标准（Almost Standards）”模式。而当你打开 Internet Explorer 的时候，又看到了什么浏览器模式、文档模式，还有什么兼容性视图等等…

    这些都是什么？啥是浏览器模式，啥是文档模式？标准模式和准标准的模式有什么区别？IE9兼容性视图和真正的IE9有什么区别？什么情况下会触发这些模式，又该怎样才能检测到浏览器当前处于哪种模式中呢？本文将详细为你解答这些疑问。

    三种模式

    首先我们要知道，为什么会有这么多模式。其实这是个历史遗留问题，在浏览器大战时期，网景浏览器（Netscape Navigator）和微软的IE浏览器（Microsoft Internet Explorer）对网页分别有不同的实现方式，那个时候的网页要针对这两种浏览器分别开发不同的版本。而到了 W3C 制定标准之后，这些浏览器就不能继续使用这种页面了，因而会导致大部分现有站点都不能使用。基于这个原因，浏览器才引入两种模式来处理一些遗留的站点。

    现在的浏览器排版引擎支持三种模式：怪异（Quirks）模式、准标准（Almost Standards）和标准（Standards）模式。在怪异模式中，排版引擎会模拟 网景4 和 Windows 中的 IE5 的行为；在完全标准的模式中，会尽量执行 HTML 和 CSS 规范所指定的行为；而在准标准模式中，则只包含很少的一部分怪异模式中的行为。

    那么所谓标准模式，就一定都“标准”吗？答案当然是否定的，因为各个浏览器厂商实现标准的阶段不同，所以各个浏览器的“标准模式”之间也会有很大的不同。

    Firefox、Safari、Chrome、Opera (自 7.5 以后)、 IE8 和 IE9 都有一个准标准模式。那么既然标准模式都不那么标准，准标准的模式肯定就更不标准了。最初的准标准模式只会影响表格中的图像，而后来各个浏览器又或多或少地进行了修改。那么什么情况下会触发准标准模式呢？是的，正如你所想到的，某些 DOCTYPE 会触发准标准模式，例如：

    1
2
3
4
5

    "-//W3C//DTD XHTML 1.0 Transitional//EN"
"-//W3C//DTD XHTML 1.0 Frameset//EN"
"-//W3C//DTD HTML 4.01 Transitional//EN"
"-//W3C//DTD HTML 4.01 Frameset//EN"
"http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"

    一个完整的 DOCTYPE 例子如下：

    <!DOCTYPE HTML PUBLIC “–//W3C//DTD HTML 4.01 Transitional//EN”

                      "http://www.w3.org/TR/html4/loose.dtd">

    如果在 Firefox 中插入这种 DOCTYPE，并在页面中插入一个空的 span 标签，那么在 Firebug 中查看元素的布局就会发现不同：

    准标准模式中元素的 line-height 被忽略了，元素既没有宽度也没有高度：

    Almost Standards

    标准模式中元素仍然保留了 line-height，拥有 18px 的高度：

    Standards

    在 Firefox 浏览器中，使用鼠标右键 –> 查看页面信息 可以看到当前浏览器运行在何种模式（只能看到“混杂模式”和“标准规范模式”两种表示）：

    mozilla-standard-mode

    有位大神 Henri Sivonen 曾写过一篇文章叫做 Activating Browser Modes with Doctype，里面包含了一个完整的表格，展示了各种 DOCTYPE 设置将会使浏览器以何种方式渲染。这里还有一篇 秦歌 的译文 《用doctype激活浏览器模式》。

    鉴于目前一些最新版本的浏览器已经放弃了准标准模式，所以关于准标准模式的细节这里就不再赘述了，感兴趣的同学可以详细阅读以下资料：

    Gecko’s “Almost Standards” Mode

    Line Height Calculations in Almost Standards Mode

    Images, Tables, and Mysterious Gaps

    almost-standards test

    DOCTYPE Switches support in Opera Presto 2.10

    那么，既然这么多的 DOCTYPE 都会触发非标准的模式，那么如何才能触发标准模式呢？对了！要使用 HTML5 DOCTYPE，即：

    <!DOCTYPE html> 注意：如果文档中没有包含 DOCTYPE 或者包含了一个无法识别的 DOCTYPE，则浏览器就会进入怪异模式。

    下面简单说一下怪异模式。怪异模式有许多“怪异”的行为，主要是为了兼容那些遗留的古老页面而保留的模式。不同浏览器的怪异模式也不尽相同，它们都有自己的实现方式。怪异模式与标准模式的差异主要体现在 盒模型（box model）、表格单元格高度的处理等。例如 IE 的怪异模式中，元素的 width 包含了 padding 和 border，而标准模式中 padding 和 border 并不属于宽度的一部分。

    若想详细了解浏览器在怪异模式下的行为，可以参看下面两篇文章。不过不建议在这上面花太多的精力，这是个历史遗留问题，而且我们也尽量保证新开发的页面不要进入到怪异模式：

    Mozilla Quirks Mode Behavior

    What happens in Quirks Mode?

    Compatability Mode Test

    小结： 至此我们需要了解，浏览器有三种运行模式，即标准模式、准标准模式和怪异模式，要使用 <!DOCTYPE html> 来正确地触发标准模式。千万不要丢掉 DOCTYPE 声明，因为这会导致浏览器进入怪异模式。

    IE的浏览器模式

    IE8有4种模式：IE5.5怪异模式、IE7标准模式、IE8 准标准模式和IE8标准模式，而IE9有7种模式: IE5.5怪异模式、IE7标准模式、IE8准标准模式、IE8标准模式、IE9准标准模式、IE9标准模式、XML模式。

    其中 XML模式 是针对 XML 文档的，这里不打算阐述，细节可以看这篇文章Defining Document Compatibility.aspx) 中有详细阐述。

    在 IE8 及以后的的 IE 浏览器中，支持 X-UA-Compatible 头，可以通过在服务器端设置 HTTP 头，或者在页面中插入 标签来实现：

    1
2
3
4
5

    HTTP:
Header set X-UA-Compatible "IE=8"

Meta:
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" />

    这种方法主要是防止老的页面在较新的浏览器中显示不正常的情况的， 比如上面的代码可以强制 IE8 以上版本的浏览器以IE7的模式进行渲染。

    注意，不要在新开发的网页中使用这种技术，这种技术只应该作为新老网页更替过程中的过渡方案。由于目前新开发的网页都是尽量支持最新版本的浏览器的，所以这种技术也会慢慢被淘汰，感兴趣的同学可以详细阅读 微软的这篇文档。

    小结： 这里我们需要知道有这种方式可以强制浏览器以某种模式运行，但只应作为过渡方案，不应在新开发的网页中使用。

    IE9 兼容性视图 与 IE9 标准视图

    如果你使用的是 IE9，那么按下 F12 键就会出现开发者工具，上面有两个下拉菜单：浏览器模式 和 文档模式。那么什么是浏览器模式？什么又是文档模式？二者有何区别？

    浏览器模式用于切换IE针对该网页的默认文档模式、对不同版本浏览器的条件注释解析、以及发送给网站服务器的用户代理（User-Agent）字符串的值。网站可以根据浏览器返回的不同用户代理字符串判断浏览器的版本和及安装的功能，这样就可以根据不同的浏览器返回不同的页面内容了。

    文档模式用于指定IE的页面排版引擎（Trident）以哪个版本的方式来解析并渲染网页代码。切换文档模式会导致网页被刷新，但不会更改用户代理字符串中的版本号，也不会从服务器重新下载网页。切换浏览器模式的同时，浏览器也会自动切换到相应的文档模式。

    一言以蔽之，浏览器模式会影响服务器端对客户端浏览器版本的判断，对条件注释也有影响；而文档模式会影响IE的排版引擎，对网页渲染会有影响，对 CSS hack 也会产生影响。因此，通过条件注释可以判断浏览器模式，而使用 CSS hack 可以判断文档模式。

    如果我们使用一句简单的 JavaScript 语句来查看用户代理（User-Agent）字符串的值，则可以看到 IE9 兼容性视图 与 IE9 的区别：

    1
2
3

    <script type="text/javascript">
    alert('UA:'+navigator.userAgent);
</script>

    输出结果如下所示，注意其中的 MSIE 版本号已经不同。判断浏览器模式就是判断 User-Agent 中的版本号，即 MSIE 后面的数值：

    // IE9 UA:Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; Tablet PC 2.0)

    // IE9 兼容性视图 UA:Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; Tablet PC 2.0) 话说 IE9 兼容性视图 是模拟IE7的行为，那么 IE9 兼容性视图 与 IE7 有没有区别呢？肯定是有区别的，即使是 IE9 中的 IE7标准模式，与原生的IE7在渲染上也是有区别的，具体我们暂不去深究。

    那么既然 IE9 兼容性视图 的版本号跟 IE7 相同，如何才能判断当前是 IE9 兼容性视图，还是纯正的 IE7 呢？其实很简单，只需要判断浏览器的用户代理（User-Agent）字符串中是否包含 Trident 即可。首先检测 MSIE 的版本号是否为 7.0，然后再判断是否含有 Trident 字串，若包含则为 IE9 兼容性视图，否则则为纯正的 IE7。

    小结： 至此，你应该了解了什么是浏览器模式、什么是文档模式以及它们之间的区别了，另外还了解了 IE9 兼容性视图 与 IE9 以及 IE7 的区别。

    控制默认的渲染方式

    当 Internet Explorer 9 遇到未包含 X-UA-Compatible 标头的网页时，它将使用 <!DOCTYPE> 指令来确定如何显示该网页。 如果该指令丢失或未指定基于标准的文档类型，则 Internet Explorer 9 将以 IE5 模式（怪异模式）来显示该网页。

    如果 <!DOCTYPE> 指令指定了基于标准的文档类型，则 Internet Explorer 9 将以 IE9 模式显示该网页，但出现以下情况时除外：

    为该网页启用了兼容性视图。 该网页是在 Intranet 区域中加载的，并且已将 Internet Explorer 9 配置为使用兼容性视图来显示 Intranet 区域中的网页。 已将 Internet Explorer 9 配置为使用兼容性视图来显示所有网站。 已将 Internet Explorer 9 配置为使用兼容性视图列表（其实是个黑名单，其中指定了一组始终使用兼容性视图显示的网站）。 已使用开发人员工具覆盖在该网页中指定的设置。 该网页遇到了页面布局错误，并且已将 Internet Explorer 9 配置为，通过在兼容性视图中重新打开网页来自动从此类错误中恢复。 此外，可以使用下面的注册表项来控制 Internet Explorer 对未包含 X-UA-Compatible 标头的页面的处理方式。

    1
2
3
4
5
6
7
8

    HKEY_LOCAL_MACHINE (or HKEY_CURRENT_USER)
     SOFTWARE
          Microsoft
               Internet Explorer
                    Main
                         FeatureControl
                              FEATURE_BROWSER_EMULATION
                                   iexplore.exe = (DWORD)

    其中 DWORD 值必须等于下列值之一：

    值 说明 7000 包含基于标准的 <!DOCTYPE> 指令的页面将以 IE7 模式显示。 8000 包含基于标准的 <!DOCTYPE> 指令的页面以 IE8 模式显示。 8888 页面始终以 IE8 模式显示，而不考虑 <!DOCTYPE> 指令。 （这可绕过前面列出的例外情况。） 关于IE浏览器确定文档模式的整个流程，可以参看这篇文章 How IE8 Determines Document Mode，文中详细阐述了整个流程与内部机制。

    小结： 仍然坚持使用 <!DOCTYPE html>，可最大程度减小发生错误的几率。

    文档模式的检测

    在 JavaScript 中可以通过 documentMode 来检测文档模式，在 IE6 和 IE7 中是使用 compatMode 来确定文档模式的，这个属性自 IE8 开始已经被 documentMode 所替代。

    那么，如果需要兼容 IE6 和 IE7 的话（必须的 …），则相应的检测代码大致如下：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    engine = null;
if (window.navigator.appName == "Microsoft Internet Explorer")
{
   // This is an IE browser. What mode is the engine in?
   if (document.documentMode) // IE8 or later
      engine = document.documentMode;
   else // IE 5-7
   {
      engine = 5; // Assume quirks mode unless proven otherwise
      if (document.compatMode)
      {
         if (document.compatMode == "CSS1Compat")
            engine = 7; // standards mode
      }
      // There is no test for IE6 standards mode because that mode
      // was replaced by IE7 standards mode; there is no emulation.
   }
   // the engine variable now contains the document compatibility mode.
}

    IE6 和 IE7 中的 compatMode 有两个可能的值“CSS1Compat”和“BackCompat ”，分别对应了 IE6 和 IE7 中的标准模式和怪异模式。上面的代码首先假定是怪异模式，然后再试图推翻假设。这里没有包含“IE6 标准模式”，因为它已经被 IE7标准模式 所替代，没有模拟的情况。

    这里要注意，不同的文档模式对 JavaScript 也有一些影响，我们不必去深究不同文档模式对 JavaScript 有何种不同影响，只需要在编码时进行特定的 特性检测 即可。

    小结： 一般情况下是没必要进行文档模式检测的，对于样式兼容我们可以写 CSS hack，而对于 JavaScript 来说，则更加推荐特性检测，而不是检测浏览器本身。

    浏览器模式与文档模式之间的关系

    浏览器模式可以决定页面默认的文档模式，但文档模式可能会受其他因素影响而改变，如上文所述。如果浏览器模式与文档模式设置不同的话，会不会有什么影响呢？

    我们已经知道浏览器模式主要用于标识浏览器本身，原则上不会对页面渲染产生影响。但是我们又知道，浏览器模式可以影响条件注释，所以如果你的页面中有条件注释的话，那么浏览器模式的变化就会影响到页面渲染。

    服务器端只能通过浏览器模式所标识的版本来确定客户端浏览器的版本，如果你将浏览器模式标识为IE9，但文档模式选择为IE7标准的话，就可能会有问题。不过这还要看服务器端是否有针对不同浏览器的处理策略，如果服务器端并未对不同浏览器的输出做差异化处理的话，那么这两个模式选项不同就不会有问题。

    小结： 如果服务器端对不同浏览器的输出做了差异化处理，那么浏览器模式和文档模式不一致就可能产生问题。

    原文地址： http://colalife.com/blog/2012/11/zhuan-shen-ru-li-jie-liu-lan-qi-jian-rong-xing-mo-shi.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[测试Hibernate动态添加实体类]]> 2012-09-28T07:54:33+08:00 http://colalife.com/blog/2012/09/ce-shi-hibernatedong-tai-tian-jia-wei-pei-zhi-de-shi-ti-lei 大家知道通过hibernate cfg或和spring集成的配置里，可用packagesToScan或mapping*之类声明实体类；但有需求可能要在某个项目中编码式加载实体类（例如某个不常用的或特定用户的实体类，并未事先配置），然后进行增删改查操作。下面代码配合spring test framework做了测试（注：hibernate升级到了4.3.final，与4.2有不同，spring3或4测试通过）：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/spring-hibernate.xml" })
public class ConfigurationTest extends AbstractJUnit4SpringContextTests {
    public static final String session_factory = "sessionFactory";
  // 值得注意: org.springframework.beans.factory.FactoryBean that creates a Hibernate org.hibernate.SessionFactory
  public static final String local_session_factory = "&sessionFactory";

  @Test
  public void sessionFactoryAndFactoryBean() throws ClassNotFoundException {
      SessionFactory sessionFactory = (SessionFactory) applicationContext.getBean(session_factory);
      Map<String, ClassMetadata> meta = sessionFactory.getAllClassMetadata();
      for (Entry<String, ClassMetadata> each : meta.entrySet()) {
          ClassMetadata value = each.getValue();
          System.out.println("entity name:" + value.getEntityName());
      }

      LocalSessionFactoryBean sessionFactoryBean = (LocalSessionFactoryBean) applicationContext.getBean(local_session_factory);

      Configuration config = sessionFactoryBean.getConfiguration();
      config.addAnnotatedClass(User.class);
      ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();
      SessionFactory newSessionFactory = config.buildSessionFactory(serviceRegistry);
      Session session = newSessionFactory.openSession();

      User user = new User();
      user.setName("username");
      session.save(user);
      session.flush();

      user = (User) session.get(User.class, user.getId());
      session.close();
      System.out.println("------" + user.getId());
      System.out.println("------" + user.getName());

      Iterator<Table> mappings = config.getTableMappings();
      while (mappings.hasNext()) {
          Table each = mappings.next();
          System.out.println("table name:" + each.getName());
      }

  }
}

    原文地址： http://colalife.com/blog/2012/09/ce-shi-hibernatedong-tai-tian-jia-wei-pei-zhi-de-shi-ti-lei.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[关于公司技术管理工作的几点思考]]> 2011-04-14T15:06:42+08:00 http://colalife.com/blog/2011/04/guan-yu-gong-si-ji-zhu-guan-li-gong-zuo-de-ji-dian-si-kao 一. 关于文档规范

    文档规范化正在形成的过程中，具体标准根据项目大小、要求、进度等不同而不同。开发人员写文档的能力向来是个短板，多看多借鉴国标、成熟的开发过程以及其他公司的文档，明白知道各文档所应涵盖的内容，学会并提高文档书写水平，是文档规范化的前提。在此基础之上，再召开会议讨论制定文档规范化模板，制定公司特色的文档体系才是可行的。

    二. 关于需求理解、分析设计

    一般来讲，前期与客户沟通的不充分，调研工作不充分而产生需求理解上的偏差（如果排除人员能力水平、方法上的问题的话）是导致接下来分析设计以及开发工作偏差和反复修改的重要原因，并且有损开发人员的工作热情。因此，我提议重视和做好调研和需求分析工作，并在项目开始阶段召开几次分析会议，项目组成员充分讨论，每次会议都要评分，以使项目组员对项目需求和设计的理解程度达到进行开发的要求。

    三. 关于项目产出物的管理

    如各类文档、各类资料、可复用模块、产品化软件，需要制定出制度和管理流程，以达到规范化管理。涉及到具体的要求和流程，需要先制定出思路和计划，讨论研究。

    四. 关于产品化开发和模块复用封装

    就现在来看，公司已经积累了若干项目，其中的功能有可以剥离出来封装服用的，同时这项工作也有难度，它很大程度上需要大家有扎实的开发基础，良好的代码编写习惯，要写出逻辑清晰、方便调用的代码来。我的看法是简单的功能可以封装的先完成，以供日常使用；同时讨论、借鉴、探求产品化思路，制定实施规划。

    五. 关于项目管理

    项目开发过程中经常会出现各种问题，比如在团队建设、人员管理、与客户沟通以及编码开发、测试等各方面，人与人相处，尤其工作当中，难免出现误会争吵，实属正常，对事不对人就好。我所观察，项目开发中最大的矛盾可能是工作量大、时间紧张与开发人员能力、效率不高之间的矛盾了；我们需要可能是较长一段时间继续在项目开发中锻炼和成长；我所担心，无论是技术总监、项目经理、组长还是开发人员，会慢慢成为项目组乃至公司的短板，还是要关注自己，提高自己的能力。

    六. 关于技术水平提高

    如果最终的需求、产品、网站、系统以及客户给钱都是落在代码上，我们就无法忽略代码的重要性；因为大家每天大部分的时间都在敲代码，如果你珍惜你的时间而不是浪费，你也会去想到底如何才能写出整洁规范的代码，也无法忽略编码水平提高的需要；如果你要修改别人的代码，看到的却像是一地鸡毛，无从下手，影响心情，那你应该想一想你自己的代码是否在别人看也是这样；如何去从源头控制bug数量，提高代码的正确性、健壮性等等，关于代码的很多都是值得我们关注的。我认为代码审查机制是需要的，从规范性着手，从每周或每天的code review开始，改善我们的代码。另外一方面就是购置学习书籍，可以由全体员工积极推荐书目，大家投票决定是否购置，而且不限于技术方面。

    七. 关于框架开发

    我所计划框架的演进是有一个路线图的，从ibatis+struts，到ssh，到现在ss，以及ssh2或sh等等。实际上，如果项目经理或技术经理一直停留在一个框架上或是从外派公司拿的，只因为他很熟悉，那么势必造成组员技术水平的停滞不前甚至下降。虽然我一直维护框架文档并不时的更新，框架源码去年时候就发布出来，但是很多人没有认真看，遇到问题仍然不知怎样解决。培训时候就学习ssh，现在的开发框架也是ssh，大部分的功能都一样，不客气地讲，不会用的原因就是struts，spring，hibernate基础不牢固。待这几个项目做完，各人对框架应该是很上手加熟悉了，下一步的计划就是在重新开发自己的框架，类似开源项目，每个人都可以开发修改、维护这个框架，当然，前提是代码水平和编码习惯要改善。

    另：关于员工职业规划

    新员工培训中有职业素养，而对于工作一年和两年以上的员工，职场相关的交流和学习就比较少，如果能让大家成长成一个职业化、专业化、高效能的职业人士会在很大程度上促进公司的发展。

    以上七个方面依然是我接下来工作的主要内容，需要按部就班推进执行。

    审查年初的工作计划，存在规划粗略、执行的资源如工作时间、人力资源等不足的问题，其中应在接下来的年度继续规划和执行的工作如：
    1、规范开发流程，这在项目管理体系中属于组织过程资产，是一个长期积累，不断发展的过程。
    2、组织技术培训，是因为公司高度重视对人的培养，并为公司发展战略服务，通过帮助员工提升工作绩效和个人能力，推动员工与公司的共同成长。员工不仅可以选择技术、设计、产品、市场等专业技能发展通道，也可以有项目管理的发展通道。这项工作的开展需要管理层的支持。
    3、产品研发的工作无论从技术上还是管理上都不同于普通项目，这方面我们的知识和经验不足，需要一个规划、学习、摸索实践以及积累的过程。

    关于项目管理，之前项目管理工作中，如果有项目管理知识体系这些理论作为指导，去开展项目工作，问题会少很多，项目工作的效率和效果也会好很多。现在公司项目管理可改进的方面我认为：
    1、客户相关的，涉及到项目范围、变更、沟通等，有效的管理客户是一个值得努力的方向；
    2、人力资源相关，如团队建设和管理等，提高团队绩效、个人能力等方面是我们工作中需要关注和努力的。
    3、成本和质量相关，需要我们在项目开发工作中重视项目工作的成本和项目完成的质量。

    新的一年里，公司面临新的机遇和新的挑战，亟需深耕行业，形成自己的业务体系和战略布局，中级管理层人员更要提高业务和管理能力，为公司发展做出贡献。

    原文地址： http://colalife.com/blog/2011/04/guan-yu-gong-si-ji-zhu-guan-li-gong-zuo-de-ji-dian-si-kao.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[9种排序算法的java实现]]> 2010-08-09T13:09:09+08:00 http://colalife.com/blog/2010/08/jiu-zhong-pai-xu-suan-fa-de-javashi-xian 使用枚举类型存入各算法和接口实现，main方法打印排序后的数组，也可以加入nanotime、currentTimeMillis测试效率，但可能数组太小不明显

    1
2
3
4
5
6
7

    package comcolalife.demo.sort;
import java.util.Arrays;
/**
 * 冒择入希快(快改进)归(归改进)堆：9种排序算法的java实现
 * @author wangchaoqun
 */
public class SortTest {

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418

    public static void main(String[] args) {
  int[] original = { 1, 3, 1, 10, 4, 8, 5, 21, 43, 29, 53 };
  // 执行排序算法
  for (Sorts each : Sorts.values()) {
      System.out.print(each.name() + "   ");
      int[] data = Arrays.copyOf(original, original.length);
      each.impl().sort(data);
      print(data);
  }
  // java.util.Arrays类使用调优的快速排序法
  Arrays.sort(original);
  print(original);
}

public static void print(int[] data) {
  for (int each : data) {
      System.out.print(each + " ");
  }
  System.out.println();
}
}

/**
 * 插入排序算法
 */
class InsertSort implements Sort {
public void sort(int[] data) {
  for (int i = 1; i < data.length; i++) {
      for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
          SortUtil.swap(data, j, j - 1);
      }
  }
}
}

/**
 * 冒泡排序算法
 */
class BubbleSort implements Sort {
public void sort(int[] data) {
  for (int i = 0; i < data.length; i++) {
      for (int j = data.length - 1; j > i; j--) {
          if (data[j] < data[j - 1]) {
              SortUtil.swap(data, j, j - 1);
          }
      }
  }
}

}

/**
 * 选择排序算法
 */
class SelectionSort implements Sort {
public void sort(int[] data) {
  for (int i = 0; i < data.length; i++) {
      int lowIndex = i;
      for (int j = data.length - 1; j > i; j--) {
          if (data[j] < data[lowIndex]) {
              lowIndex = j;
          }
      }
      SortUtil.swap(data, i, lowIndex);
  }
}

}

/**
 * 希尔排序算法
 */
class ShellSort implements Sort {
public void sort(int[] data) {
  for (int i = data.length / 2; i > 2; i /= 2) {
      for (int j = 0; j < i; j++) {
          insertSort(data, j, i);
      }
  }
  insertSort(data, 0, 1);
}

private void insertSort(int[] data, int start, int inc) {
  for (int i = start + inc; i < data.length; i += inc) {
      for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
          SortUtil.swap(data, j, j - inc);
      }
  }
}

}

/**
 * 快速排序算法
 */
class QuickSort implements Sort {
public void sort(int[] data) {
  quickSort(data, 0, data.length - 1);
}

private void quickSort(int[] data, int first, int last) {
  if (first >= last) {
      return;
  }

  int pivot = partition(data, first, last, first);
  quickSort(data, first, pivot - 1);// 对左半段排序
  quickSort(data, pivot + 1, last);// 对右半段排序

}

private int partition(int[] data, int first, int last, int pivot) {
  while (true) {
      while (data[++first] < data[pivot])
          ;
      while (data[--last] > data[pivot])
          ;
      if (first >= last) {
          break;
      }
      SortUtil.swap(data, first, last);
  }
  SortUtil.swap(data, last, pivot);
  return last;
}

}

/**
 * 改进的快速排序算法
 */
class ImprovedQuickSort implements Sort {
private static int MAX_STACK_SIZE = 4096;
private static int THRESHOLD = 10;

public void sort(int[] data) {
  int[] stack = new int[MAX_STACK_SIZE];

  int top = -1;
  int pivot;
  int pivotIndex, l, r;

  stack[++top] = 0;
  stack[++top] = data.length - 1;

  while (top > 0) {
      int j = stack[top--];
      int i = stack[top--];

      pivotIndex = (i + j) / 2;
      pivot = data[pivotIndex];

      SortUtil.swap(data, pivotIndex, j);

      // partition
      l = i - 1;
      r = j;
      do {
          while (data[++l] < pivot)
              ;
          while ((r != 0) && (data[--r] > pivot))
              ;
          SortUtil.swap(data, l, r);
      } while (l < r);
      SortUtil.swap(data, l, r);
      SortUtil.swap(data, l, j);

      if ((l - i) > THRESHOLD) {
          stack[++top] = i;
          stack[++top] = l - 1;
      }
      if ((j - l) > THRESHOLD) {
          stack[++top] = l + 1;
          stack[++top] = j;
      }
  }
  insertSort(data);
}

private void insertSort(int[] data) {
  for (int i = 1; i < data.length; i++) {
      for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
          SortUtil.swap(data, j, j - 1);
      }
  }
}

}

/**
 * 归并排序算法
 */
class MergeSort implements Sort {
public void sort(int[] data) {
  int[] temp = new int[data.length];
  mergeSort(data, temp, 0, data.length - 1);
}

private void mergeSort(int[] data, int[] temp, int left, int right) {
  if (left == right) {
      return;
  }
  int mid = (left + right) / 2;
  mergeSort(data, temp, left, mid);
  mergeSort(data, temp, mid + 1, right);
  for (int i = left; i <= right; i++) {
      temp = Arrays.copyOf(data, data.length);
  }
  int i1 = left;
  int i2 = mid + 1;
  for (int cur = left; cur <= right; cur++) {
      if (i1 == mid + 1) {
          data[cur] = temp[i2++];
      } else if (i2 > right) {
          data[cur] = temp[i1++];
      } else if (temp[i1] < temp[i2]) {
          data[cur] = temp[i1++];
      } else {
          data[cur] = temp[i2++];
      }
  }
}

}

/**
 * 改进的归并排序算法
 */
class ImprovedMergeSort implements Sort {
private static final int THRESHOLD = 10;

public void sort(int[] data) {
  int[] temp = new int[data.length];
  mergeSort(data, temp, 0, data.length - 1);
}

private void mergeSort(int[] data, int[] temp, int left, int right) {
  int i, j, k;
  int mid = (left + right) / 2;
  if (left == right) {
      return;
  }
  if ((mid - left) >= THRESHOLD) {
      mergeSort(data, temp, left, mid);
  } else {
      insertSort(data, left, mid - left + 1);
  }
  if ((right - mid) > THRESHOLD) {
      mergeSort(data, temp, mid + 1, right);
  } else {
      insertSort(data, mid + 1, right - mid);
  }
  for (i = left; i <= mid; i++) {
      temp = Arrays.copyOf(data, data.length);
  }
  for (j = 1; j <= right - mid; j++) {
      temp[right - j + 1] = data[j + mid];
  }
  int a = temp[left];
  int b = temp[right];
  for (i = left, j = right, k = left; k <= right; k++) {
      if (a < b) {
          data[k] = temp[i++];
          a = temp[i];
      } else {
          data[k] = temp[j--];
          b = temp[j];
      }
  }
}

private void insertSort(int[] data, int start, int len) {
  for (int i = start + 1; i < start + len; i++) {
      for (int j = i; (j > start) && data[j] < data[j - 1]; j--) {
          SortUtil.swap(data, j, j - 1);
      }
  }
}

}

/**
 * 堆排序算法
 */
class HeapSort implements Sort {
public void sort(int[] data) {
  MaxHeap h = new MaxHeap();
  h.init(data);
  for (int i = 0; i < data.length; i++) {
      h.remove();
  }
  System.arraycopy(h.queue, 1, data, 0, data.length);
}

private static class MaxHeap {
  void init(int[] data) {
      this.queue = new int[data.length + 1];
      for (int i = 0; i < data.length; i++) {
          queue[++size] = data[i];
          fixUp(size);
      }
  }

  private int size = 0;
  private int[] queue;

  public void remove() {
      SortUtil.swap(queue, 1, size--);
      fixDown(1);
  }

  // fixdown
  private void fixDown(int k) {
      int j;
      while ((j = k << 1) <= size) {
          if (j < size && queue[j] < queue[j + 1]) {
              j++;
          }
          if (queue[k] > queue[j]) { // 不用交换
              break;
          }
          SortUtil.swap(queue, j, k);
          k = j;
      }
  }

  private void fixUp(int k) {
      while (k > 1) {
          int j = k >> 1;
          if (queue[j] > queue[k]) {
              break;
          }
          SortUtil.swap(queue, j, k);
          k = j;
      }
  }

}

}

/**
 * 排序算法接口
 */
interface Sort {
public void sort(int[] data);
}

/**
 * 排序算法枚举
 */
enum Sorts {
INSERT() {
  public Sort impl() {
      return new InsertSort();
  }
},
BUBBLE() {
  public Sort impl() {
      return new BubbleSort();
  }
},
SELECTION() {
  public Sort impl() {
      return new SelectionSort();
  }
},
SHELL() {
  public Sort impl() {
      return new ShellSort();
  }
},
QUICK() {
  public Sort impl() {
      return new QuickSort();
  }
},
IMPROVED_QUICK() {
  public Sort impl() {
      return new ImprovedQuickSort();
  }
},
MERGE() {
  public Sort impl() {
      return new MergeSort();
  }
},
IMPROVED_MERGE() {
  public Sort impl() {
      return new ImprovedMergeSort();
  }
},
HEAP() {
  public Sort impl() {
      return new HeapSort();
  }
};

public abstract Sort impl();
}

/**
 * 排序算法工具类
 */
class SortUtil {
public static void swap(int[] data, int i, int j) {
  int temp = data[i];
  data[i] = data[j];
  data[j] = temp;
}

public static void print(int[] data) {
  for (int each : data) {
      System.out.print(each + " ");
  }
  System.out.println();
}
}

    原文地址： http://colalife.com/blog/2010/08/jiu-zhong-pai-xu-suan-fa-de-javashi-xian.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[宁静（二）]]> 2009-07-09T14:40:21+08:00 http://colalife.com/blog/2009/07/ning-jing-2 我已经开始喜欢这种感觉了， 晚上， 关了门，关了灯，一个人， 听着音乐，享受独处，真是美妙！

    生活是多少新鲜， 我的心里充满了好奇， 如太阳朝升夕落，每天都是新的， 哦，拥抱激情，真是美妙！

    站在不高的山头， 看远处绿树舞动， 动物奔跑，鸟儿飞翔， 还有太阳、云朵和天空， 大自然啊，真是美妙！

    我们有生命，我们有思想， 我们生在一个美丽的星球， 宇宙充满未知，我们困惑， 除此之外，我们勇敢， 锲而不舍，孜孜不倦， 哦，去探索，真是美妙！

    活着的意义是什么？ 你发现了吗？你发现了吗？ 真正意义之所在？！ 不要止于提问， 紧随其后的更加精彩！

    不知生，不知死， 生亦何欢，死亦何哀， 如此百年，吾当何为？！ 诸行无常，为之奈何？！ oh,my God，真是美妙！

    这万物之灵长， 何能与自己的灵魂对话， 真正了知自我，而不迷失， 如同太阳底下的花儿和小草， 快乐的生长？

    我知道这个世上有人在等我， 虽然我不知道是谁， 哦，就是这个， 我每天都非常快乐，真是美妙！

    金钱买不到幸福， 我们却都在追逐金钱， 乐此不疲！ 何不如一箪食，一瓢饮， 居陋室，享其乐！ 哦，真是美妙！

    幸福，我是幸福的， 不为权柄，不为金银， 在我饿的时候可以吃， 能爱人时亦能被人爱， 哦，真是美妙！

    用心聆听，用心思考， 原来熟悉的其实很陌生， 或许你会发现有一种东西， 它一直在这里，总是在这里！ 哦，真是美妙！

    语言是苍白的， 一堆没有生命的字词， 它却能刮起一阵心灵风暴， 让我们拥有不可战胜的力量， 哦，这充满爱的语言，真是美妙！

    原文地址： http://colalife.com/blog/2009/07/ning-jing-2.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[宁静（一）]]> 2009-07-05T15:11:10+08:00 http://colalife.com/blog/2009/07/ning-jing-1 现在是周五的晚上，已经十点半了，我想睡觉，可是，要求如此却也不能如愿：房间隔音效果不太好，这倒问题不大，但兄弟姐妹们着实很喜欢聊天，唱歌，喧嚣……好几次我是睡了又起，看会书，等等再睡，这次就写点东西吧 – 是为记。

    我一直觉得，在人生的不同阶段，对于人生的认识多少都会有所改变，在我们的童年，基本上没有谁会考虑生死；青春少年时，思想萌动，恰如“独上西楼，为赋新诗强说愁”，其实我们的那点阅历和体验简直如西湖里的单细胞生物般微不足道，更多时候脑袋里充斥着青春期的躁动、叛逆……对于生命，有过多少真正的思考呢？
    人生美丽的花季雨季，于我而言，已变得遥远而又模糊，竟没有多少记忆了，好像那时候时间很快，仅有的印象是我在上学，我在学习，无他。很快的，到了大学，这是几乎所有人都认为是人生最美好的一段时光，我的感受是自由，无论是世事还是人际，你都是你自己。这个时候，大家心中都有了自己的人生意义，区别只在于思考的深度罢了。那时候，我晚上经常坐到洞门山的石头上，仰面看星空，看云月，再看看灯光点缀的校园，偶尔也思考着这些生死的或人生的问题，没什么特别的意义，只是给自己找到个答案，而且自己还很满意。如今，解答这些问题已然无从着落，想想之前的念头和答案是多么幼稚了。

    去探究人生的真理，无过于探究人生的意义，只是这个命题太大了。对此，也许有人会说：你想这些干什么？但是我同意苏格拉底所说：未经审视的生活是毫无意义的，或者用周国平的话说，对意义的寻求是人的最基本的需要，如果我们找寻不到，则会感到精神空虚，是为“存在的空虚”，如果可望不可即，则会有挫折之感，是为“存在的挫折”。如果说我相信他们，试问，我怎能不去思考它？

    古往今来，几乎没有人不思考人生，先哲的思想也给了我们很多启发，人有生死是个亘古不变的事情，子曰：未知生，焉知死；而与此相应西方则认为：未知死，焉知生。且不谈东西方思想文化差异，至少我们要认识生和死，才可能去探究人生的意义。而问题恰恰在于生与死：何为生，何为死？据我所知，个体的人不是横空出世，却是生于偶然，从生理上是万千精子中的一个与卵子的结合才有了你，真是奇妙；而无奈的是生你之前，几万万年月沧海桑田，无不尽去，今年今月今日有你；却人生自古谁无死，自你死后，几万万年月沧海桑田，依然尽去，与你何干？如此百年人生，与几万万年月相比何其短暂，你怎能不思考活而为何？

    佛曰：诸行无常，诸法无我，寂静涅槃，人生的虚无就在一个“空”字上，一切皆为虚幻，让众生追求无我境界，那么人生到底是不是虚幻的呢？这个问题经常让我想起《黑客帝国》这部电影，其中有关感知的论述就说：你的感觉是真实的吗？你感觉到的就存在吗？从生理上来说，感觉只是传入大脑的电流罢了。我有时会想比如说颜色，几乎所有的人都认可的红色，而实际上如果是绿色呢？在我们几十亿人，假如只有一个人看是绿色，毫无疑问我们说他是色盲，问题是如果他是对的呢？再者，如同电影里的人生活在虚拟世界，如果我们现在的世界实际上就是个虚拟世界，每个人都是上帝（但是，上帝死了，这在哲学里是毫无疑问的）操纵的，那你又作何感想？你是不是会去想到底什么是真实？到底有没有真实？到底这个世界本来的面目是什么样子？到底什么才是存在呢？关于“存在是什么”在哲学上也是个很深的问题，你有兴趣可以去读一下海德格尔《存在与时间》、萨特的《存在与虚无》。思考的翅膀可以飞的很高很远，但是在现实生活中，在有限的认知里，我们还得相信凭感官所感知的事物是真实存在的，否则我们将寸步难行。 思考活而何为不得，其实可以去思考该怎么活的问题，“好好活着就是去做有意义的事，比如让所爱的人幸福”，但是别忘了思考意义本身是什么。

    人生是有限的，如果我们说要活的有意义就是要突破这有限而到达永恒，那么请定义永恒。你可能想到不随时间流逝而消灭就是永恒，但是你知道什么是时间吗？难道是我们无时无刻不在说的时分秒、日月年吗，请注意这些只是我们衡量时间的尺度，那被衡量的东西是什么？如果说时间是永恒的，空间是无限的，那么人的个体生命显得是多么的渺小和空幻，果真是“天地之蜉蝣，沧海之一粟”！昨日已去，明日未知，只有今日，只有当下，但是它也是转瞬即逝的，你还没来得及喊出“现在”，现在已成过去了。

    佛曰因果循环，人们常说有因有果，有果有因，换句话说，世上发生的每一件事必定都是有原因的，如没有原因，就不会有任何事情发生，是这样吗？典型的如《黑客帝国》里的那个法国人，比如我们所知的蝴蝶效应，从发生海啸可以倒推到一直不知趣的蝴蝶扇动了一下翅膀；比如《本杰明巴顿奇事》里女主角遭遇车祸，影片也是描绘了一系列原因，说如果“女乘客去拿东西，司机去喝咖啡，朋友系鞋带……”等这些恰有一个不发生，那车祸是否会发生呢？如果是因果性，那么可以说世上的一切事物都是由上帝（如果有上帝的话）安排好的，那么人也就没了自由意志，或者说我们都是有命运的，命该如此的。天哪，你不觉得荒谬吗？但是换个角度思考，你怎么知道海啸的发生这个事实是因为蝴蝶扇动了一下翅膀这个事实而导致的呢？也就是说，你知道蝴蝶扇动了翅膀，发生了海啸这两个事实，可是你看到它们的因果关系了吗？你看到的只是它们相继出现的关系，从这种关系你能推断出因果关系吗？其实，所谓因果关系只不过是我们习惯性的联想，至于事实上是否存在，我们永远也无法知道。即使你天天看到太阳升起，你也不能据此断定说因为你天天看到太阳升起，所以明天早上太阳一定升起。所谓因果关系是一事实必然导致另一事实的关系，可是观察和实验总是有限的，经验只能说明过去，不能说明未来，从经验中不能得出永远有效的必然判断。这样一来，如果因果关系都不存在，何谈因、果呢？还是那句话，思考虽如此，回到现实生活，我们还是到处把握着原因与结果。

    是不是这些东西太虚了，一点都不实用？是啊，有些事情就是务虚的，当然还是务实的更多，比如谈处事交际的、谈成功励志的各类技巧，于此完全不在一个层面。思考这些，认识这些，或去探究人生的意义，或去去建立你自己的精神体系、价值体系，比如塑造什么样的灵魂，能否企及永恒，有什么样的生命状态，怎样才能幸福，如何面对苦难……等等逐一展开。为什么不去想？果真懒得动脑，懒得思考？我说还是那句话：未经审视的生活是毫无意义的。

    一些想法，写完睡觉，不知所云——Colalife。

    原文地址： http://colalife.com/blog/2009/07/ning-jing-1.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[本地搭建SVN服务器及配置]]> 2008-10-23T12:50:35+08:00 http://colalife.com/blog/2008/10/ben-di-da-jian-svnfu-wu-qi-ji-pei-zhi 1. 创建SVN数据库 
    1

    svnadmin create D:\svn

    说明： repository创建完毕后会在目录下生成若干个文件和文件夹， dav目录是提供给Apache与mod_dav_svn使用的目录，让它们存储内部数据； db目录就是所有版本控制的数据文件； hooks目录放置hook脚本文件的目录； locks用来放置Subversion文件库锁定数据的目录，用来追踪存取文件库的客户端； format文件是一个文本文件，里面只放了一个整数，表示当前文件库配置的版本号；

    2. 创建服务

    1

    sc create svnservice binpath= "D:\Subversion\bin\svnserve.exe --service -r D:\svn" displayname= "SVNService" depend= Tcpip

    3. 删除服务

    1

    sc delete svnservice

    4. 启动服务/停止服务

    1

    net start svnservice
    1

    net stop svnservice

    也可以在运行里输入 services.msc 找到名称为“svnservice”的服务 手动启动或停止

    5. 导入工程

    1

    svn import E:\workspace\myproject\ svn://localhost/svn -m "initial import" --username admin --password mypassword

    6. 导出工程

    1

    svn co svn://localhost/server --username admin --password mypassword

    原文地址： http://colalife.com/blog/2008/10/ben-di-da-jian-svnfu-wu-qi-ji-pei-zhi.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[何以如此]]> 2008-10-12T19:16:27+08:00 http://colalife.com/blog/2008/10/he-yi-ru-ci 乌云未散，夜雨不止

    还是没有什么；

    虚空袭来

    在今夜，无声无息；

    可怖的黑暗之穴

    狰狞如死海狂风

    吞噬一切，这般美妙；

    来吧

    给我光亮

    在我所指

    犀利的闪电，撕开大幕；

    依然

    我的灵魂，宁静清澈

            原文地址：
        <a href='http://colalife.com/blog/2008/10/he-yi-ru-ci.html/'>http://colalife.com/blog/2008/10/he-yi-ru-ci.html/</a><br/>
        &nbsp;written by &nbsp;<a href='http://colalife.com'>wang chaoqun</a>
        &nbsp;posted at &nbsp;<a href='http://colalife.com'>http://colalife.com</a>
        </p>
    ]]>         <![CDATA[《时间管理》读书笔记]]> 2008-09-23T18:44:23+08:00 http://colalife.com/blog/2008/09/shi-jian-guan-li-zhi-du-shu-bi-ji
    【原 书 名】 Time Management for System Administrators
    【原出版社】 O’Reilly Media, Inc.
    【作 者】Thomas A. Limoncelli [同作者作品] [作译者介绍]
    【译 者】 O’Reilly[同译者作品] Taiwan公司
    【出 版 社】 东南大学出版社     【书 号】 9787564109059

    第一章 时间管理原则

    六项基本原则：

    1. 给时间管理的信息一个“数据库”（使用笔记）
    2. 将脑力留给最重要的事（节省内存）
    3. 开发例行公事并持之以恒（程序代码函数库再利用，不要重新发明既有的东西）
    4. 形成习惯与信念（以预选计算的结果取代运行时的计算）
    5. 在项目期间保持专心（就像一个核心信号）
    6. 以工作生活上的工具管理社交生活（社交生活不是一个可选功能）

    本章精要：

    与同事安排共同干扰防线，以便你必须完成项目时让别人的干扰转向。

    时间管理的中心工具就是PDA（个人数字助理）或PAA（个人模拟助理），你会用他们存储你的工作表、日程表以及人生目标列表。

    将脑力留给最重要的是：有清晰的头脑很重要，使用外部存储设备来存储你无法专注的部分。把脑力用在手上的工作，用笔记记录待办事项、约会和通知。

    开发例行公事并持之以恒：把常规活动转成例行公事，以便消耗较少的时间计划处理总是会发生的突发事件。

    形成习惯与信念：习惯是你不用思考而做的例行公事，信念是作为形式法则的心灵启发。

    我的箴言：迟早都要做，早比晚好（一针及时省九针）。

    信任过程：每天早上花五分钟计划你的一天，对自己说“信任过程”，然后做计划。

    在“项目期间”保持专心：因为从中断返回很浪费时间。一次只专心做一件事会把事情做得更好。

    以工作生活上的工具管理社交生活：工作之外的生活很重要，别忘了玩乐。

    所有事情看起来都是讨厌和困难的，只要记住“改变”是一小步、一小步进行。继续尝试，持之以恒，告诉自己“信任过程”，从你的大脑榨取那些负面思想，然后再试一次。

    你能尝试冒险，但是当你只有一点筹码时，你不愿意尝试，其实你能大赢！

     大声呼叫：“是的，我可以！”

    第二章 专心对待干扰

    本章精要：

    专注是重要的。通过移开分心的事物获得专注并有效地处理干扰。

    本质上干扰是让别人控制你的时间。干扰是专注的天敌，因此需要时间管理。

    干扰是不好的。因为它会延后你当前的工作，而且也会因此在回到之前的工作是导致错误。修复那些错误将比做原来的工作花更多的时间。

    移开分心的事物有助于保持专注：清理你的桌子和计算机桌面，并从办公室移掉分心的东西。关掉即时通讯软件、新邮件通知器等。

    每个人都有不同的精神和体能活动上的尖峰时间。发觉你自己的尖峰时间，然后在那些时段安排适当的工作。

    每天的第一小时可能是工作效率最高的时刻，因为干扰最少。比同事稍微早上班以增加产出。别把这段时间浪费在维护工作上，要用在重要的项目上。

    委派、记录或执行步骤允许你收回对时间的控制权。当你的项目被干扰时，使用这些步骤。委派工作意味着将它交给其他人处理；记录工作让你确认请求，安排到之后再做；执行工作是最后的选择，但是应该用在紧急事件或运行中断状态中。

    你记录了它，就有了计划和安排的能力，而不是受干扰驱动。

    确认请求时，应该从视觉上有意义的方式进行。确认请求者看到了你的记录并让请求者确认。

    客户宁愿有请求确认，而不愿猜测请求是否被收到，即使这意味着请求已经延后了。

    类似RT的请求追踪系统让你记录请求到一个中央数据库，好让其他SA可以访问，而且客户可以用来检查请求的状态。

    前往别信赖大脑会记住请求，将请求记录到纸上或电子设备。你的大脑有更重要的事情要做。

     

    原文地址： http://colalife.com/blog/2008/09/shi-jian-guan-li-zhi-du-shu-bi-ji.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[《最后期限》读书笔记]]> 2008-09-16T13:49:44+08:00 http://colalife.com/blog/2008/09/zui-hou-qi-xian-zhi-du-shu-bi-ji 优质管理的四大要素

        选择正确的人
        为他们分配正确的工作
        保持他们的积极性
        帮助团队凝聚起来并保持团队的凝聚力
        (其他一切都只是“文案”)

    安全和变化

        除非感到安全，否则人们就不能去迎接变化
        在所有成功的工程中(以及在绝大多数其他有价值的工作中)，变化都是基本的要素之一
        安全感的缺乏会让人们反对变化
        逃避风险是致命的，因为这会让你也得不到与风险同在的利益
        人们可能会因为来自客观世界的直接的恐吓而觉得没有安全感，但是如果察觉到管理者可能滥用权力来惩罚自己，他们也会觉得没有安全感

    负面效应

    　　威胁不是提高业绩最好的方法
    　　如果分配的时间一开始就不够，不管威胁有多么吓人，工作也无法按时完成
    　　更糟糕的是，如果目标没有实现，你就必须兑现你的威胁

    管理者必需的身体部位

    　　管理涉及到心、肠胃、灵魂和鼻子
    　　因此……用心来领导，相信你的肠胃(相信你的预感)，构筑团队的灵魂，训练一个能嗅出谎言的鼻子

    招聘过程

    　　用指挥战争来作为管理的一个比喻：在战役开始的时候，管理者真正的工作已经完成了

    　　面试和招聘
    　　招聘涉及到所有与管理相关的身体部位：心、灵魂、鼻子和肠胃(但是主要是肠胃)
    　　    不要试图单独去招聘——两副肠胃远比一副肠胃的两倍要好
            对于新的雇员，让他们承担与以前曾经成功过的同样难度的项目，把有挑战性的目标推迟到下一次
    　　征求提示：你最希望雇的那个人可能还知道其他很好的人选
    　　多听，少说
    　　如果先把材料整理好，那么所有的事情都会进行得更好

    生产力的提高

    　　没有“短期生产力提高”这样的东西
    　　生产力的提高是来自长期投资的
    　　任何承诺立刻见效的东西都很可能是江湖游医所卖的万灵油

    风险控制

    　　通过控制风险来管理项目
    　　为每个项目创建并维护风险统计表
    　　跟踪根源性的风险，而不只是最后那讨厌的结果
    　　评估每种风险具体化的概率和可能造成的开销
    　　对于每种风险，预测标志其具体化的早期征兆
    　　任命一个风险控制官，这个人不应该维护组织内部“我能行”的态度
    　　建立简单的(可能是匿名的)通道，让坏消息能传递到高层

    防止失败

    　　壮士断腕
    　　控制住失败比优化成功更能提高你全面的成绩
    　　要有闯劲，尽早取消失败的工作
    　　除非必要，否则就不要自己去凝聚一个团队：出去找一个已经成型的团队来用
    　　保持好的团队在一起(只要他们自己愿意)，以帮助你的继任者避免团队凝聚得慢或者不能凝聚的问题
    　　把凝聚在一起的团队——准备好、并且也愿意接受新的工作——作为项目的收获之一
    　　项目开始时浪费的一天和最后阶段浪费的一天对项目造成的伤害是同等的
    　　有无数种方法可以浪费一天的时间……但是没有任何一种方法可以拿回一天的时间

    开发过程的建模和模拟

    　　将你关于完成工作过程的直觉建模
    　　在同事的交流中使用这些模型，以便交流、提炼关于项目运转的思想
    　　用模型来模拟项目的结果
    　　根据实际的结果来调整模型

    原文地址： http://colalife.com/blog/2008/09/zui-hou-qi-xian-zhi-du-shu-bi-ji.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[[转]大型网站架构演变和知识体系]]> 2008-09-06T14:57:20+08:00 http://colalife.com/blog/2008/09/zhuan-da-xing-wang-zhan-jia-gou-yan-bian-he-zhi-shi-ti-xi 转自BlueDavy之技术Blog 之前也有一些介绍大型网站架构演变的文章，例如LiveJournal的、ebay的，都是非常值得参考的，不过感觉他们讲的更多的是每次演变的结果，而没有很详细的讲为什么需要做这样的演变，再加上近来感觉有不少同学都很难明白为什么一个网站需要那么复杂的技术，于是有了写这篇文章的想法，在这篇文章中 将阐述一个普通的网站发展成大型网站过程中的一种较为典型的架构演变历程和所需掌握的知识体系，希望能给想从事互联网行业的同学一点初步的概念，:)，文中的不对之处也请各位多给点建议，让本文真正起到抛砖引玉的效果。

    架构演变第一步：物理分离webserver和数据库

    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候 已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易出问题，于是进入了第一步演变阶段：将应用和数据库从物理上分离，变成了两台机器，这个时候技术上没有什么新的要求，但你发现确实起到效果了，系统又恢复到以前的响应速度了，并且支撑住了更高的流量，并且不会因为数据库和应用形成互相的影响。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    这一步架构演变对技术上的知识体系基本没有要求。

    架构演变第二步：增加页面缓存

    好景不长，随着访问的人越来越多，你发现响应速度又开始变慢了，查找原因，发现是访问数据库的操作太多，导致数据连接竞争激烈，所以响应变慢，但数据库连 接又不能开太多，否则数据库机器压力会很高，因此考虑采用缓存机制来减少数据库连接资源的竞争和对数据库读的压力，这个时候首先也许会选择采用squid 等类似的机制来将系统中相对静态的页面（例如一两天才会有更新的页面）进行缓存（当然，也可以采用将页面静态化的方案），这样程序上可以不做修改，就能够 很好的减少对webserver的压力以及减少数据库连接资源的竞争，OK，于是开始采用squid来做相对静态的页面的缓存。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    前端页面缓存技术，例如squid，如想用好的话还得深入掌握下squid的实现方式以及缓存的失效算法等。

    架构演变第三步：增加页面片段缓存

    增加了squid做缓存后，整体系统的速度确实是提升了，webserver的压力也开始下降了，但随着访问量的增加，发现系统又开始变的有些慢了，在尝 到了squid之类的动态缓存带来的好处后，开始想能不能让现在那些动态页面里相对静态的部分也缓存起来呢，因此考虑采用类似ESI之类的页面片段缓存策略，OK，于是开始采用ESI来做动态页面中相对静态的片段部分的缓存。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    页面片段缓存技术，例如ESI等，想用好的话同样需要掌握ESI的实现方式等；

    架构演变第四步：数据缓存

    在采用ESI之类的技术再次提高了系统的缓存效果后，系统的压力确实进一步降低了，但同样，随着访问量的增加，系统还是开始变慢，经过查找，可能会发现系 统中存在一些重复获取数据信息的地方，像获取用户信息等，这个时候开始考虑是不是可以将这些数据信息也缓存起来呢，于是将这些数据缓存到本地内存，改变完毕后，完全符合预期，系统的响应速度又恢复了，数据库的压力也再度降低了不少。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    缓存技术，包括像Map数据结构、缓存算法、所选用的框架本身的实现机制等。

    架构演变第五步： 增加webserver

    好景不长，发现随着系统访问量的再度增加，webserver机器的压力在高峰期会上升到比较高，这个时候开始考虑增加一台webserver，这也是为了同时解决可用性的问题，避免单台的webserver down机的话就没法使用了，在做了这些考虑后，决定增加一台webserver，增加一台webserver时，会碰到一些问题，典型的有： 1、如何让访问分配到这两台机器上，这个时候通常会考虑的方案是Apache自带的负载均衡方案，或LVS这类的软件负载均衡方案； 2、如何保持状态信息的同步，例如用户session等，这个时候会考虑的方案有写入数据库、写入存储、cookie或同步session信息等机制等； 3、如何保持数据缓存信息的同步，例如之前缓存的用户数据等，这个时候通常会考虑的机制有缓存同步或分布式缓存； 4、如何让上传文件这些类似的功能继续正常，这个时候通常会考虑的机制是使用共享文件系统或存储等； 在解决了这些问题后，终于是把webserver增加为了两台，系统终于是又恢复到了以往的速度。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    负载均衡技术（包括但不限于硬件负载均衡、软件负载均衡、负载算法、linux转发协议、所选用的技术的实现细节等）、主备技术（包括但不限于ARP欺骗、linux heart-beat等）、状态信息或缓存同步技术（包括但不限于Cookie技术、UDP协议、状态信息广播、所选用的缓存同步技术的实现细节等）、共享文件技术（包括但不限于NFS等）、存储技术（包括但不限于存储设备等）。

    架构演变第六步：分库

    享受了一段时间的系统访问量高速增长的幸福后，发现系统又开始变慢了，这次又是什么状况呢，经过查找，发现数据库写入、更新的这些操作的部分数据库连接的 资源竞争非常激烈，导致了系统变慢，这下怎么办呢，此时可选的方案有数据库集群和分库策略，集群方面像有些数据库支持的并不是很好，因此分库会成为比较普遍的策略，分库也就意味着要对原有程序进行修改，一通修改实现分库后，不错，目标达到了，系统恢复甚至速度比以前还快了。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    这一步更多的是需要从业务上做合理的划分，以实现分库，具体技术细节上没有其他的要求；

    但同时随着数据量的增大和分库的进行，在数据库的设计、调优以及维护上需要做的更好，因此对这些方面的技术还是提出了很高的要求的。

    架构演变第七步：分表、DAL和分布式缓存

    随着系统的不断运行，数据量开始大幅度增长，这个时候发现分库后查询仍然会有些慢，于是按照分库的思想开始做分表的工作，当然，这不可避免的会需要对程序 进行一些修改，也许在这个时候就会发现应用自己要关心分库分表的规则等，还是有些复杂的，于是萌生能否增加一个通用的框架来实现分库分表的数据访问，这个在ebay的架构中对应的就是DAL，这个演变的过程相对而言需要花费较长的时间，当然，也有可能这个通用的框架会等到分表做完后才开始做，同时，在这个阶段可 能会发现之前的缓存同步方案出现问题，因为数据量太大，导致现在不太可能将缓存存在本地，然后同步的方式，需要采用分布式缓存方案了，于是，又是一通考察和折磨，终于是将大量的数据缓存转移到分布式缓存上了。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    分表更多的同样是业务上的划分，技术上涉及到的会有动态hash算法、consistent hash算法等；

    DAL涉及到比较多的复杂技术，例如数据库连接的管理（超时、异常）、数据库操作的控制（超时、异常）、分库分表规则的封装等；

    架构演变第八步：增加更多的webserver

    在做完分库分表这些工作后，数据库上的压力已经降到比较低了，又开始过着每天看着访问量暴增的幸福生活了，突然有一天，发现系统的访问又开始有变慢的趋势 了，这个时候首先查看数据库，压力一切正常，之后查看webserver，发现apache阻塞了很多的请求，而应用服务器对每个请求也是比较快的，看来 是请求数太高导致需要排队等待，响应速度变慢，这还好办，一般来说，这个时候也会有些钱了，于是添加一些webserver服务器，在这个添加 webserver服务器的过程，有可能会出现几种挑战： 1、Apache的软负载或LVS软负载等无法承担巨大的web访问量（请求连接数、网络流量等）的调度了，这个时候如果经费允许的话，会采取的方案是购 买硬件负载，例如F5、Netsclar、Athelon之类的，如经费不允许的话，会采取的方案是将应用从逻辑上做一定的分类，然后分散到不同的软负载集群中； 2、原有的一些状态信息同步、文件共享等方案可能会出现瓶颈，需要进行改进，也许这个时候会根据情况编写符合网站业务需求的分布式文件系统等； 在做完这些工作后，开始进入一个看似完美的无限伸缩的时代，当网站流量增加时，应对的解决方案就是不断的添加webserver。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    到了这一步，随着机器数的不断增长、数据量的不断增长和对系统可用性的要求越来越高，这个时候要求对所采用的技术都要有更为深入的理解，并需要根据网站的需求来做更加定制性质的产品。

    架构演变第九步：数据读写分离和廉价存储方案

    突然有一天，发现这个完美的时代也要结束了，数据库的噩梦又一次出现在眼前了，由于添加的webserver太多了，导致数据库连接的资源还是不够用，而这个时候又已经分库分表了，开始分析数据库的压力状况，可能会发现数据库的读写比很高，这个时候通常会想到数据读写分离的方案，当然，这个方案要实现并不 容易，另外，可能会发现一些数据存储在数据库上有些浪费，或者说过于占用数据库资源，因此在这个阶段可能会形成的架构演变是实现数据读写分离，同时编写一些更为廉价的存储方案，例如BigTable这种。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    数据读写分离要求对数据库的复制、standby等策略有深入的掌握和理解，同时会要求具备自行实现的技术；

    廉价存储方案要求对OS的文件存储有深入的掌握和理解，同时要求对采用的语言在文件这块的实现有深入的掌握。

    架构演变第十步：进入大型分布式应用时代和廉价服务器群梦想时代

    经过上面这个漫长而痛苦的过程，终于是再度迎来了完美的时代，不断的增加webserver就可以支撑越来越高的访问量了，对于大型网站而言，人气的重要毋 庸置疑，随着人气的越来越高，各种各样的功能需求也开始爆发性的增长，这个时候突然发现，原来部署在webserver上的那个web应用已经非常庞大 了，当多个团队都开始对其进行改动时，可真是相当的不方便，复用性也相当糟糕，基本是每个团队都做了或多或少重复的事情，而且部署和维护也是相当的麻烦， 因为庞大的应用包在N台机器上复制、启动都需要耗费不少的时间，出问题的时候也不是很好查，另外一个更糟糕的状况是很有可能会出现某个应用上的bug就导 致了全站都不可用，还有其他的像调优不好操作（因为机器上部署的应用什么都要做，根本就无法进行针对性的调优）等因素，根据这样的分析，开始痛下决心，将 系统根据职责进行拆分，于是一个大型的分布式应用就诞生了，通常，这个步骤需要耗费相当长的时间，因为会碰到很多的挑战： 1、拆成分布式后需要提供一个高性能、稳定的通信框架，并且需要支持多种不同的通信和远程调用方式； 2、将一个庞大的应用拆分需要耗费很长的时间，需要进行业务的整理和系统依赖关系的控制等； 3、如何运维（依赖管理、运行状况管理、错误追踪、调优、监控和报警等）好这个庞大的分布式应用。 经过这一步，差不多系统的架构进入相对稳定的阶段，同时也能开始采用大量的廉价机器来支撑着巨大的访问量和数据量，结合这套架构以及这么多次演变过程吸取的经验来采用其他各种各样的方法来支撑着越来越高的访问量。

    看看这一步完成后系统的图示：

    这一步涉及到了这些知识体系：

    这一步涉及的知识体系非常的多，要求对通信、远程调用、消息机制等有深入的理解和掌握，要求的都是从理论、硬件级、操作系统级以及所采用的语言的实现都有清楚的理解。

    运维这块涉及的知识体系也非常的多，多数情况下需要掌握分布式并行计算、报表、监控技术以及规则策略等等。

    说起来确实不怎么费力，整个网站架构的经典演变过程都和上面比较的类似，当然，每步采取的方案，演变的步骤有可能有不同，另外，由于网站的业务不同，会有不同的专业技术的需求，这篇blog更多的是从架构的角度来讲解演变的过程，当然，其中还有很多的技术也未在此提及，像数据库集群、数据挖掘、搜索等，但在真实的演变过程中还会借助像提升硬件配置、网络环境、改造操作系统、CDN镜像等来支撑更大的流量，因此在真实的发展过程中还会有很多的不同，另外一个大型网站要做到的远远不仅仅上面这些，还有像安全、运维、运营、服务、存储等，要做好一个大型的网站真的很不容易，写这篇文章更多的是希望能够引出更多大型网站架构演变的介绍，:)。

    ps:最后附上几篇LiveJournal架构演变的文章： 从LiveJournal后台发展看大规模网站性能优化方法 http://blog.zhangjianfeng.com/article/743
    另外从这里：http://www.danga.com/words/%E5%A4%A7%E5%AE%B6%E5%8F%AF%E4%BB%A5%E6%89%BE%E5%88%B0%E6%9B%B4%E5%A4%9A%E5%85%B3%E4%BA%8E%E7%8E%B0%E5%9C%A8LiveJournal%E7%BD%91%E7%AB%99%E6%9E%B6%E6%9E%84%E7%9A%84%E4%BB%8B%E7%BB%8D%E3%80%82

    原文地址： http://colalife.com/blog/2008/09/zhuan-da-xing-wang-zhan-jia-gou-yan-bian-he-zhi-shi-ti-xi.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>         <![CDATA[SQL Server 2005的安装和JDBC连接方法]]> 2008-08-11T13:29:34+08:00 http://colalife.com/blog/2008/08/sql-server-2005-de-an-zhuang-he-jdbc-lian-jie-fang-fa 本文先介绍Windows XP SP2/SP3 下Microsoft SQL Server 2005 的安装及有关问题的解决方法，然后介绍Eclipse3.2 / 3.3 或 MyEclipse6.0 / 6.5 进行JDBC连接SQL Server 2005数据库的方法。

    一、SQL Server 版本（32位）
    SQL Server 2005 Enterprise Edition 企业版不能用在Windows XP系统下（当然还是有些特别方法可以安装，不推荐），一般是运行不了。
    SQL Server 2005 Standard Edition 标准版、SQL Server 2005 Evaluation Edition 评估版和 Workgroup Edition 工作组版、SQL Server 2005 Developer Edition 开发版和 Express Edition 都可以安装在Windows XP下。
    建议安装SQL Server 2005 Developer Edition 开发版，其安装DVD文件大约1.74G，整合补丁包sp2的大约1.98G.

    二、SQL Server 2005 安装过程详细图解
    步骤：
    1.主菜单——只要你载入DVD驱动器中的光盘，就会出现。
    要安装SQL Server 2005的实例，在安装标题下选择“服务器组件、工具、在线书籍，以及示范”选项。
    2.终端用户许可协议 – 检查终端用户的许可协议(EULA) ，看完后选择 ‘I accept the licensing terms and conditions’ 框。
    接受协议后可激活“next”按钮，按下这个按钮继续。
    3.安装的先决条件 – 决定好先决条件后点击 ‘Next’按钮。[http://www.colalife.com]
    4.欢迎– 点击 ‘Next’ 按钮开始安装过程。
    5.系统配置检查——安装应用程序需要查看服务器上的15个组件，并且判断成功和失败。
    6.安装–一个进度条显示安装过程的状态. 不需要动作.
    7.注册信息 – 输入姓名和公司，继续 SQL Server 的安装
    点击“下一步”按钮继续
    8.安装组件 – 选择’SQL Server 数据库服务’ 的检查框
    点击右边的’高级’按钮，可更改安装目录和所需安装的组件，继续下一步
    9特性选择 – 验证所有的数据库服务选项都被选中了
    如果有选项没有被选中，它显示为一个红色的叉，右击特性然后选择安装选项。
    点击“next”按钮继续。
    10.安装环境– 如果可用的话，现有的环境将会列出应用程序、译本、版本，以及语言。
    点击 ‘OK’按钮继续
    11.实例名字 – 默认的实例名称即为服务器的名字，例如MSSQLServer。命名的实例，如MySqlServer2005.
    *** 注意 *** - 只可以创建一个默认的实例，但是可以创建多个有名字的实例。[http://www.colalife.com]
    点击 ‘Next’ 按钮继续

    指定账号、认证模式和设置
    12.服务账号– 为数据库服务 Windows 服务指定账号.可以是一个内建的账号，例如本地系统或者网络服务。第二个选项是使用域的用户名和密码。
    点击 ‘Next’ 按钮继续
    13.认证模式 – 配置单独Windows默认的认证或者混合认证模式的认证，输入系统管理员的密码。
    点击’Next’按钮继续
    14.调整设置– 为实例进行调整设置的配置。
    点击 ‘Next’按钮继续（选择排序规则：Chinese_PRC_CS_AI_WS[http://www.colalife.com]）

    点击“安装”并检查你的总结日志
    15.准备安装– 检查安装的项目。点击“安装”按钮继续
    16.安装进度 – 检查过程中每个步骤的状态。安装结束后，点击’Next’ 按钮继续
    17.完成SQL Server 2005 的安装 – 检查总结日志并点击 ‘finish’ 按钮结束安装过程。 

    三、出现问题

    问题1. 无法在com+目录中安装和配置程序集
    这是在安装后期时有可能出现的：
     无法在com+目录中安装和配置程序集
     错误说明: 事务管理器可用。
    解决方法：
    这时候不要点击中止、忽略，也不要点击取消

    按以下步骤
        1.删除注册表中的：
           a. HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\MSDTC项
           b. HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSDTC项
           c. HKEY_CLASSES_ROOT\CID项[http://www.colalife.com]
        2.使用cmd执行-停止MSDTC服务：net stop msdtc（在命令行输入，然后回车即可，步骤3.4.同样）
        3.使用cmd执行-卸载MSDTC服务：msdtc -uninstall
        4.使用cmd执行-重新安装MSDTC服务：msdtc -install

    最后点击重试，继续安装。

    （问题2和3基本不会出现，没出错可以略去~~）

    问题2. 安装成功后没有SQL Server Management Studio选项（版本冲突，基本不会出现）
        1.电脑里先前装了sql2000和Visual Studio 2005，解决方法是 "先删除Visual Studio 2005 Bata1版的Framework，运行Visual Studio 2005 Bata1版安装盘上的dotnetfx.exe进行删除，然后再安装SQL Server 2005 Bata2版"。
    解决方法：
        2.先把SQL2005删除，把先前的Native Client删除
        3.分步安装Tools包和Servers包，安装路径可以全部改掉
              3.1.先安装Tools包，在安装Tools包是遇到了第3个问题：性能监视器计数器要求（错误）（下面有介绍。）
              3.2.安装Servers包，也是除了文档演示全部安装。

    问题3. 如何在 SQL Server 2005 中为安装程序增加计数器注册表项值(转载)
    解决方法：
    在 SQL Server 安装开始前，Microsoft SQL Server 安装程序中的安装配置检查器 (SCC) 会验证计数器注册表项的值。如果 SCC 无法验证现有的注册表项，或 SCC 无法运行 lodctr.exe 系统程序，则 SCC 检查会失败，致使安装受阻。错误编辑注册表会严重损坏您的系统。更改注册表项之前，建议您备份计算机中的所有重要数据。
    在 Microsoft Windows 2003 或 Windows XP 桌面上，依次单击“开始”、“运行”，然后在“打开”中键入 regedit.exe，再单击“确定”。在 Windows 2000 中，使用 regedt32.exe 启动注册表编辑器。定位到以下注册表项：
    [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib]
    "Last Counter"=dword:00000ed4 (5276)
    "LastHelp"=dword:00000ed5 (5277)
    上一步的“Last Counter”值 (5276) 必须与以下注册表项中“Perflib\009”的“Counter”项的最大值匹配，并且上一步的“Last Help”值 (5277) 必须与以下注册表项中“Perflib\009”的“Help”项的最大值匹配。[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009]
    注意 009 是英文中的一个示例。
    “Last Counter”和“Last Help”值是由 Windows 动态分配的；这两个值会因计算机的不同而不同。
    如有必要，可修改“\Perflib”项中的“Last Counter”和“Last Help”值的值：在右侧窗格中，右键单击“Last Counter”或“Last Help”，单击“修改”，再单击“Base = "Decimal"”，在“值数据”中设置值，再单击“确定”。如有必要，对另一个项重复以上过程，然后关闭注册表编辑器。再次运行 SQL Server 安装程序。
              注意:上面所描述的009是存储英文版的mssql2005的计数器,而中文版的则是004!

    四、SQL Server 2005 插入数据中文乱码[http://www.colalife.com]

    安装完成，打开SQL Server Management Studio，登入系统，新建数据库，新建数据库表，插入数据的时候，出现了中文乱码-全部是问号。

    原因分析：

    SQL版的乱码问题还是出现在SQL SERVER的安装设置上，默认安装时系统默认的排序规则是拉丁文的排序规则，没有选择其他项目，安装时只是点取下一步，安装完成后，造成了插入了数据的过程中出现乱码。

    解决方法：
    1.最彻底的就是重装SQL，在安装时自定义安装，选好语言版本及排序规则（选择排序规则：Chinese_PRC_CS_AI_WS），这样问题就解决了。

    2.不重新安装也是可以的，只要在新建数据库时指定排序规则（强烈建议），选择中文简体。
    步骤：
        1、启动Microsft SQL Server Management Studio，登录到一个实例服务器。

        2、新建数据库，在左侧打开的窗口中单击“选项”。

        3、把“排序规则”改为  "Chinese_PRC_CI_AI” 单击“确定”就行了，然后再从Visual Studio 2005的数据库管理里，进行相关的建表，插入数据等操作 。

        4、也可以在表中修改，Sql语句如同：
           ALTER TABLE tablename
           ALTER COLUMN column1 nvarchar(100) COLLATE CHINESE_PRC_CI_AI

    五、 JDBC连接SQL Server 2005数据库

    1. 关闭防火墙。

    2. 配置TCP端口：
        a. 开始->所有程序->Microsoft SQL Server 2005->配置工具->SQL Server配置管理器->SQL Server 2005 网络配置->MSSQLSERVER协议
        b. 启用“TCP/IP”（右键单击选择“启动”）[http://www.colalife.com]
        c. 双击“TCP/IP”->“IP 地址”->“IPAll”->“TCP 端口”项添加默认的“1433”端口

    3. 外围应用配置：Microsoft SQL Server 2005->配置工具->SQL Server外围应用配置器->服务和连接的外围应用配置器->
         ①选SQLEXPRESS->Database Engine->远程连接->本地连接和远程连接->同时使用TCP/IP和named pipes
         ②选SQL Server Browser->服务->启动类型改为“自动”->应用->启动->确定

    4. 修改默认的登录验证模式（如果在安装过程中是默认按“Windows 身份验证模式”方式安装，所以sa登录是被禁用的，即使将身份验证模式更改为“SQL Server 和 Windows 身份验证模式”，sa登录仍处于禁用状态，所以需要启用sa登录帐户）：
        ①在SQL Server Management Studio 的对象资源管理器中，安全性->登录名->右击“sa”->属性->

    常规->将登录名sa的密码和确认密码设为强密码->状态->登录->启用->确定
        ②在SQL Server Management Studio 的对象资源管理器中，右击服务器->属性->安全性->服务器身份验证->选择“SQL Server和Windows身份验证模式”->确定->确定

    5. 在SQL Server Management Studio中新建一个数据库(例如“mytest”，如果测试程序带有数据库文件也可不用新建而直接附加到当前SQL Server数据库服务器)；在SQL Server Management Studio 的对象资源管理器中右击服务器->重新启动->是

    6. 运行下载的JDBC文件“sqljdbc_1.2.2828.100_chs.exe”，解压到“C:\Program Files”文件夹中；[http://www.colalife.com]

    将Classpath设置为包含sqljdbc.jar文件(也可加到系统环境变量中)，建议从解压文件夹下找到sqljdbc.jar，将其复制到自己常用的Jar文件夹里，用的时候方便找到。

    7. 在Eclipse3.2 / 3.3 或 MyEclipse6.0 / 6.5 进行JDBC连接设置并测试
        1、打开Eclipse3.2 / 3.3 或 MyEclipse6.0 / 6.5，新建Java Project”，项目名为Test
        2、选择“Window”→“Preferences”→“Java”→“Installed JREs”，选定已安装的 JRE，点击“Edit…”→“Add External JARs”，找到sqljdbc.jar并添加—>OK
        3、"Window"->"Open Perspective"->"MyEclipse Database Explorer"->（左侧）"DB Browser"右键“New”->填写链接属性Driver name，URL为：jdbc:sqlserver:// localhost:1433;databaseName=mytest，User name：sa，Password：密码。然后在Driver JARs 点Add JARs 添加sqljdbc.jar，点及Test

    Driver测试，勾上Save Password保存密码，点击完成结束——即完成了在DB Browser中连接数据库配置。

    8、编写Java代码测试，如下：

    package jdbc.test;
    import java.sql.*;

    public class Test {
     public static void main(String[] srg) {
      String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
      // 加载JDBC驱动
      String dbURL = "jdbc:sqlserver://localhost:1433; DatabaseName=mytest";
      // 连接服务器和数据库mytest
      String userName = "sa"; // 默认用户名
      String userPwd = "123456"; // 密码[http://www.colalife.com]
      Connection dbConn = null;
      Statement stmt = null;

      try {
       Class.forName(driverName);
       dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
       stmt = dbConn.createStatement();
       System.out.println("Connect Succeed!");
       // 连接成功控制台输出语句

       ResultSet rs = stmt.executeQuery("select * from mytest");
       while (rs.next()) {
        System.out.print(rs.getInt(1) + " " + rs.getString(2) + " "
          + rs.getString(3) + "\n");
       }
      } catch (Exception e) {
       e.printStackTrace();
      }
     }
    }

    9. Sql Server2000和2005的连接代码区别：（注意2000和2005的不同）
        1. 连接SqlServer2000
          Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
          URL = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=tempdb";
        2. 连接SqlServer2005
          Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
          URL = "jdbc:sqlserver://localhost:1433;DatabaseName=tempdb";
    10、可能出现的exception: com.microsoft.sqlserver.jdbc.AuthenticationJNI <clinit>
         WARNING: Failed to load the sqljdbc_auth.dll
    解决办法：在sqljdbc_1.2.2828.100_chs.exe解压后的文件夹中找到Microsoft SQL Server 2005 JDBC Driver\sqljdbc_1.2\chs\auth\x86下的sqljdbc_auth.dll拷贝到：C:WINDOWSsystem32 目录下即可。

    （全文完——By ColaLife[http://www.colalife.com]）

    原文地址： http://colalife.com/blog/2008/08/sql-server-2005-de-an-zhuang-he-jdbc-lian-jie-fang-fa.html/
     written by  wang chaoqun  posted at  http://colalife.com

    ]]>