VPS/服务器 ’ 目录归档

超快速搭建Ubuntu下Nodejs的开发环境

Nodejs很火,在Ubuntu下搭建它的开发环境尝尝鲜,有一个捷径,它能让系统自动帮你安装所需要的东西,我们生成一段shell脚本,让它来完成以下工作: 安装git下最新的node,node包管理器,Forever和Cloud9IDE工具(可选),mongodb 10gen;脚本的正常运行需要比较新板的Ubuntu,而且需要联网,因为它会连接网络去下载所有的依赖包顺序安装。

#!/bin/sh  
# Update System  
echo 'System Update'  
apt-get update  
echo 'Update completed'  
apt-get install libssl-dev git-core pkg-config build-essential curl  
# Clone Node.js  
echo 'Clone Node.js'  
cd /usr/src  
git clone https://github.com/joyent/node  
echo 'Node.js clone completed'  
# Install Node.js  
echo 'Install Node.js'  
cd node  
./configure && make && make install  
echo 'Node.js install completed'  
# Install Node Package Manager  
echo 'Install Node Package Manager'  
curl http://npmjs.org/install.sh | sh  
echo 'NPM install completed'  
# Install Forever  
echo 'Install Forever'  
npm install forever  
echo 'Forever install completed'  
# Install Cloud9IDE  
echo 'Install Cloud9IDE'  
git clone git://github.com/ajaxorg/cloud9.git  
echo 'Cloud9IDE install completed'  
# Install MongoDB  
echo 'Install MongoDB'  
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10  
echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" >> /etc/apt/sources.list  
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10  
sudo apt-get update  
sudo apt-get install mongodb-10gen  
echo 'MongoDB install completed.'

安装方法:

$ cd ~/  
$ nano -w node.sh

把以上代码粘贴到node.sh文件里,ctrl+o 保存,ctrl+x 退出nano。如果你没有安装nano,请google一下安装吧。
然后执行脚本:

$ chmod a+x node.sh && sudo ./node.sh

如果网速足够快,一会功夫即可完成安装。等安装完毕,我们来个测试:

mkdir node_project  
cd node_project  
nano -w server.js

粘贴以下著名的代码:

var http = require('http');  
http.createServer(function (req, res) {  
  res.writeHead(200, {'Content-Type': 'text/plain'});  
  res.end('Hello World\n');  
}).listen(1337, "127.0.0.1");  
console.log('Server running at http://127.0.0.1:1337/');

ctrl+o 保存,ctrl+x 退出nano,尝试跑它 :

node server.js

在浏览器中打开 :http://127.0.0.1:1337,看到久违的Hello World了吧?

[收藏]Ubuntu常用命令大全

今天心血来潮安装Ubuntu 12嘿嘿,不过是虚拟机安装的,第一次接触的是Server版,命令行操作头疼啊,恶补一下常用命令吧!

查看软件xxx安装内容
#dpkg -L xxx

查找软件
#apt-cache search 正则表达式
查找文件属于哪个包
#dpkg -S filename apt-file search filename

查询软件xxx依赖哪些包
#apt-cache depends xxx

查询软件xxx被哪些包依赖
#apt-cache rdepends xxx

增加一个光盘源
#sudo apt-cdrom add

系统升级
#sudo apt-get update
#sudo apt-get upgrade
#sudo apt-get dist-upgrade

清除所以删除包的残余配置文件
#dpkg -l |grep ^rc|awk ‘{print $2}’ |tr [””n”] [” “]|sudo xargs dpkg -P –

编译时缺少h文件的自动处理
#sudo auto-apt run ./configure

查看安装软件时下载包的临时存放目录
#ls /var/cache/apt/archives

备份当前系统安装的所有包的列表
#dpkg –get-selections | grep -v deinstall > ~/somefile

从上面备份的安装包的列表文件恢复所有包
#dpkg –set-selections < ~/somefile sudo dselect 清理旧版本的软件缓存 #sudo apt-get autoclean 清理所有软件缓存 #sudo apt-get clean 删除系统不再使用的孤立软件 #sudo apt-get autoremove 查看包在服务器上面的地址 #apt-get -qq –print-uris install ssh | cut -d"’ -f2 系统 查看内核 #uname -a 查看Ubuntu版本 #cat /etc/issue 查看内核加载的模块 #lsmod 查看PCI设备 #lspci 查看USB设备 #lsusb 查看网卡状态 #sudo ethtool eth0 查看CPU信息 #cat /proc/cpuinfo 显示当前硬件信息 #lshw 硬盘 查看硬盘的分区 #sudo fdisk -l 查看IDE硬盘信息 #sudo hdparm -i /dev/hda 查看STAT硬盘信息 #sudo hdparm -I /dev/sda 或 #sudo apt-get install blktool #sudo blktool /dev/sda id 查看硬盘剩余空间 #df -h #df -H 查看目录占用空间 #du -hs 目录名 优盘没法卸载 #sync fuser -km /media/usbdisk 内存 查看当前的内存使用情况 #free -m 进程 查看当前有哪些进程 #ps -A 中止一个进程 #kill 进程号(就是ps -A中的第一列的数字) 或者 killall 进程名 强制中止一个进程(在上面进程中止不成功的时候使用) #kill -9 进程号 或者 killall -9 进程名 图形方式中止一个程序 #xkill 出现骷髅标志的鼠标,点击需要中止的程序即可 查看当前进程的实时状况 #top 查看进程打开的文件 #lsof -p ADSL 配置 ADSL #sudo pppoeconf ADSL手工拨号 #sudo pon dsl-provider 激活 ADSL #sudo /etc/ppp/pppoe_on_boot 断开 ADSL #sudo poff 查看拨号日志 #sudo plog 如何设置动态域名 #首先去http://www.3322.org申请一个动态域名 #然后修改 /etc/ppp/ip-up 增加拨号时更新域名指令 sudo vim /etc/ppp/ip-up #在最后增加如下行 w3m -no-cookie -dump 网络 根据IP查网卡地址 #arping IP地址 查看当前IP地址 #ifconfig eth0 |awk ‘/inet/ {split($2,x,”:”);print x[2]}’ 查看当前外网的IP地址 #w3m -no-cookie -dumpwww.edu.cn|grep-o‘[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}’ #w3m -no-cookie -dumpwww.xju.edu.cn|grep-o’[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}’ #w3m -no-cookie -dump ip.loveroot.com|grep -o’[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}".[0-9]"{1,3"}’ 查看当前监听80端口的程序 #lsof -i :80 查看当前网卡的物理地址 #arp -a | awk ‘{print $4}’ ifconfig eth0 | head -1 | awk ‘{print $5}’ 立即让网络支持nat #sudo echo 1 > /proc/sys/net/ipv4/ip_forward
#sudo iptables -t nat -I POSTROUTING -j MASQUERADE

