YM

JSP SmartUpload 下载小文件异常、错误的解决方法

yymmiinngg — Wed, 09 Jul 2008 12:06:03 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/213021 发表时间: 2008年07月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

<%@ page contentType="application/x-msdownload;charset=UTF-8" import="com.jspsmart.upload.*,java.io.File"%>
<%
	String filename = request.getParameter("filename");
	String resultdir = (String) request.getAttribute("resultdir");
	File file = new File(resultdir, filename);

	//新建一个SmartUpload对象
	SmartUpload su = new SmartUpload();

	// 初始化
	su.initialize(pageContext);
	// 设定contentDisposition为null以禁止浏览器自动打开文件，
	// 保证点击链接后是下载文件。若不设定，则下载的文件扩展名为
	// doc时，浏览器将自动用word打开它。扩展名为pdf时，
	// 浏览器将用acrobat打开。
	// 下载文件
	su.setContentDisposition(null);
	su.downloadFile(file.getAbsolutePath());
	
	// 如果是小文件加上这句就能处理
	response.getOutputStream().close();
%>

写一个SmartUpload下载，下载大文件大约10K没问题，但是1K左右的小文件就会报异常：java.lang.IllegalStateException: getOutputStream() has already been called for this response

我在JSP页面的最后加了一句“response.getOutputStream().close();”，问题解决。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

sql server 2005 将表记录导出到文件

yymmiinngg — Fri, 25 Apr 2008 11:38:32 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/186674 发表时间: 2008年04月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在使用sql server 2005数据时，需要将大量数据导出到文本文件就需要用到这个命令，该命令速度比较快。

命令行:>bcp "select [字段列表] from [数据库].DBO.[表或视图]" queryout [本地路径，如 D:\test.txt] -c -S[服务器名，如 localhost] -U[用户名，如 sa] -P[密码]

另外注意：如果环境变量里没有sql server 2005 的bin目录配置（即无法找到bcp命令），请到 sql server 2005/90/tool/bin 目录下运行此命令。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

PHP验证码应用，示例

yymmiinngg — Fri, 18 Jan 2008 14:48:35 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/157287 发表时间: 2008年01月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

近日试着用PHP做了一个验证码程序，示例如下：

一、准备一个展示并提交验证码的页面

二、以下是验证码生成页面，该页面在第一页面中被调用

三、这是验证页面，提示是否通过验证

通过验证！";

    } else {

       echo "验证错误！";

    }

    //关闭session，以清除所有注册过的变量

    session_destroy();

?>

四、开启服务，在地址栏中输入 “.../input.php” ，此处省略了主机及目录名

五、更多有关GD2库的介绍请参考：

http://www.cndw.com/tech/server/2006042051613.asp

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第六章、标识符和变量的作用域

yymmiinngg — Fri, 18 Jan 2008 13:47:30 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/157260 发表时间: 2008年01月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Ruby 的标识符用来指向常量，变量，方法，类和模块。标识符的首字符用来帮助我们确定标识所指向内容的作用域。

注意：关键字不能用来当作常量，变量，方法，类或模块的名字。

Ruby的标识符区分大小写。

Ruby 使用一个约定来帮助它区别一个名字的用法：名字前面的第一个字符表明这个名字的用法。局部变量、方法参数和方法名称应该用一个小写字母开头或者用一个下划线开头；全局变量用美元符作为前缀“$”；而实例变量用“@”开头；类变量用“@@” 开头；类名、模块名和常量应该用大写字母开头。

词首字母后面可以是字母、数字和下划线的任意组合；“@”后面不可以直接跟数字。

Ruby 程序代码现在是用7位ACSII 码来表示，通过语言扩展来支持 EUC, SJIS 或 UTF-8 等8位编码系统。Ruby 2.0 版本将 16位的 Unicode 编码。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第五章、ruby语法之——注释、关键字、运算符、分融符

yymmiinngg — Thu, 10 Jan 2008 19:36:34 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/154852 发表时间: 2008年01月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我们清楚ruby区分大小写，语法简明，代码简短精干，并且可读性较强。

下面让我们了解一下ruby的语法，这是学任何语言的开始(注释、关键字、运算符、分隔符等)。

一、注释与分行

Ruby中的注释有单行与多行两种，例如：

puts '以下是单行注释'
# 这行是单行注释，单行注释用"#"
=begin 
  多行注释可以用"=begin"和"=end"
  实际上，这也是Ruby的内嵌文档(Rdoc)注释，类似javadoc，可以用命令ri从源文件生产文档。 
=end
puts '=begin 和 =end 之前的是多行注释'

结果：
以下是单行注释
=begin 和 =end 之前的是多行注释

注：Rdoc是内嵌在ruby代码之中的，可以转换为html文档说明。类似javadoc。
ri是一个命令行程序，用来查看函数说明、类说明。函数说明、类说明应该放置在"=begin"和"=end"之中。"=begin"一定要写在行首，也就是说，这一行的前六个字符是"=begin"，不允许有空格在这之前。

Ruby 中用分号";"来表示一个语句的结束。一行如果有多个语句，每个语句用分号隔开，而最后一个语句可以省略分号。换行符表示一行结束。

如果语句太长，可以用"\"连接行。例如：

p  "行连接开始>>>" \
"<<<结束"

结果：
行连接开始>>><<<结束

二、关键字、运算符、分隔符

关键字、运算符、分隔符一起构成了一门编程语言的基本定义

Ruby中的常用分隔符如下：

符号

名称

用途

；

分号

用来分隔一行中的多个语句

()

圆括号

提高优先级；定义方法时容纳参数列表

"　"

空格/分隔字符

在可省略"()"的地方代替"()"

逗号

隔开多个参数

点

将对象与它的方法隔开

双冒号

域作用符，将模块(类)与它的常量隔开

Ruby中的关键字如下：

模块定义：module
类定义：　class
方法定义：def，undef
检查类型：defined?
条件语句：if，then，else，elsif，case，when，unless
循环语句：for，in，while，until，next，break，do，redo，retry，yield
逻辑判断：not，and，or
逻辑值：　true，false

空值：　　nil
异常处理：rescue，ensure
对象引用：super，self
块的起始：begin/end
嵌入模块：BEGIN，END
文件相关：__FILE__，__LINE__
方法返回：return
别名：　　alias

注：BEGIN模块相当于C语言中的宏， END模块用来作一些收尾工作。有了require，include，应该取消BEGIN和END的语法定义。