查看路由信息
#netstat -rn sudo route -n

手工增加删除一条路由
#sudo route add -net 192.168.0.0 netmask 255.255.255.0 gw 172.16.0.1
#sudo route del -net 192.168.0.0 netmask 255.255.255.0 gw 172.16.0.1

修改网卡MAC地址的方法
#sudo ifconfig eth0 down 关闭网卡
#sudo ifconfig eth0 hw ether 00:AA:BB:CC:DD:EE 然后改地址
#sudo ifconfig eth0 up 然后启动网卡

统计当前IP连接的个数
#netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F: ‘{print $1}’|sort|uniq -c|sort -r -n
#netstat -na|grep SYN|awk ‘{print $5}’|awk -F: ‘{print $1}’|sort|uniq -c|sort -r -n

统计当前20000个IP包中大于100个IP包的IP地址
#tcpdump -tnn -c 20000 -i eth0 | awk -F “.” ‘{print $1″.”$2″.”$3″.”$4}’ | sort | uniq -c | sort -nr | awk ‘ $1 > 100 ‘

屏蔽IPV6
#echo “blacklist ipv6″ | sudo tee /etc/modprobe.d/blacklist-ipv6

服务
添加一个服务
#sudo update-rc.d 服务名 defaults 99

删除一个服务
#sudo update-rc.d 服务名 remove

临时重启一个服务
#/etc/init.d/服务名 restart

临时关闭一个服务
#/etc/init.d/服务名 stop

临时启动一个服务
#/etc/init.d/服务名 start

设置
配置默认Java使用哪个
#sudo update-alternatives –config java

修改用户资料
#sudo chfn userid

给apt设置代理
#export http_proxy=http://xx.xx.xx.xx:xxx

修改系统登录信息
#sudo vim /etc/motd

中文
转换文件名由GBK为UTF8
#sudo apt-get install convmv convmv -r -f cp936 -t utf8 –notest –nosmart *

批量转换src目录下的所有文件内容由GBK到UTF8
#find src -type d -exec mkdir -p utf8/{} “; find src -type f -exec iconv -f GBK -t UTF-8 {} -o utf8/{} “; mv utf8/* src rm -fr utf8

转换文件内容由GBK到UTF8
#iconv -f gbk -t utf8 $i > newfile

转换 mp3 标签编码
#sudo apt-get install python-mutagen find . -iname “*.mp3” -execdir mid3iconv -e GBK {} “;

控制台下显示中文
#sudo apt-get install zhcon 使用时,输入zhcon即可

文件
快速查找某个文件
#whereis filename
#find 目录 -name 文件名

查看文件类型
#file filename

显示xxx文件倒数6行的内容
#tail -n 6 xxx

让tail不停地读地最新的内容
#tail -n 10 -f /var/log/apache2/access.log

查看文件中间的第五行(含)到第10行(含)的内容
#sed -n ‘5,10p’ /var/log/apache2/access.log

查找包含xxx字符串的文件
#grep -l -r xxx .

全盘搜索文件(桌面可视化)
gnome-search-tool

查找关于xxx的命令
#apropos xxx man -k xxx

通过ssh传输文件
#scp -rp /path/filenameusername@remoteIP:/path
#将本地文件拷贝到服务器上
#scp -rpusername@remoteIP:/path/filename/path
#将远程文件从服务器下载到本地

查看某个文件被哪些应用程序读写
#lsof 文件名

把所有文件的后辍由rm改为rmvb
#rename ’s/.rm$/.rmvb/’ *

把所有文件名中的大写改为小写
#rename ‘tr/A-Z/a-z/’ *

删除特殊文件名的文件,如文件名:–help.txt
#rm — –help.txt 或者 rm ./–help.txt

查看当前目录的子目录
#ls -d */. 或 echo */.

将当前目录下最近30天访问过的文件移动到上级back目录
#find . -type f -atime -30 -exec mv {} ../back “;

将当前目录下最近2小时到8小时之内的文件显示出来
#find . -mmin +120 -mmin -480 -exec more {} “;

删除修改时间在30天之前的所有文件
#find . -type f -mtime +30 -mtime -3600 -exec rm {} “;

查找guest用户的以avi或者rm结尾的文件并删除掉
#find . -name ‘*.avi’ -o -name ‘*.rm’ -user ‘guest’ -exec rm {} “;

查找的不以java和xml结尾,并7天没有使用的文件删除掉
#find . ! -name *.java ! -name ‘*.xml’ -atime +7 -exec rm {} “;

统计当前文件个数
#ls /usr/bin|wc -w

统计当前目录个数
#ls -l /usr/bin|grep ^d|wc -l

显示当前目录下2006-01-01的文件名
#ls -l |grep 2006-01-01 |awk ‘{print $8}’

FTP
上传下载文件工具-filezilla
#sudo apt-get install filezilla

filezilla无法列出中文目录?
站点->字符集->自定义->输入:GBK

本地中文界面
1)下载filezilla中文包到本地目录,如~/
2)#unrar x Filezilla3_zhCN.rar
3) 如果你没有unrar的话,请先安装rar和unrar
#sudo apt-get install rar unrar
#sudo ln -f /usr/bin/rar /usr/bin/unrar
4)先备份原来的语言包,再安装;实际就是拷贝一个语言包。
#sudo cp /usr/share/locale/zh_CN/filezilla.mo /usr/share/locale/zh_CN/filezilla.mo.bak
#sudo cp ~/locale/zh_CN/filezilla.mo /usr/share/locale/zh_CN/filezilla.mo
5)重启filezilla,即可!

解压缩
解压缩 xxx.tar.gz
#tar -zxvf xxx.tar.gz

解压缩 xxx.tar.bz2
#tar -jxvf xxx.tar.bz2

压缩aaa bbb目录为xxx.tar.gz
#tar -zcvf xxx.tar.gz aaa bbb

压缩aaa bbb目录为xxx.tar.bz2
#tar -jcvf xxx.tar.bz2 aaa bbb

解压缩 RAR 文件
1) 先安装
#sudo apt-get install rar unrar
#sudo ln -f /usr/bin/rar /usr/bin/unrar
2) 解压
#unrar x aaaa.rar

解压缩 ZIP 文件
1) 先安装
#sudo apt-get install zip unzip
#sudo ln -f /usr/bin/zip /usr/bin/unzip
2) 解压
#unzip x aaaa.zip

Nautilus
显示隐藏文件
Ctrl+h

显示地址栏
Ctrl+l

特殊 URI 地址
* computer:/// – 全部挂载的设备和网络
* network:/// – 浏览可用的网络
* burn:/// – 一个刻录 CDs/DVDs 的数据虚拟目录
* smb:/// – 可用的 windows/samba 网络资源
* x-nautilus-desktop:/// – 桌面项目和图标
*file:///- 本地文件
* trash:/// – 本地回收站目录
* ftp:// – FTP 文件夹
* ssh:// – SSH 文件夹
* fonts:/// – 字体文件夹,可将字体文件拖到此处以完成安装
* themes:/// – 系统主题文件夹

查看已安装字体
在nautilus的地址栏里输入”fonts:///“,就可以查看本机所有的fonts

程序
详细显示程序的运行信息
#strace -f -F -o outfile

日期和时间

设置日期
#date -s mm/dd/yy

设置时间
#date -s HH:MM

将时间写入CMOS
#hwclock –systohc

读取CMOS时间
#hwclock –hctosys

从服务器上同步时间
#sudo ntpdate time.nist.gov
#sudo ntpdate time.windows.com

控制台

不同控制台间切换
Ctrl + ALT + ← Ctrl + ALT + →

指定控制台切换
Ctrl + ALT + Fn(n:1~7)

控制台下滚屏
SHIFT + pageUp/pageDown

控制台抓图
#setterm -dump n(n:1~7)

数据库
mysql的数据库存放在地方
#/var/lib/mysql