ruby中的运算符如下：优先级(由高到低)

能否重写
运算符
描述

Y
[]、[]=
数组下标、数组元素赋值

Y
**
乘冥

Y
！、~、+、-
非、位非、一元加(正号)、负号

Y
*、/、%
乘、除、模

Y
+、-
加、减

Y
>>、<<
右移、左移

Y
&
位与

Y
^、|
位异或、位或

Y
<=、<、>、>=
小于等于、小于、大于、大于等于

Y
<=>、==、===、=~、!=、!~
各种相等判断（不能重写=~、!=、!~）

N
&&
短路与

N
||
短路或

N
..、...
区间的开始点到结束点

N
? :
三元条件运算符

N
=、%=、~=、/=、-=、+=、|=、&=、>>=、<<=、*=、&&=、||=、**=
各种赋值

N
defined?
检查类型

N
not
逻辑非

N
or、and
逻辑或、逻辑与

N
if、unless、while、until
判断与循环

N
begin、end
定义方法，类，模块的范围

值得注意的是，ruby中没有"++"、"--"一类的运算符，但可以通过"+=1"、"-=1"实现。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

MySQL数据库服务器优化详细

yymmiinngg — Thu, 10 Jan 2008 13:07:12 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/154700 发表时间: 2008年01月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我最近在网上查了一些有关优化MySql的资料，并对照MySql手册对一些调优设置进行了细结，但是由于时间比较勿忙，没来得及对这些设置进行实验/测试，你可以把这些方法应用到实际中，得出具体结论。调优方法大致如下：

MySql服务器的后台管理程序，要想使用客户端程序，该程序必须运行，因为客户端通过连接服务器来访问数据库。下面让我们以服务器的系统变量和状态变量为根据，优化我们的MySql数据库服务。

在这之前，我们需要掌握以下方法：

查看MySql状态及变量的方法：

Mysql> show status ——显示状态信息（扩展show status like 'XXX'）
Mysql> show variables ——显示系统变量（扩展show variables like 'XXX'）
Mysql> show innodb status ——显示InnoDB存储引擎的状态
Shell> mysqladmin variables -u username -p password——显示系统变量
Shell> mysqladmin extended-status -u username -p password——显示状态信息

查看状态变量及帮助：