从mysql中导出和导入数据
#mysqldump 数据库名 > 文件名 #导出数据库
#mysqladmin create 数据库名 #建立数据库
#mysql 数据库名 < 文件名 #导入数据库 忘了mysql的root口令怎么办 #sudo /etc/init.d/mysql stop #sudo mysqld_safe –skip-grant-tables #sudo mysqladmin -u user password ‘newpassword” #sudo mysqladmin flush-privileges 修改mysql的root口令 #sudo mysqladmin -uroot -p password ‘你的新密码’ 其它 下载网站文档 #wget -r -p -np -khttp://www.21cn.com · r:在本机建立服务器端目录结构; · -p: 下载显示HTML文件的所有图片; · -np:只下载目标站点指定目录及其子目录的内容; · -k: 转换非相对链接为相对链接。 如何删除Totem电影播放机的播放历史记录 #rm ~/.recently-used 如何更换gnome程序的快捷键 点击菜单,鼠标停留在某条菜单上,键盘输入任意你所需要的键,可以是组合键,会立即生效; 如果要清除该快捷键,请使用backspace vim 如何显示彩色字符 #sudo cp /usr/share/vim/vimcurrent/vimrc_example.vim /usr/share/vim/vimrc 如何在命令行删除在会话设置的启动程序 #cd ~/.config/autostart rm 需要删除启动程序 如何提高wine的反应速度 #sudo sed -ie ‘/GBK/,/^}/d’ /usr/share/X11/locale/zh_CN.UTF-8/XLC_LOCALE #chgrp [语法]: chgrp [-R] 文件组 文件… [说明]: 文件的GID表示文件的文件组,文件组可用数字表示, 也可用一个有效的组名表示,此命令改变一个文件的GID,可参看chown。 -R 递归地改变所有子目录下所有文件的存取模式 [例子]: #chgrp group file 将文件 file 的文件组改为 group #chmod [语法]: chmod [-R] 模式 文件… 或 chmod [ugoa] {+|-|=} [rwxst] 文件… [说明]: 改变文件的存取模式,存取模式可表示为数字或符号串,例如: #chmod nnnn file , n为0-7的数字,意义如下: 4000 运行时可改变UID 2000 运行时可改变GID 1000 置粘着位 0400 文件主可读 0200 文件主可写 0100 文件主可执行 0040 同组用户可读 0020 同组用户可写 0010 同组用户可执行 0004 其他用户可读 0002 其他用户可写 0001 其他用户可执行 nnnn 就是上列数字相加得到的,例如 chmod 0777 file 是指将文件 file 存取权限置为所有用户可读可写可执行。 -R 递归地改变所有子目录下所有文件的存取模式 u 文件主 g 同组用户 o 其他用户 a 所有用户 + 增加后列权限 - 取消后列权限 = 置成后列权限 r 可读 w 可写 x 可执行 s 运行时可置UID t 运行时可置GID [例子]: #chmod 0666 file1 file2 将文件 file1 及 file2 置为所有用户可读可写 #chmod u+x file 对文件 file 增加文件主可执行权限 #chmod o-rwx 对文件file 取消其他用户的所有权限 #chown [语法]: chown [-R] 文件主 文件… [说明]: 文件的UID表示文件的文件主,文件主可用数字表示, 也可用一个有效的用户名表示,此命令改变一个文件的UID,仅当此文件的文件主或超级用户可使用。 -R 递归地改变所有子目录下所有文件的存取模式 [例子]: #chown mary file 将文件 file 的文件主改为 mary #chown 150 file 将文件 file 的UID改为150 Ubuntu命令行下修改网络配置 以eth0为例 1. 以DHCP方式配置网卡 编辑文件/etc/network/interfaces: #sudo vi /etc/network/interfaces 并用下面的行来替换有关eth0的行: # The primary network interface - use DHCP to find our address auto eth0 iface eth0 inet dhcp 用下面的命令使网络设置生效: #sudo /etc/init.d/networking restart 当然,也可以在命令行下直接输入下面的命令来获取地址 #sudo dhclient eth0 2. 为网卡配置静态IP地址 编辑文件/etc/network/interfaces: #sudo vi /etc/network/interfaces 并用下面的行来替换有关eth0的行: # The primary network interface auto eth0 iface eth0 inet static address 192.168.3.90 gateway 192.168.3.1 netmask 255.255.255.0 network 192.168.3.0 broadcast 192.168.3.255 将上面的ip地址等信息换成你自己就可以了. 用下面的命令使网络设置生效: #sudo /etc/init.d/networking restart 3. 设定第二个IP地址(虚拟IP地址) 编辑文件/etc/network/interfaces: #sudo vi /etc/network/interfaces 在该文件中添加如下的行: auto eth0:1 iface eth0:1 inet static address 192.168.1.60 netmask 255.255.255.0 network x.x.x.x broadcast x.x.x.x gateway x.x.x.x 根据你的情况填上所有诸如address,netmask,network,broadcast和gateways等信息. 用下面的命令使网络设置生效: #sudo /etc/init.d/networking restart 4. 设置主机名称(hostname) 使用下面的命令来查看当前主机的主机名称: #sudo /bin/hostname 使用下面的命令来设置当前主机的主机名称: #sudo /bin/hostname newname 系统启动时,它会从/etc/hostname来读取主机的名称. 5. 配置DNS 首先,你可以在/etc/hosts中加入一些主机名称和这些主机名称对应的IP地址,这是简单使用本机的静态查询. 要访问DNS 服务器来进行查询,需要设置/etc/resolv.conf文件. 假设DNS服务器的IP地址是192.168.3.2, 那么/etc/resolv.conf文件的内容应为: search test.com nameserver 192.168.3.2 安装AMP服务 如果采用Ubuntu Server CD开始安装时,可以选择安装,这系统会自动装上apache2,php5和mysql5。下面主要说明一下如果不是安装的Ubuntu server时的安装方法。 用命令在Ubuntu下架设Lamp其实很简单,用一条命令就完成。在终端输入以下命令: #sudo apt-get install apache2 mysql-server php5 php5-mysql php5-gd #phpmyadmin 装好后,mysql管理员是root,无密码,通过http://localhost/phpmyadmin就可以访问mysql了 修改 MySql 密码 终端下输入: #mysql -u root #mysql> GRANT ALL PRIVILEGES ON *.* TO root@localhost IDENTIFIED BY “123456″;
’123456‘是root的密码,可以自由设置,但最好是设个安全点的。
#mysql> quit; 退出mysql

apache2的操作命令
启动:#sudo /etc/init.d/apache2 start
重启:#sudo /etc/init.d/apache2 restart
关闭:#sudo /etc/init.d/apache2 stop
apache2的默认主目录:/var/www/

原文地址:http://www.blogjava.net/bukebushuo/archive/2009/08/27/283427.html

[收藏]Jetty 的工作原理以及与 Tomcat 的比较

Jetty 的基本架构

Jetty 目前的是一个比较被看好的 Servlet 引擎,它的架构比较简单,也是一个可扩展性和非常灵活的应用服务器,它有一个基本数据模型,这个数据模型就是 Handler,所有可以被扩展的组件都可以作为一个 Handler,添加到 Server 中,Jetty 就是帮你管理这些 Handler。

Jetty 的基本架构

下图是 Jetty 的基本架构图,整个 Jetty 的核心组件由 Server 和 Connector 两个组件构成,整个 Server 组件是基于 Handler 容器工作的,它类似与 Tomcat 的 Container 容器,Jetty 与 Tomcat 的比较在后面详细介绍。Jetty 中另外一个比不可少的组件是 Connector,它负责接受客户端的连接请求,并将请求分配给一个处理队列去执行。
图 1. Jetty 的基本架构
图 1. Jetty 的基本架构

Jetty 中还有一些可有可无的组件,我们可以在它上做扩展。如 JMX,我们可以定义一些 Mbean 把它加到 Server 中,当 Server 启动的时候,这些 Bean 就会一起工作。
图 2. Jetty 的主要组件的类图
图 2. Jetty 的主要组件的类图

从上图可以看出整个 Jetty 的核心是围绕着 Server 类来构建,Server 类继承了 Handler,关联了 Connector 和 Container。Container 是管理 Mbean 的容器。Jetty 的 Server 的扩展主要是实现一个个 Handler 并将 Handler 加到 Server 中,Server 中提供了调用这些 Handler 的访问规则。

整个 Jetty 的所有组件的生命周期管理是基于观察者模板设计,它和 Tomcat 的管理是类似的。下面是 LifeCycle 的类关系图
LifeCycle 的类关系图

每个组件都会持有一个观察者(在这里是 Listener 类,这个类通常对应到观察者模式中常用的 Observer 角色,关于观察者模式可以参考 《Tomcat系统架构与设计模式,第2部分:设计模式分析》一文中关于观察者模式的讲解)集合,当 start、fail 或 stop 等事件触发时,这些 Listener 将会被调用,这是最简单的一种设计方式,相比 Tomcat 的 LifeCycle 要简单的多。

Handler 的体系结构

前面所述 Jetty 主要是基于 Handler 来设计的,Handler 的体系结构影响着整个 Jetty 的方方面面。下面总结了一下 Handler 的种类及作用:
图 3. Handler 的体系结构
图 3. Handler 的体系结构

Jetty 主要提供了两种 Handler 类型,一种是 HandlerWrapper,它可以将一个 Handler 委托给另外一个类去执行,如我们要将一个 Handler 加到 Jetty 中,那么就必须将这个 Handler 委托给 Server 去调用。配合 ScopeHandler 类我们可以拦截 Handler 的执行,在调用 Handler 之前或之后,可以做一些另外的事情,类似于 Tomcat 中的 Valve;另外一个 Handler 类型是 HandlerCollection,这个 Handler 类可以将多个 Handler 组装在一起,构成一个 Handler 链,方便我们做扩展。

Jetty 的启动过程

Jetty 的入口是 Server 类,Server 类启动完成了,就代表 Jetty 能为你提供服务了。它到底能提供哪些服务,就要看 Server 类启动时都调用了其它组件的 start 方法。从 Jetty 的配置文件我们可以发现,配置 Jetty 的过程就是将那些类配置到 Server 的过程。下面是 Jetty 的启动时序图:
图 4. Jetty 的启动流程
图 4. Jetty 的启动流程

因为 Jetty 中所有的组件都会继承 LifeCycle,所以 Server 的 start 方法调用就会调用所有已经注册到 Server 的组件,Server 启动其它组件的顺序是:首先启动设置到 Server 的 Handler,通常这个 Handler 会有很多子 Handler,这些 Handler 将组成一个 Handler 链。Server 会依次启动这个链上的所有 Handler。接着会启动注册在 Server 上 JMX 的 Mbean,让 Mbean 也一起工作起来,最后会启动 Connector,打开端口,接受客户端请求,启动逻辑非常简单。

接受请求

Jetty 作为一个独立的 Servlet 引擎可以独立提供 Web 服务,但是它也可以与其他 Web 应用服务器集成,所以它可以提供基于两种协议工作,一个是 HTTP,一个是 AJP 协议。如果将 Jetty 集成到 Jboss 或者 Apache,那么就可以让 Jetty 基于 AJP 模式工作。下面分别介绍 Jetty 如何基于这两种协议工作,并且它们如何建立连接和接受请求的。

基于 HTTP 协议工作

如果前端没有其它 web 服务器,那么 Jetty 应该是基于 HTTP 协议工作。也就是当 Jetty 接收到一个请求时,必须要按照 HTTP 协议解析请求和封装返回的数据。那么 Jetty 是如何接受一个连接又如何处理这个连接呢?

我们设置 Jetty 的 Connector 实现类为 org.eclipse.jetty.server.bi.SocketConnector 让 Jetty 以 BIO 的方式工作,Jetty 在启动时将会创建 BIO 的工作环境,它会创建 HttpConnection 类用来解析和封装 HTTP1.1 的协议,ConnectorEndPoint 类是以 BIO 的处理方式处理连接请求,ServerSocket 是建立 socket 连接接受和传送数据,Executor 是处理连接的线程池,它负责处理每一个请求队列中任务。acceptorThread 是监听连接请求,一有 socket 连接,它将进入下面的处理流程。

当 socket 被真正执行时,HttpConnection 将被调用,这里定义了如何将请求传递到 servlet 容器里,有如何将请求最终路由到目的 servlet,关于这个细节可以参考《 servlet 工作原理解析》一文。

下图是 Jetty 启动创建建立连接的时序图:
图 5. 建立连接的时序图
图 5. 建立连接的时序图