Shell> mysqld --verbose --help [|more #逐行显示]

首先，让我们看看有关请求连接的变量：

为了能适应更多数据库应用用户，MySql提供了连接（客户端）变量，以对不同性质的用户群体提供不同的解决方案，笔者就max_connections，back_log做了一些细结，如下：

max_connections是指MySql的最大连接数，如果服务器的并发连接请求量比较大，建议调高此值，以增加并行连接数量，当然这建立在机器能支撑的情况下，因为如果连接数越多，介于MySql会为每个连接提供连接缓冲区，就会开销越多的内存，所以要适当调整该值，不能盲目提高设值。可以过'conn%'通配符查看当前状态的连接数量，以定夺该值的大小。

back_log是要求MySQL能有的连接数量。当主要MySQL线程在一个很短时间内得到非常多的连接请求，这就起作用，然后主线程花些时间(尽管很短)检查连接并且启动一个新线程。back_log值指出在MySQL暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中。如果期望在一个短时间内有很多连接，你需要增加它。也就是说，如果MySql的连接数据达到max_connections时，新来的请求将会被存在堆栈中，以等待某一连接释放资源，该堆栈的数量即back_log，如果等待连接的数量超过back_log，将不被授予连接资源。另外，这值（back_log）限于您的操作系统对到来的TCP/IP连接的侦听队列的大小。你的操作系统在这个队列大小上有它自己的限制（可以检查你的OS文档找出这个变量的最大值），试图设定back_log高于你的操作系统的限制将是无效的。

优化了MySql的连接后属性后，我们需要看看缓冲区变量：

使用MySql数据库存储大量数据（或使用复杂查询）时，我们应该考虑MySql的内存配置。如果配置MySQL服务器使用太少的内存会导致性能不是最优的；如果配置了太多的内存则会导致崩溃，无法执行查询或者导致交换操作严重变慢。在现在的32位平台下，仍有可能把所有的地址空间都用完，因此需要审视。

计算内存使用的秘诀公式就能相对地解决这一部分问题。不过，如今这个公式已经很复杂了，更重要的是，通过它计算得到的值只是“理论可能”并不是真正消耗的值。事实上，有8GB内存的常规服务器经常能运行到最大的理论值（100GB甚至更高）。此外，你轻易不会使用到“超额因素”（它实际上依赖于应用以及配置）。一些应用可能需要理论内存的10%而有些仅需1%。
那么，我们可以做什么呢？

来看看那些在启动时就需要分配并且总是存在的全局缓冲吧！

全局缓冲：
key_buffer_size, innodb_buffer_pool_size, innodb_additional_mem_pool_size，innodb_log_buffer_size, query_cache_size

注：如果你大量地使用MyISAM表，那么你也可以增加操作系统的缓存空间使得MySQL也能用得着。把这些也都加到操作系统和应用程序所需的内存值之中，可能需要增加32MB甚至更多的内存给MySQL服务器代码以及各种不同的小静态缓冲。这些就是你需要考虑的在MySQL服务器启动时所需的内存。其他剩下的内存用于连接。

key_buffer_size决定索引处理的速度，尤其是索引读的速度。一般我们设为16M，通过检查状态值Key_read_requests和Key_reads，可以知道key_buffer_size设置是否合理。比例key_reads / key_read_requests应该尽可能的低，至少是1:100，1:1000更好（上述状态值可以使用'key_read%'获得用来显示状态数据）。key_buffer_size只对MyISAM表起作用。即使你不使用MyISAM表，但是内部的临时磁盘表是MyISAM表，也要使用该值。可以使用检查状态值'created_tmp_disk_tables'得知详情。

innodb_buffer_pool_size对于InnoDB表来说，作用就相当于key_buffer_size对于MyISAM表的作用一样。InnoDB使用该参数指定大小的内存来缓冲数据和索引。对于单独的MySQL数据库服务器，最大可以把该值设置成物理内存的80%。

innodb_additional_mem_pool_size指定InnoDB用来存储数据字典和其他内部数据结构的内存池大小。缺省值是1M。通常不用太大，只要够用就行，应该与表结构的复杂度有关系。如果不够用，MySQL会在错误日志中写入一条警告信息。

innodb_log_buffer_size指定InnoDB用来存储日志数据的缓存大小，如果您的表操作中包含大量并发事务（或大规模事务），并且在事务提交前要求记录日志文件，请尽量调高此项值，以提高日志效率。

query_cache_size是MySql的查询缓冲大小。（从4.0.1开始，MySQL提供了查询缓冲机制）使用查询缓冲，MySQL将SELECT语句和查询结果存放在缓冲区中，今后对于同样的SELECT语句（区分大小写），将直接从缓冲区中读取结果。根据MySQL用户手册，使用查询缓冲最多可以达到238%的效率。通过检查状态值’Qcache_%’，可以知道query_cache_size设置是否合理：如果Qcache_lowmem_prunes的值非常大，则表明经常出现缓冲不够的情况，如果Qcache_hits的值也非常大，则表明查询缓冲使用非常频繁，此时需要增加缓冲大小；如果Qcache_hits的值不大，则表明你的查询重复率很低，这种情况下使用查询缓冲反而会影响效率，那么可以考虑不用查询缓冲。此外，在SELECT语句中加入SQL_NO_CACHE可以明确表示不使用查询缓冲。

除了全局缓冲，MySql还会为每个连接发放连接缓冲。

连接缓冲：
每个连接到MySQL服务器的线程都需要有自己的缓冲。大概需要立刻分配256K，甚至在线程空闲时，它们使用默认的线程堆栈，网络缓存等。事务开始之后，则需要增加更多的空间。运行较小的查询可能仅给指定的线程增加少量的内存消耗，然而如果对数据表做复杂的操作例如扫描、排序或者需要临时表，则需分配大约read_buffer_size，sort_buffer_size，read_rnd_buffer_size，tmp_table_size大小的内存空间。不过它们只是在需要的时候才分配，并且在那些操作做完之后就释放了。有的是立刻分配成单独的组块。tmp_table_size 可能高达MySQL所能分配给这个操作的最大内存空间了。注意，这里需要考虑的不只有一点 —— 可能会分配多个同一种类型的缓存，例如用来处理子查询。一些特殊的查询的内存使用量可能更大——如果在MyISAM表上做成批的插入时需要分配 bulk_insert_buffer_size 大小的内存；执行 ALTER TABLE， OPTIMIZE TABLE， REPAIR TABLE 命令时需要分配 myisam_sort_buffer_size 大小的内存。

read_buffer_size是MySql读入缓冲区大小。对表进行顺序扫描的请求将分配一个读入缓冲区，MySql会为它分配一段内存缓冲区。read_buffer_size变量控制这一缓冲区的大小。如果对表的顺序扫描请求非常频繁，并且你认为频繁扫描进行得太慢，可以通过增加该变量值以及内存缓冲区大小提高其性能。

sort_buffer_size是MySql执行排序使用的缓冲大小。如果想要增加ORDER BY的速度，首先看是否可以让MySQL使用索引而不是额外的排序阶段。如果不能，可以尝试增加sort_buffer_size变量的大小。

read_rnd_buffer_size是MySql的随机读缓冲区大小。当按任意顺序读取行时(例如，按照排序顺序)，将分配一个随机读缓存区。进行排序查询时，MySql会首先扫描一遍该缓冲，以避免磁盘搜索，提高查询速度，如果需要排序大量数据，可适当调高该值。但MySql会为每个客户连接发放该缓冲空间，所以应尽量适当设置该值，以避免内存开销过大。

tmp_table_size是MySql的heap（堆积）表缓冲大小。所有联合在一个DML指令内完成，并且大多数联合甚至可以不用临时表即可以完成。大多数临时表是基于内存的(HEAP)表。具有大的记录长度的临时表 (所有列的长度的和)或包含BLOB列的表存储在硬盘上。如果某个内部heap（堆积）表大小超过tmp_table_size，MySQL可以根据需要自动将内存中的heap表改为基于硬盘的MyISAM表。还可以通过设置tmp_table_size选项来增加临时表的大小。也就是说，如果调高该值，MySql同时将增加heap表的大小，可达到提高联接查询速度的效果。

当我们设置好了缓冲区大小之后，再来看看：

table_cache所有线程打开的表的数目，增大该值可以增加mysqld需要的文件描述符的数量。每当MySQL访问一个表时，如果在表缓冲区中还有空间，该表就被打开并放入其中，这样可以更快地访问表内容。通过检查峰值时间的状态值’Open_tables’和’Opened_tables’，可以决定是否需要增加table_cache的值。如果你发现open_tables等于table_cache，并且opened_tables在不断增长，那么你就需要增加table_cache的值了（上述状态值可以使用’Open%tables’获得）。注意，不能盲目地把table_cache设置成很大的值。如果设置得太高，可能会造成文件描述符不足，从而造成性能不稳定或者连接失败。

做了以上方面的调优设置之后，MySql应该基本能满足您需求（当然是建立在调优设置适当的情况下），我们还应该了解并注意：

只有简单查询OLTP（联机事务处理）应用的内存消耗经常是使用默认缓冲的每个线程小于1MB，除非需要使用复杂的查询否则无需增加每个线程的缓冲大小。使用1MB的缓冲来对10行记录进行排序和用16MB的缓冲基本是一样快的（实际上16MB可能会更慢，不过这是其他方面的事了）。

找出MySQL服务器内存消耗的峰值。这很容易就能计算出操作系统所需的内存、文件缓存以及其他应用。在32位环境下，还需要考虑到32位的限制，限制 “mysqld” 的值大约为2.5G（实际上还要考虑到很多其他因素）。现在运行 “ps aux” 命令来查看 “VSZ” 的值（MySQL 进程分配的虚拟内存）。监视着内存变化的值，就能知道是需要增加或减少当前的内存值了。

最后来看看调优设置方法：

安装好MySql后，配制文件应该在 ./share/mysql ("./"即MySql安装目录) 目录中，配制文件有几个，有my-huge.cnf my-medium.cnf my-large.cnf my-small.cnf。win环境下即存在于MySql安装目录中的.ini文件。不同的流量的网站和不同配制的服务器环境，当然需要有不同的配制文件了。

一般的情况下，my-medium.cnf这个配制文件就能满足我们的大多需要；一般我们会把配置文件拷贝到 /etc/my.cnf ，win环境下则拷备到 my.ini 下即可，只需要修改这个配置文件就可以了。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JAVA发送HTTP请求，返回HTTP响应内容，实例及应用

yymmiinngg — Wed, 09 Jan 2008 11:26:58 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/154258 发表时间: 2008年01月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

JDK中提供了一些对无状态协议请求（HTTP）的支持，下面我就将我所写的一个小例子（组件）进行描述：

首先让我们先构建一个请求类（HttpRequester）。

该类封装了JAVA实现简单请求的代码，如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.Vector;
 
/**
 * HTTP请求对象
 * 
 * @author YYmmiinngg
 */
public class HttpRequester {
	private String defaultContentEncoding;
 
	public HttpRequester() {
		this.defaultContentEncoding = Charset.defaultCharset().name();
	}
 
	/**
	 * 发送GET请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendGet(String urlString) throws IOException {
		return this.send(urlString, "GET", null, null);
	}
 
	/**
	 * 发送GET请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @param params
	 *            参数集合
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendGet(String urlString, Map params)
			throws IOException {
		return this.send(urlString, "GET", params, null);
	}
 
	/**
	 * 发送GET请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @param params
	 *            参数集合
	 * @param propertys
	 *            请求属性
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendGet(String urlString, Map params,
			Map propertys) throws IOException {
		return this.send(urlString, "GET", params, propertys);
	}
 
	/**
	 * 发送POST请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendPost(String urlString) throws IOException {
		return this.send(urlString, "POST", null, null);
	}
 
	/**
	 * 发送POST请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @param params
	 *            参数集合
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendPost(String urlString, Map params)
			throws IOException {
		return this.send(urlString, "POST", params, null);
	}
 
	/**
	 * 发送POST请求
	 * 
	 * @param urlString
	 *            URL地址
	 * @param params
	 *            参数集合
	 * @param propertys
	 *            请求属性
	 * @return 响应对象
	 * @throws IOException
	 */
	public HttpRespons sendPost(String urlString, Map params,
			Map propertys) throws IOException {
		return this.send(urlString, "POST", params, propertys);
	}
 
	/**
	 * 发送HTTP请求
	 * 
	 * @param urlString
	 * @return 响映对象
	 * @throws IOException
	 */
	private HttpRespons send(String urlString, String method,
			Map parameters, Map propertys)
			throws IOException {
		HttpURLConnection urlConnection = null;
 
		if (method.equalsIgnoreCase("GET") && parameters != null) {
			StringBuffer param = new StringBuffer();
			int i = 0;
			for (String key : parameters.keySet()) {
				if (i == 0)
					param.append("?");
				else
					param.append("&");
				param.append(key).append("=").append(parameters.get(key));
				i++;
			}
			urlString += param;
		}
		URL url = new URL(urlString);
		urlConnection = (HttpURLConnection) url.openConnection();
 
		urlConnection.setRequestMethod(method);
		urlConnection.setDoOutput(true);
		urlConnection.setDoInput(true);
		urlConnection.setUseCaches(false);
 
		if (propertys != null)
			for (String key : propertys.keySet()) {
				urlConnection.addRequestProperty(key, propertys.get(key));
			}
 
		if (method.equalsIgnoreCase("POST") && parameters != null) {
			StringBuffer param = new StringBuffer();
			for (String key : parameters.keySet()) {
				param.append("&");
				param.append(key).append("=").append(parameters.get(key));
			}
			urlConnection.getOutputStream().write(param.toString().getBytes());
			urlConnection.getOutputStream().flush();
			urlConnection.getOutputStream().close();
		}
 
		return this.makeContent(urlString, urlConnection);
	}
 
	/**
	 * 得到响应对象
	 * 
	 * @param urlConnection
	 * @return 响应对象
	 * @throws IOException
	 */
	private HttpRespons makeContent(String urlString,
			HttpURLConnection urlConnection) throws IOException {
		HttpRespons httpResponser = new HttpRespons();
		try {
			InputStream in = urlConnection.getInputStream();
			BufferedReader bufferedReader = new BufferedReader(
					new InputStreamReader(in));
			httpResponser.contentCollection = new Vector();
			StringBuffer temp = new StringBuffer();
			String line = bufferedReader.readLine();
			while (line != null) {
				httpResponser.contentCollection.add(line);
				temp.append(line).append("\r\n");
				line = bufferedReader.readLine();
			}
			bufferedReader.close();
 
			String ecod = urlConnection.getContentEncoding();
			if (ecod == null)
				ecod = this.defaultContentEncoding;
 
			httpResponser.urlString = urlString;
 
			httpResponser.defaultPort = urlConnection.getURL().getDefaultPort();
			httpResponser.file = urlConnection.getURL().getFile();
			httpResponser.host = urlConnection.getURL().getHost();
			httpResponser.path = urlConnection.getURL().getPath();
			httpResponser.port = urlConnection.getURL().getPort();
			httpResponser.protocol = urlConnection.getURL().getProtocol();
			httpResponser.query = urlConnection.getURL().getQuery();
			httpResponser.ref = urlConnection.getURL().getRef();
			httpResponser.userInfo = urlConnection.getURL().getUserInfo();
 
			httpResponser.content = new String(temp.toString().getBytes(), ecod);
			httpResponser.contentEncoding = ecod;
			httpResponser.code = urlConnection.getResponseCode();
			httpResponser.message = urlConnection.getResponseMessage();
			httpResponser.contentType = urlConnection.getContentType();
			httpResponser.method = urlConnection.getRequestMethod();
			httpResponser.connectTimeout = urlConnection.getConnectTimeout();
			httpResponser.readTimeout = urlConnection.getReadTimeout();
 
			return httpResponser;
		} catch (IOException e) {
			throw e;
		} finally {
			if (urlConnection != null)
				urlConnection.disconnect();
		}
	}
 
	/**
	 * 默认的响应字符集
	 */
	public String getDefaultContentEncoding() {
		return this.defaultContentEncoding;
	}
 
	/**
	 * 设置默认的响应字符集
	 */
	public void setDefaultContentEncoding(String defaultContentEncoding) {
		this.defaultContentEncoding = defaultContentEncoding;
	}
}

其次我们来看看响应对象（HttpRespons）。响应对象其实只是一个数据BEAN，由此来封装请求响应的结果数据，如下：

import java.util.Vector;
 
/**
 * 响应对象
 */
public class HttpRespons {
 
	String urlString;
 
	int defaultPort;
 
	String file;
 
	String host;
 
	String path;
 
	int port;
 
	String protocol;
 
	String query;
 
	String ref;
 
	String userInfo;
 
	String contentEncoding;
 
	String content;
 
	String contentType;
 
	int code;
 
	String message;
 
	String method;
 
	int connectTimeout;
 
	int readTimeout;
 
	Vector contentCollection;
 
	public String getContent() {
		return content;
	}
 
	public String getContentType() {
		return contentType;
	}
 
	public int getCode() {
		return code;
	}
 
	public String getMessage() {
		return message;
	}
 
	public Vector getContentCollection() {
		return contentCollection;
	}
 
	public String getContentEncoding() {
		return contentEncoding;
	}
 
	public String getMethod() {
		return method;
	}
 
	public int getConnectTimeout() {
		return connectTimeout;
	}
 
	public int getReadTimeout() {
		return readTimeout;
	}
 
	public String getUrlString() {
		return urlString;
	}
 
	public int getDefaultPort() {
		return defaultPort;
	}
 
	public String getFile() {
		return file;
	}
 
	public String getHost() {
		return host;
	}
 
	public String getPath() {
		return path;
	}
 
	public int getPort() {
		return port;
	}
 
	public String getProtocol() {
		return protocol;
	}
 
	public String getQuery() {
		return query;
	}
 
	public String getRef() {
		return ref;
	}
 
	public String getUserInfo() {
		return userInfo;
	}
 
}

最后，让我们写一个应用类，测试以上代码是否正确

import com.yao.http.HttpRequester; import com.yao.http.HttpRespons; public class Test { public static void main(String[] args) { try { HttpRequester request = new HttpRequester(); HttpRespons hr = request.sendGet("http://www.csdn.net"); System.out.println(hr.getUrlString()); System.out.println(hr.getProtocol()); System.out.println(hr.getHost()); System.out.println(hr.getPort()); System.out.println(hr.getContentEncoding()); System.out.println(hr.getMethod()); System.out.println(hr.getContent()); } catch (Exception e) { e.printStackTrace(); } } }

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JAVA中使用Htmlparse解析HTML文档

yymmiinngg — Wed, 09 Jan 2008 11:00:55 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/154250 发表时间: 2008年01月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

import java.util.HashMap;
import java.util.Map;
import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.tags.LinkTag;
import org.htmlparser.util.NodeList;
import com.yao.http.HttpRequester;
import com.yao.http.HttpRespons;
 
/**
 * JAVA中使用Htmlparse解析HTML文档，使用htmlparse遍历出HTML文档的所有超链接（标记）。
 * 
 * @author YYmmiinngg
 */
public class Test {
	public static void main(String[] args) {
		try {
/* 首先我们先使用HttpRequester类和HttpRespons类获得一个HTTP请求中的数据（HTML文档）。 可以从(http://download.csdn.net/source/321516)中下载htmlloader，该库中有上述类；或从我的《JAVA发送HTTP请求，返回HTTP响应内容，实例及应用》一文中摘取上述两JAVA类的代码。htmlparse可以从(http://download.csdn.net/source/321507)中下载
*/
			Map map = new HashMap();
			HttpRequester request = new HttpRequester();
			HttpRespons hr = request.sendGet("http://www.baidu.com");
 
			Parser parser = Parser.createParser(hr.getContent(), hr
					.getContentEncoding());
			try {
				// 通过过滤器过滤出标签
				NodeList nodeList = parser
						.extractAllNodesThatMatch(new NodeFilter() {
							//实现该方法,用以过滤标签
							public boolean accept(Node node) {
								if (node instanceof LinkTag)//标记
									return true;
								return false;
							}
						});
				// 打印
				for (int i = 0; i < nodeList.size(); i++) {
					LinkTag n = (LinkTag) nodeList.elementAt(i);
					System.out.print(n.getStringText() + " ==>> ");
					System.out.println(n.extractLink());
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
 
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

MYSQL数据同步,双向热备

yymmiinngg — Tue, 08 Jan 2008 10:53:09 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/153875 发表时间: 2008年01月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、简要介绍：mysql从3.23.15版本以后提供数据库复制功能。利用该功能可以实现两个数据库同步，主从模式(A->B)，互相备份模式(A<=>B)的功能。
mysql数据库同步复制功能的设置都在mysql的配置文件中体现。在linux环境下的配置文件一般在/etc/mysql/my.cnf或者在mysql用户的home目录下的my.cnf，笔者的my.cnf则在/etc/my.cnf；windows环境下则可到mysql安装路径下找到my.ini。

2、下面我们来看看如何配置数据同步(A->B)：
(笔者mysql版本 5.0.26)
假设数据库A为主机（将向B提供同步服务，即B中的数据来自A）：
A机器：
IP = 192.168.1.101
B机器：
IP = 192.168.1.102

(1).在A机器中有数据库如下：

//数据库A
CREATE DATABASE backup_db;
USE backup_db;
CREATE TABLE `backup_table` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(20) character set utf8 NOT NULL,
`sex` varchar(2) character set utf8 NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

#A机器的my.cnf(或my.ini)中应该配置：
server-id=1
log-bin=c:\mysqlback #同步事件的日志记录文件
binlog-do-db=backup_db #提供数据同步服务的数据库

(2).在B机器中有数据库如下：

//数据库B
CREATE DATABASE backup_db;
USE backup_db;
CREATE TABLE `backup_table` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(20) character set utf8 NOT NULL,
`sex` varchar(2) character set utf8 NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
注：数据库A和B的数据库结构一定要相同，否则无法构成同步。

#B机器的my.cnf(或my.ini)中应该配置：
server-id=2
master-host=192.168.1.101 #主机A的地址
master-user=ym #主机A提供给B的用户，该用户中需要包括数据库backup_db的权限
master-password=ym #访问密码
master-port=3306 #端口，主机的MYSQL端口
master-connect-retry=60 #重试间隔60秒
replicate-do-db=backup_db #同步的数据库

(3).完成了以上配置之后，将A的mysql数据的权限给B。
A机器：
mysql>GRANT FILE ON *.* TO ym@'192.168.1.102' IDENTIFIEDBY ‘ym’;

(4).重启AB数据库，后：
B机器：
mysql>slave start;

查看同步配置情况
A机器：
mysql>show master status;
B机器：
mysql>show slave status;

(5).在A中的backup_db.backup_table表中插入一些数据，查看B中的backup_db.backup_table表是否同步了数据改动。如果没有看到同步数据结果，即同步不成功，请查看错误（如下）。
当有错误产生时*.err日志文件（可到mysql安装目录下找），同步的线程退出。当纠正错误后重复步骤(4)。

3、实现双向热备(A<=>B)：
将以上的(1)-(5)步骤按A-B双向配置即可。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第四章、ruby之Hello word

yymmiinngg — Fri, 04 Jan 2008 17:46:53 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/153172 发表时间: 2008年01月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

下面就从我们非常熟悉的“Hello word”入手，来学习简单的ruby语言应用。

我们约定在windows xp操作系统平台下，使用命令行方式创建并运行ruby程序

一、Hello word

打开命令窗口(“开始”->“运行”)：

cmd

将当前目录定位在C盘(XXXX表示不确定当前目录) ：

xxxx>c:
xxxx>cd \

输入编辑命令：

C:\>edit hello.rb

　将打开原始的文本编辑器

输入如下语句

puts "Hello word!"

快捷键： "Alt + F + X"->选择保存退出"Y"

C:\>ruby hello.rb

我们将看到结果：

Hello word!

这样我们就完成了第一个ruby程序，也是最简单的“Hello word”程序！

二、puts与p的区别

以上就是用ruby写的“Hello word”，“puts”是ruby向控制台打印文字的内置函数，将向用户输出字符定界符（>"<或>'<）内的字符串（或表达式）内容。简单吧！

下面我们再打开hello.rb，这次我们用"notepad"吧：
C:\>notepad c:\hello.rb
将程序改为：

puts "Hello word!"
p "Hello word!"

注：在ruby中程序代码结束可以是换行符和“;”
以上代码也可写成

puts "Hello word" ; p "Hello word"

代码中的“p”同样是字符串输出语句
然后再运行“hello.rb”
这时我们将看到：
Hello word!
"Hello word!"

同样是向控制台输出字符串，但结果有不同
这是因为在ruby中，“puts”是用来正常的向控制台输出结果串，“p”用作调试期间的输出命令，将结果串用>"<括起来，并且将>"<转成转义码"\""。
从运行以下代码可以看出：

puts "\"Hello word!\"" 
p "\"Hello word!\""

结果是：
"Hello word!"
"\"Hello word!\""

三、使用>"<与>'<的区别

下面我们来看看这段代码：

@a = "YYmmiinngg"
puts "Hello #@a!"
puts 'Hello #@a!'

输出：
Hello YYmmiinngg!
Hello #@a!
注：@a是一个变量(有关变量的描述请参看后续章节，此处不多加解释！)
为什么第一行与第二行的输出又不同呢？原因是：在ruby中使用>"<括起来的字符串中的"#@XX"将会解析成替换“@XX”变量，而>'<将原样输出内容。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第三章、ruby命令行参数介绍

yymmiinngg — Thu, 03 Jan 2008 18:08:03 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/152900 发表时间: 2008年01月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

命令行参数

“从命令行开始”。不管Ruby用在哪个系统上，无论是超级的科学工作站或者是嵌入式PDA设备，你无论如何都要从Ruby的解释器开始，这会给我们传递命令行参数的机会。

Ruby的命令行由三个部分组成：Ruby解释器选项，可选的要运行程序的名字，和可选的用于那个程序的一组参数。

ruby [ options ] [ -- ] [ programfile ] [ arguments ]

Ruby选项是命令行直接跟在第一个单词后面的，它不能用连字号，或特殊标志--(两个连字号)开头。

如果命令行上未出现文件名，或如果文件名是单个连字号(-)，Ruby从标准输入中读取程序源代码。

传递给程序本身的参数跟随在程序名字的后面。例如：

% ruby -w - "Hello World"

打开警告，从标准输入读取程序，并传递双引号字符串"Hello World"做为参数。

命令行选项

-0[octal] 0标志(数字零)指定记录的分隔字符(，如果没有数字跟随)。-00指出段落模式：记录由两个连续的缺省记录分隔字符分隔。-0777一次读入整个文件(它像个非法字符)。设置$/。

-a 当使用-n或-p时的自动分离模式，等价于在每个循环迭代器上执行$F = $_.split。

-C directory 在运行之前修改工作路径。

-c 只检查符号，不运行程序。

-copyright 打印版权信息并退出。

-d, -debug 设置 $DEBUG 和 $VERBOSE 为 true。这可以用于你的程序的额外追踪。

-e 'command' 执行做为一行Ruby源码的命令。允许几个-e，在同一程序中命令被视做多行。当-e出现时，如果程序文件被忽略，在-e命令被运行完后中止运行。程序运行时使用-e可访问旧的条件中的范围和正则表达式的行为-整数范围比较当前输入行号，正式表达式匹配$_。

-F pattern 指定用于split()的缺省输入字段分隔符($;)(影响-a选项)。

-h, -help 显示一个简短的帮助屏幕。

-I directories 指定预定义的$LOAD_PATH($:)指令。可以有多个-I选项。每个-I后可有多个用冒号：分隔的指令。在类Unix系统上是分号(;)。

-i[extension] 以替换形式编辑ARGV文件。ARGV内的每个文件名，你写入到标准输出的任何东西，都将被回储到那个文件的内容中。如果有扩展名的话，备份文件会被保留下来。

% ruby -pi. bak –e "gsub(/Perl/, 'Ruby')" *.txt

-K kcode 指定要使用的编码。当Ruby使用日语时这个选项很有用。Kcode可以是这些当中的一个： e, E for EUC; s, S 对应 SJIS; u, U 对应 UTF-8; or a, A, n, N 对应 ASCII.

-l 自动进行行尾处理；设置$的值为$/，并且对读入的行自动地进行String#chop!处理。

-n Assumes a while gets; ...; end loop around your program. For example, a simple grep command could be implemented as

% ruby –n –e "print if /wombat/" *.txt

-p Places your program code within the loop while gets; ...; print; end.

% ruby –p –e "$_.downcase!" *.txt

-r library 在运行前请求给出名字的库。

-S 查看程序文件是否使用了RUBYPATH或PATH环境变量。

-s Any command-line switches found after the program filename, but before any filename arguments or before a , are removed from ARGV and set to a global variable named for the switch. In the following example, the effect of this would be to set the variable $opt to "electric".

% ruby -s prog -opt= electric ./mydata

-T[level] 设置安全级别，执行不纯度测试(见379页)。设置$SAFE。

-v, -verbose 设置$VERBOSE为true，打开冗长模式。也打印版本号。在冗长模式中，可打印编译警告。如果命令行上没有指定文件名，则Ruby退出。

--version 显示Ruby的版本信息并退出。

-w 打开冗长模式。与-v不同，如果命令行上没有指定文件名则从标准输入读入程序。我们推荐带 –w 来运行你程序。

-W level 设置警告的级别。可有一个或两个级别(或者没指定级别)，等价于-w—给出额外的警告。如果级别为1，运行在标准(缺省)警告级别上。使用-W0则不显示警告(包括使用Kernel.warn的警告)。

-X directory 在运行前更改工作目录。类似于-c directory 。

-x [directory] 从#!Ruby行取出文本，如果指定目录的话，并且要修改工作目录。

-y, -yydebug 在解析器中打开yacc调试器。

ARGV

程序名字后面的任何命令行参数都会对你的程序打开全局数组ARGV。例如，假设test.rb包含了下面程序：

ARGV.each {|arg| p arg }

用下同命令行调用它：

% ruby –w test.rb "Hello World" a1 1.6180

会产生如下输出：

"Hello World"

"a1"

"1.6180"

这是给C程序员准备的—ARGV[0]是传递给程序的第一个参数，不是程序的名字。当前程序的名字是全局变量$0中的变量。注意ARGV的所有值都是字符串。

如果你的程序试图从标准输入来读(或使用特殊文件ARGF，它 321页描述)，ARGV内的程序参数将接受文件名，并且Ruby会从这些文件中读入。如果你程序带有混合参数和文件名，确信你在从文件读之前倾空了ARGV数组。

程序中止

方法Kernel#exit中止你的程序，并向操作系统返回一个状态值。虽然，不像一些语言，exit不立即中止程序。Kernel#exit首先引发一个SystemExit异常，你可以捕获它，然后程序执行一系列清除动作，包括运行所有的注册的at_exit方法和对象的finalizer。参考500页的Kernel#exit描述。

环境变量

你可以使用预定义的变量ENV来访问操作系统环境变量。它像哈希表一样响应一些方法。[ENV其实不是哈希表，但如果你需要的话，你可以使用ENV#to_hash，来把它转换到成哈希表]。

ENV['SHELL'] => "/bin/sh"

ENV['HOME'] => "/Users/dave"

ENV['USER'] => "dave"

ENV.keys.size => 34

ENV.keys[0, 7] => ["MANPATH", "TERM_PROGRAM", "TERM", "SHELL",

"SAVEHIST", "HISTSIZE", "MAKEFLAGS"]

当Ruby首次启动时要读取一些环境变量值。这些变量修改解释程序的行为，像表14.1中显示的。

Table 14.1. Ruby使用的环境变量

变量名称
　描述

DLN_LIBRARY_PATH
　用于搜索被动态加载的模块的路径。

HOME
　指向用户的主目录。

LOGDIR
　Fallback pointer to the user’s home directory if $HOME is not set. Used only by Dir.chdir.

OPENSSL_CONF
　指定OpenSSL的本地配置文件。

RUBYLIB
　为Ruby程序添加搜索路径($SAFE 必须被设置成)。

RUBYLIB_PREFIX (Windows only)
　Mangle the RUBYLIB search path by adding this prefix to each component.

RUBYOPT
　给Ruby添加命令行选项，在命令行选项并解析后进行检查($SAFE 必须设置成0)。

RUBYPATH
　指定–S选项，Ruby会搜索路径(缺省值是PATH)。

RUBYSHELL
　Shell to use when spawning a process under Windows; if not set, will also check SHELL or COMSPEC.

RUBY_TCL_DLL
　Override default name for TCL shared library or DLL.

RUBY_TK_DLL
　Override default name for Tk shared library or DLL. Both this and RUBY_TCL_DLL must be set for either to be used.

写入环境变量

Ruby程序可以对ENV对象进行写操作。在大多数系统上这会修改相应的环境变量的值。虽然，这种修改是本地的，只针对于这个进程或其随后的子进程。环境变量的种继承在下面例子中说明。一个子进程若修改了一个环境变量，这个修改会被一个进程继承然后启动。尽管修改对原有的父进程不可见。(这只是证明了它的父进程并不真的知道子进程再做什么。)

puts "In parent, term = #{ENV['TERM']}"

fork do

puts "Start of child 1, term = #{ENV['TERM']}"

ENV['TERM'] = "ansi"

fork do

puts "Start of child 2, term = #{ENV['TERM']}"

end

Process.wait

puts "End of child 1, term = #{ENV['TERM']}"

end

Process.wait

puts "Back in parent, term = #{ENV['TERM']}"

produces:

In parent, term = xtermcolor

Start of child 1, term = xtermcolor

Start of child 2, term = ansi

End of child 1, term = ansi

Back in parent, term = xtermcolor

Ruby在哪里找到它的模块

你使用require或load来使库模块添加到你的Ruby程序内。这些模块中一些应用于Ruby，一些你可以安装Ruby的应用程序文档(RAA),一些是你自己写。Ruby是如何找到它们呢？

当Ruby构建你的特殊机器时，它会预先确定持有库资料的标准目录。这些依赖于机器。你可以像这样在命令行中确定它们

% ruby –e 'puts $:'

在典型的Linux box 上，你或许会找到一些如下面显示的。注意Ruby1.8中，这些目录的次序已被修改—下面目录依赖于它们的机器。

/usr/local/lib/ruby/site_ruby/1.8

/usr/local/lib/ruby/site_ruby/1.8/i686linux

/usr/local/lib/ruby/site_ruby

/usr/local/lib/ruby/1.8

/usr/local/lib/ruby/1.8/i686linux

site_ruby目录持有模块和你添加扩展的模块。依赖于系统的目录(本例中是i686-linux)持有可运行的和其它指定给此机器的。所有这些目录被自动地包含在Ruby对模块的搜索路径内。

源文出处：http://www.rorchina.net/?viewnews-933.htm

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第二章、ruby安装

yymmiinngg — Thu, 03 Jan 2008 17:50:52 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/152893 发表时间: 2008年01月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

window下的安装方法就不多说了，很简单，下载exe安装文件，根据提示单击安装即可。

以下是linux下安装ruby的方式：

1、下载ruby安装包（地址：http://www.ruby-lang.org/en/downloads/）

2、解压安装包：

　tar xzvf ruby-1.8.5.tar.gz
　cd ruby-1.8.5

3、配置&安装
　./configure –prefix=/usr/local/ruby
　make && make install

如果想浏览所有的configure参数，可以：
　./configure –help |more

如果不定制安装的目录，默认将安装到/usr/local目录下面。然而我建议自行定制一个ruby的安装目录，例如/usr/local/ruby，这样便于以后的升级，不会和操作系统其他软件混在一起。

安装好以后，修改操作系统PATH路径，加入/usr/local/ruby/bin：
export PATH=/usr/local/ruby/bin:$PATH
将我们自己安装的ruby放在系统PATH前面，避免操作系统自带的ruby造成的干扰。在Linux上，一般将设置放在/etc/profile中，便于对全局生效。

有关ruby on rails以及其它支持的安装方法请访问：http://www.javaeye.com/topic/43228

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

第一章、ruby简介

yymmiinngg — Thu, 03 Jan 2008 16:56:34 +0800

作者: yymmiinngg 链接：http://yymmiinngg.javaeye.com/blog/152866 发表时间: 2008年01月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Ruby是一种简单的面向对象编程语言，十分容易上手，并且功能强大。她是一个日本的Yukihiro Matsumoto（大家都叫他Matz.）在1995年首次发布的。Ruby从Perl语言那里借鉴了许多东西（有人形象地说Ruby是Perl的漂亮的妹妹：），和Perl相似，Ruby也擅长于文本处理、系统管理等任务。

Ruby是面向对象的编程语言，她追求的是“简便快捷的面向对象编程”。Ruby是解释型语言，因此不需编译即可快捷地编程。同时Ruby具有类似Perl的强大的文本处理功能，她可并不只是个玩具，您可以用她来进行实用的编程。此外，您还可以很方便地使用C语言来扩展Ruby的功能，因此可以把她当作各种库的前端来使用。

若您曾经“想要一种简单的面向对象的语言”，或者认为“Perl的功能虽然好用，但它的语法真让人受不了”，又或者觉得“lisp系列语言的思想不错，但到处都是括号真让人讨厌，最起码算式应该按照通常的样式书写”。那么，Ruby或许能让您满意。

ruby作者简介：

Matz是一个专业的软件工程师，在日本有名的opensource公司netlab.JP工作，而且他在日本也是一个高姿态的opensource布道者。他参与了几个开源软件项目，包括cmail，这是一个基于emacs的邮件用户代理，完全用emacslisp编写。Ruby也是他的第一个在日本以外的国家如此出名的作品。
在1993年的时候，有一次他和同事们谈论关于脚本语言（scriptinglanguage）的事情，Matz深深的认识到了脚本语言的强大和可行性，他想也许脚本语言是他的方向。
由于Matz很早以前就对面向对象编程很感兴趣，所以他认为面向对象也会适合脚本语言编程。然后，他到网络上去找了一些相关的东西，并且发现了perl5，当时它还没有发布，并且打算支持面向对象的特点，但是Matz发现这并不是他想找的东西，所以他放弃了把perl当作一个面向对象的脚本语言。
然后Matz转向了Python。Python是一个解释型的、面向对象语言，但是Matz发现它并不能完全算作“脚本”语言。Matz认为Python是面向对象和程序化语言（proceduralprogramming）的混合产物。
Matz希望的是一种比Perl强大，比Python更面向对象的语言，所以，他打算设计一个全新的自己的语言。Matz的开发从1993年2月24日开始，同年夏天，第一个Ruby语言的HelloWorld程序成功运行，第一个alpha版本在1994年12月发布。
直到1996年都是Matz一个人在开发，从这时候开始Ruby社区也渐渐形成，尽管现在大部分的开发还是Matz自己来开发，但很多人都给了Matz有意义的帮助，包括提交bug和patch等。
Ruby这个名字意为珍贵的宝石，千万不要认为是什么缩写，比如PERL。当作者开始写ruby的时候，跟一个同事开玩笑说这个项目要以一个宝石的名字命名。那个同事就说”ruby”，就是一种美丽贵重的宝石的名字。所以作者用了这个名字，并且最后在官方发布版本中，也延续了这个名字。后来，作者发现珍珠（pearl）是六月的诞生石（birthstone，这个我不懂），ruby是七月的诞生石，所以作者相信ruby是perl之后自己语言的一个好的名字。

归纳以来，Ruby有以下优点：
◆解释器
　Ruby是解释型语言，其程序无需编译即可轻松执行。
◆变量无类型
　Ruby的变量没有类型，因此不必为静态的类型匹配而烦恼。相应地，错误检查功能也变弱了。
◆不需要变量声明
　所有变量均无需声明即可立即使用。另外，从变量名即可判断出是何种变量（局部变量，全局变量，实例变量）。
◆语法简单
　语法比较简单，类似Algol系语法。
◆不需要内存管理
　具有垃圾回收（Garbage Collect，GC）功能，能自动回收不再使用的对象。
◆一切都是对象
　Ruby从一开始就被设计成纯粹的面向对象语言，因此以整数等基本数据类型为首的所有东西都是对象，它们都有发送信息的统一接口。
◆类，继承，方法
　Ruby当然具有面向对象语言的基本功能。
◆特殊方法
　可向某对象添加方法。例如，可以把GUI按钮被按下时的动作作为方法记述下来，还可以用它来进行原型库（prototypebase）的面向对象编程（有人这么干吧）。
◆用模块进行混合插入（Mixin）
　Ruby故意舍弃了多重继承，但拥有混合插入功能。使用模块来超越类的界限来共享数据和方法等。

◆迭代器
　该功能可以将循环抽象化。
◆闭包
　可以将某过程片段对象化。对象化后的该过程片段就称作闭包。
◆功能强大的字符串操作／正则表达式
　以Perl为样板创造出了功能强大的字符串操作和正则表达式检索功能。
◆拥有超长整数
　添加超长整数功能后，可以计算非常大的整数。例如计算400的阶乘也轻而易举。
◆具有错误处理功能
　错误处理功能可以使您编写代码处理出错情况。
◆可以直接访问OS
　Ruby可以使用（UNIX的）绝大部分的系统调用。单独使用Ruby也可以进行系统编程。
◆动态加载
　若OS支持的话，可以在运行时读入对象文件。

但Ruby也有下列缺点：
◆因为Ruby是解释型语言，所以速度较慢
◆静态检查比较少

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