Jetty 创建接受连接环境需要三个步骤:

  1. 创建一个队列线程池,用于处理每个建立连接产生的任务,这个线程池可以由用户来指定,这个和 Tomcat 是类似的。
  2. 创建 ServerSocket,用于准备接受客户端的 socket 请求,以及客户端用来包装这个 socket 的一些辅助类。
  3. 创建一个或多个监听线程,用来监听访问端口是否有连接进来。

相比 Tomcat 创建建立连接的环境,Jetty 的逻辑更加简单,牵涉到的类更少,执行的代码量也更少了。

当建立连接的环境已经准备好了,就可以接受 HTTP 请求了,当 Acceptor 接受到 socket 连接后将转入下图所示流程执行:
图 6. 处理连接时序图
图 6. 处理连接时序图

Accetptor 线程将会为这个请求创建 ConnectorEndPoint。HttpConnection 用来表示这个连接是一个 HTTP 协议的连接,它会创建 HttpParse 类解析 HTTP 协议,并且会创建符合 HTTP 协议的 Request 和 Response 对象。接下去就是将这个线程交给队列线程池去执行了。

基于 AJP 工作

通常一个 web 服务站点的后端服务器不是将 Java 的应用服务器直接暴露给服务访问者,而是在应用服务器,如 Jboss 的前面在加一个 web 服务器,如 Apache 或者 nginx,我想这个原因大家应该很容易理解,如做日志分析、负载均衡、权限控制、防止恶意请求以及静态资源预加载等等。

下图是通常的 web 服务端的架构图:
图 7. Web 服务端架构
图 7. Web 服务端架构

这种架构下 servlet 引擎就不需要解析和封装返回的 HTTP 协议,因为 HTTP 协议的解析工作已经在 Apache 或 Nginx 服务器上完成了,Jboss 只要基于更加简单的 AJP 协议工作就行了,这样能加快请求的响应速度。

对比 HTTP 协议的时序图可以发现,它们的逻辑几乎是相同的,不同的是替换了一个类 Ajp13Parserer 而不是 HttpParser,它定义了如何处理 AJP 协议以及需要哪些类来配合。

实际上在 AJP 处理请求相比较 HTTP 时唯一的不同就是在读取到 socket 数据包时,如何来转换这个数据包,是按照 HTTP 协议的包格式来解析就是 HttpParser,按照 AJP 协议来解析就是 Ajp13Parserer。封装返回的数据也是如此。

让 Jetty 工作在 AJP 协议下,需要配置 connector 的实现类为 Ajp13SocketConnector,这个类继承了 SocketConnector 类,覆盖了父类的 newConnection 方法,为的是创建 Ajp13Connection 对象而不是 HttpConnection。如下图表示的是 Jetty 创建连接环境时序图:
Figure xxx. Requires a heading

与 HTTP 方式唯一不同的地方的就是将 SocketConnector 类替换成了 Ajp13SocketConnector。改成 Ajp13SocketConnector 的目的就是可以创建 Ajp13Connection 类,表示当前这个连接使用的是 AJP 协议,所以需要用 Ajp13Parser 类解析 AJP 协议,处理连接的逻辑都是一样的。如下时序图所示:
Figure xxx. Requires a heading

基于 NIO 方式工作

前面所描述的 Jetty 建立客户端连接到处理客户端的连接都是基于 BIO 的方式,它也支持另外一种 NIO 的处理方式,其中 Jetty 的默认 connector 就是 NIO 方式。

关于 NIO 的工作原理可以参考 developerworks 上关于 NIO 的文章,通常 NIO 的工作原型如下:

Selector selector = Selector.open(); 
 ServerSocketChannel ssc = ServerSocketChannel.open(); 
 ssc.configureBlocking( false ); 
 SelectionKey key = ssc.register( selector, SelectionKey.OP_ACCEPT ); 
 ServerSocketChannel ss = (ServerSocketChannel)key.channel(); 
 SocketChannel sc = ss.accept(); 
 sc.configureBlocking( false ); 
 SelectionKey newKey = sc.register( selector, SelectionKey.OP_READ ); 
 Set selectedKeys = selector.selectedKeys();

 

创建一个 Selector 相当于一个观察者,打开一个 Server 端通道,把这个 server 通道注册到观察者上并且指定监听的事件。然后遍历这个观察者观察到事件,取出感兴趣的事件再处理。这里有个最核心的地方就是,我们不需要为每个被观察者创建一个线程来监控它随时发生的事件。而是把这些被观察者都注册一个地方统一管理,然后由它把触发的事件统一发送给感兴趣的程序模块。这里的核心是能够统一的管理每个被观察者的事件,所以我们就可以把服务端上每个建立的连接传送和接受数据作为一个事件统一管理,这样就不必要每个连接需要一个线程来维护了。

这里需要注意的地方时,很多人认为监听 SelectionKey.OP_ACCEPT 事件就已经是非阻塞方式了,其实 Jetty 仍然是用一个线程来监听客户端的连接请求,当接受到请求后,把这个请求再注册到 Selector 上,然后才是非阻塞方式执行。这个地方还有一个容易引起误解的地方是:认为 Jetty 以 NIO 方式工作只会有一个线程来处理所有的请求,甚至会认为不同用户会在服务端共享一个线程从而会导致基于 ThreadLocal 的程序会出现问题,其实从 Jetty 的源码中能够发现,真正共享一个线程的处理只是在监听不同连接的数据传送事件上,比如有多个连接已经建立,传统方式是当没有数据传输时,线程是阻塞的也就是一直在等待下一个数据的到来,而 NIO 的处理方式是只有一个线程在等待所有连接的数据的到来,而当某个连接数据到来时 Jetty 会把它分配给这个连接对应的处理线程去处理,所以不同连接的处理线程仍然是独立的。

Jetty 的 NIO 处理方式和 Tomcat 的几乎一样,唯一不同的地方是在如何把监听到事件分配给对应的连接的处理方式。从测试效果来看 Jetty 的 NIO 处理方式更加高效。下面是 Jetty 的 NIO 处理时序图:
Figure xxx. Requires a heading

处理请求

下面看一下 Jetty 是如何处理一个 HTTP 请求的。

实际上 Jetty 的工作方式非常简单,当 Jetty 接受到一个请求时,Jetty 就把这个请求交给在 Server 中注册的代理 Handler 去执行,如何执行你注册的 Handler,同样由你去规定,Jetty 要做的就是调用你注册的第一个 Handler 的 handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 方法,接下去要怎么做,完全由你决定。

要能接受一个 web 请求访问,首先要创建一个 ContextHandler,如下代码所示:

Server server = new Server(8080); 
 ContextHandler context = new ContextHandler(); 
 context.setContextPath("/"); 
 context.setResourceBase("."); 
 context.setClassLoader(Thread.currentThread().getContextClassLoader()); 
 server.setHandler(context); 
 context.setHandler(new HelloHandler()); 
 server.start(); 
 server.join();

 

当我们在浏览器里敲入 http://localhost:8080 时的请求将会代理到 Server 类的 handle 方法,Server 的 handle 的方法将请求代理给 ContextHandler 的 handle 方法,ContextHandler 又调用 HelloHandler 的 handle 方法。这个调用方式是不是和 Servlet 的工作方式类似,在启动之前初始化,然后创建对象后调用 Servlet 的 service 方法。在 Servlet 的 API 中我通常也只实现它的一个包装好的类,在 Jetty 中也是如此,虽然 ContextHandler 也只是一个 Handler,但是这个 Handler 通常是由 Jetty 帮你实现了,我们一般只要实现一些我们具体要做的业务逻辑有关的 Handler 就好了,而一些流程性的或某些规范的 Handler,我们直接用就好了,如下面的关于 Jetty 支持 Servlet 的规范的 Handler 就有多种实现,下面是一个简单的 HTTP 请求的流程。

访问一个 Servlet 的代码:

 Server server = new Server(); 
 Connector connector = new SelectChannelConnector(); 
 connector.setPort(8080); 
 server.setConnectors(new Connector[]{ connector }); 
 ServletContextHandler root = new 
 ServletContextHandler(null,"/",ServletContextHandler.SESSIONS); 
 server.setHandler(root); 
 root.addServlet(new ServletHolder(new 
 org.eclipse.jetty.embedded.HelloServlet("Hello")),"/"); 
 server.start(); 
 server.join();

 

创建一个 ServletContextHandler 并给这个 Handler 添加一个 Servlet,这里的 ServletHolder 是 Servlet 的一个装饰类,它十分类似于 Tomcat 中的 StandardWrapper。下面是请求这个 Servlet 的时序图:
图 8. Jetty 处理请求的时序图
图 8. Jetty 处理请求的时序图

上图可以看出 Jetty 处理请求的过程就是 Handler 链上 handle 方法的执行过程,在这里需要解释的一点是 ScopeHandler 的处理规则,ServletContextHandler、SessionHandler 和 ServletHandler 都继承了 ScopeHandler,那么这三个类组成一个 Handler 链,它们的执行规则是:ServletContextHandler.handleServletContextHandler.doScope SessionHandler. doScopeServletHandler. doScopeServletContextHandler. doHandleSessionHandler. doHandleServletHandler. doHandle,它这种机制使得我们可以在 doScope 做一些额外工作。

与 Jboss 集成

前面介绍了 Jetty 可以基于 AJP 协议工作,在正常的企业级应用中,Jetty 作为一个 Servlet 引擎都是基于 AJP 协议工作的,所以它前面必然有一个服务器,通常情况下与 Jboss 集成的可能性非常大,这里介绍一下如何与 Jboss 集成。

Jboss 是基于 JMX 的架构,那么只要符合 JMX 规范的系统或框架都可以作为一个组件加到 Jboss 中,扩展 Jboss 的功能。Jetty 作为主要的 Servlet 引擎当然支持与 Jboss 集成。具体集成方式如下:

Jetty 作为一个独立的 Servlet 引擎集成到 Jboss 需要继承 Jboss 的 AbstractWebContainer 类,这个类实现的是模板模式,其中有一个抽象方法需要子类去实现,它是 getDeployer,可以指定创建 web 服务的 Deployer。Jetty 工程中有个 jetty-jboss 模块,编译这个模块就会产生一个 SAR 包,或者可以直接从官网下载一个 SAR 包。解压后如下图:
图 9. jboss-jetty 目录
图 9. jboss-jetty 目录

在 jboss-jetty-6.1.9 目录下有一个 webdefault.xml 配置文件,这个文件是 Jetty 的默认 web.xml 配置,在 META-INF 目录发下发现 jboss-service.xml 文件,这个文件配置了 MBean,如下:

 <mbean code="org.jboss.jetty.JettyService" 
         name="jboss.web:service=WebServer" xmbean-dd="META-INF/webserver-xmbean.xml>

 

同样这个 org.jboss.jetty.JettyService 类也是继成 org.jboss.web.AbstractWebContainer 类,覆盖了父类的 startService 方法,这个方法直接调用 jetty.start 启动 Jetty。

与 Tomcat 的比较

Tomcat 和 Jetty 都是作为一个 Servlet 引擎应用的比较广泛,可以将它们比作为中国与美国的关系,虽然 Jetty 正常成长为一个优秀的 Servlet 引擎,但是目前的 Tomcat 的地位仍然难以撼动。相比较来看,它们都有各自的优点与缺点。

Tomcat 经过长时间的发展,它已经广泛的被市场接受和认可,相对 Jetty 来说 Tomcat 还是比较稳定和成熟,尤其在企业级应用方面,Tomcat 仍然是第一选择。但是随着 Jetty 的发展,Jetty 的市场份额也在不断提高,至于原因就要归功与 Jetty 的很多优点了,而这些优点也是因为 Jetty 在技术上的优势体现出来的。

架构比较

从架构上来说,显然 Jetty 比 Tomcat 更加简单,如果你对 Tomcat 的架构还不是很了解的话,建议你先看一下 《Tomcat系统架构与设计模式》这篇文章。

Jetty 的架构从前面的分析可知,它的所有组件都是基于 Handler 来实现,当然它也支持 JMX。但是主要的功能扩展都可以用 Handler 来实现。可以说 Jetty 是面向 Handler 的架构,就像 Spring 是面向 Bean 的架构,iBATIS 是面向 statement 一样,而 Tomcat 是以多级容器构建起来的,它们的架构设计必然都有一个“元神”,所有以这个“元神“构建的其它组件都是肉身。

从设计模板角度来看 Handler 的设计实际上就是一个责任链模式,接口类 HandlerCollection 可以帮助开发者构建一个链,而另一个接口类 ScopeHandler 可以帮助你控制这个链的访问顺序。另外一个用到的设计模板就是观察者模式,用这个设计模式控制了整个 Jetty 的生命周期,只要继承了 LifeCycle 接口,你的对象就可以交给 Jetty 来统一管理了。所以扩展 Jetty 非常简单,也很容易让人理解,整体架构上的简单也带来了无比的好处,Jetty 可以很容易被扩展和裁剪。

相比之下,Tomcat 要臃肿很多,Tomcat 的整体设计上很复杂,前面说了 Tomcat 的核心是它的容器的设计,从 Server 到 Service 再到 engine 等 container 容器。作为一个应用服务器这样设计无口厚非,容器的分层设计也是为了更好的扩展,这是这种扩展的方式是将应用服务器的内部结构暴露给外部使用者,使得如果想扩展 Tomcat,开发人员必须要首先了解 Tomcat 的整体设计结构,然后才能知道如何按照它的规范来做扩展。这样无形就增加了对 Tomcat 的学习成本。不仅仅是容器,实际上 Tomcat 也有基于责任链的设计方式,像串联 Pipeline 的 Vavle 设计也是与 Jetty 的 Handler 类似的方式。要自己实现一个 Vavle 与写一个 Handler 的难度不相上下。表面上看,Tomcat 的功能要比 Jetty 强大,因为 Tomcat 已经帮你做了很多工作了,而 Jetty 只告诉,你能怎么做,如何做,有你去实现。

打个比方,就像小孩子学数学,Tomcat 告诉你 1+1=2,1+2=3,2+2=4 这个结果,然后你可以根据这个方式得出 1+1+2=4,你要计算其它数必须根据它给你的公式才能计算,而 Jetty 是告诉你加减乘除的算法规则,然后你就可以根据这个规则自己做运算了。所以你一旦掌握了 Jetty,Jetty 将变得异常强大。

性能比较

单纯比较 Tomcat 与 Jetty 的性能意义不是很大,只能说在某种使用场景下,它表现的各有差异。因为它们面向的使用场景不尽相同。从架构上来看 Tomcat 在处理少数非常繁忙的连接上更有优势,也就是说连接的生命周期如果短的话,Tomcat 的总体性能更高。

而 Jetty 刚好相反,Jetty 可以同时处理大量连接而且可以长时间保持这些连接。例如像一些 web 聊天应用非常适合用 Jetty 做服务器,像淘宝的 web 旺旺就是用 Jetty 作为 Servlet 引擎。

另外由于 Jetty 的架构非常简单,作为服务器它可以按需加载组件,这样不需要的组件可以去掉,这样无形可以减少服务器本身的内存开销,处理一次请求也是可以减少产生的临时对象,这样性能也会提高。另外 Jetty 默认使用的是 NIO 技术在处理 I/O 请求上更占优势,Tomcat 默认使用的是 BIO,在处理静态资源时,Tomcat 的性能不如 Jetty。

特性比较

作为一个标准的 Servlet 引擎,它们都支持标准的 Servlet 规范,还有 Java EE 的规范也都支持,由于 Tomcat 的使用的更加广泛,它对这些支持的更加全面一些,有很多特性 Tomcat 都直接集成进来了。但是 Jetty 的应变更加快速,这一方面是因为 Jetty 的开发社区更加活跃,另一方面也是因为 Jetty 的修改更加简单,它只要把相应的组件替换就好了,而 Tomcat 的整体结构上要复杂很多,修改功能比较缓慢。所以 Tomcat 对最新的 Servlet 规范的支持总是要比人们预期的要晚。

总结

本文介绍了目前 Java 服务端中一个比较流行应用服务器 Jetty,介绍了它的基本架构和工作原理以及如何和 Jboss 工作,最后与 Tomcat 做了比较。在看这篇文章的时候最好是结合我前面写的两篇文章《 Tomcat 系统架构与设计模式》和《 Servlet 工作原理解析》以及这些系统的源代码,耐心的都看一下会让你对 Java 服务端有个总体的了解。

return top