ROR——API网站

http://www.gotapi.com/rubyrails

 

http://routes.groovie.org/manual.html#restful-services

实用的Linux日志分析命令

一、cat 日志文件 | grep -A 20 -B 20 "response=\"false\""
说明：显示log里的 含有 response="false" 的行和前面 -A(after) 后面 20行 -B(before) 前面 20行的 记录并且用--分割显示
-------------
二、cat 日志文件 |egrep -o '192.168.[0-9]+.[0-9]+:'|sort|uniq -c
说明：显示所有日志文件里的每个局域网出现的次数
cat log.txt |egrep -o '192.168.[0-9]+.[0-9]+:'|sort|uniq -c|sort -nr
说明：显示所有日志文件里的每个局域网出现的次数 并排序显示

留言版

留言请在这里

对XML 进行 parse 时的Invalid Unicode character (0x0) 分析

XML 在搜索引擎的低端起到了非常重要的作用，可是由于相当多数的网络上的Rss feed或者XML feed都是直接从数据库文件生成的，因此极有可能包含有一些非常字符，而这些字符在XML进行Parse的时候就会带来 Invalid Unicode character (0x0) 这样的错误或者是org.xml.sax.SAXParseException: An invalid XML character (Unicode: 0x0) was found，如何解决这样的错误？

先看看Unicode的一些基础知识：

Unicode 最初设计是作为一种固定宽度的 16 位字符编码。在 Java 编程语言中，基本数据类型 char 初衷是通过提供一种简单的、能够包含任何字符的数据类型来充分利用这种设计的优点。不过，现在看来，16 位编码的所有 65,536 个字符并不能完全表示全世界所有正在使用或曾经使用的字符。于是，Unicode 标准已扩展到包含多达 1,112,064 个字符。那些超出原来的 16 位限制的字符被称作增补字符。Unicode 标准 2.0 版是第一个包含启用增补字符设计的版本，但是，直到 3.1 版才收入第一批增补字符集。由于 J2SE 的 5.0 版必须支持 Unicode 标准 4.0 版，因此它必须支持增补字符。

对增补字符的支持也可能会成为东亚市场的一个普遍商业要求。政府应用程序会需要这些增补字符，以正确表示一些包含罕见中文字符的姓名。出版应用程序可能会需要这些增补字符，以表示所有的古代字符和变体字符。中国政府要求支持 GB18030（一种对整个 Unicode 字符集进行编码的字符编码标准），因此，如果是 Unicode 3.1 版或更新版本，则将包括增补字符。台湾标准 CNS-11643 包含的许多字符在 Unicode 3.1 中列为增补字符。香港政府定义了一种针对粤语的字符集，其中的一些字符是 Unicode 中的增补字符。最后，日本的一些供应商正计划利用增补字符空间中大量的专用空间收入 50,000 多个日文汉字字符变体，以便从其专有系统迁移至基于 Java 平台的解决方案。

因此，Java 平台不仅需要支持增补字符，而且必须使应用程序能够方便地做到这一点。由于增补字符打破了 Java 编程语言的基础设计构想，而且可能要求对编程模型进行根本性的修改，因此，Java Community Process 召集了一个专家组，以期找到一个适当的解决方案。该小组被称为 JSR-204 专家组，使用 Unicode 增补字符支持的 Java 技术规范请求的编号。从技术上来说，该专家组的决定仅适用于 J2SE 平台，但是由于 Java 2 平台企业版 (J2EE) 处于 J2SE 平台的最上层，因此它可以直接受益，我们期望 Java 2 平台袖珍版 (J2ME) 的配置也采用相同的设计方法。

不过，在了解 JSR-204 专家组确定的解决方案之前，我们需要先理解一些术语。

代码点、字符编码方案、UTF-16：这些是指什么？

不幸的是，引入增补字符使字符模型变得更加复杂了。在过去，我们可以简单地说“字符”，在一个基于 Unicode 的环境（例如 Java 平台）中，假定字符有 16 位，而现在我们需要更多的术语。我们会尽量介绍得相对简单一些 — 如需了解所有详细的讨论信息，您可以阅读 Unicode 标准第 2 章或 Unicode 技术报告 17“字符编码模型”。Unicode 专业人士可略过所有介绍直接参阅本部分中的最后定义。

字符是抽象的最小文本单位。它没有固定的形状（可能是一个字形），而且没有值。“A”是一个字符，“€”（德国、法国和许多其他欧洲国家通用货币的标志）也是一个字符。

字符集是字符的集合。例如，汉字字符是中国人最先发明的字符，在中文、日文、韩文和越南文的书写中使用。

编码字符集是一个字符集，它为每一个字符分配一个唯一数字。Unicode 标准的核心是一个编码字符集，字母“A”的编码为 004116 和字符“€”的编码为 20AC16。Unicode 标准始终使用十六进制数字，而且在书写时在前面加上前缀“U+”，所以“A”的编码书写为“U+0041”。

代码点是指可用于编码字符集的数字。编码字符集定义一个有效的代码点范围，但是并不一定将字符分配给所有这些代码点。有效的 Unicode 代码点范围是 U+0000 至 U+10FFFF。Unicode 4.0 将字符分配给一百多万个代码点中的 96,382 代码点。

增补字符是代码点在 U+10000 至 U+10FFFF 范围之间的字符，也就是那些使用原始的 Unicode 的 16 位设计无法表示的字符。从 U+0000 至 U+FFFF 之间的字符集有时候被称为基本多语言面 (BMP)。因此，每一个 Unicode 字符要么属于 BMP，要么属于增补字符。

字符编码方案是从一个或多个编码字符集到一个或多个固定宽度代码单元序列的映射。最常用的代码单元是字节，但是 16 位或 32 位整数也可用于内部处理。UTF-32、UTF-16 和 UTF-8 是 Unicode 标准的编码字符集的字符编码方案。

UTF-32 即将每一个 Unicode 代码点表示为相同值的 32 位整数。很明显，它是内部处理最方便的表达方式，但是，如果作为一般字符串表达方式，则要消耗更多的内存。

UTF-16 使用一个或两个未分配的 16 位代码单元的序列对 Unicode 代码点进行编码。值 U+0000 至 U+FFFF 编码为一个相同值的 16 位单元。增补字符编码为两个代码单元，第一个单元来自于高代理范围（U+D800 至 U+DBFF），第二个单元来自于低代理范围（U+DC00 至 U+DFFF）。这在概念上可能看起来类似于多字节编码，但是其中有一个重要区别：值 U+D800 至 U+DFFF 保留用于 UTF-16；没有这些值分配字符作为代码点。这意味着，对于一个字符串中的每个单独的代码单元，软件可以识别是否该代码单元表示某个单单元字符，或者是否该代码单元是某个双单元字符的第一个或第二单元。这相当于某些传统的多字节字符编码来说是一个显著的改进，在传统的多字节字符编码中，字节值 0x41 既可能表示字母“A”，也可能是一个双字节字符的第二个字节。

UTF-8 使用一至四个字节的序列对编码 Unicode 代码点进行编码。U+0000 至 U+007F 使用一个字节编码，U+0080 至 U+07FF 使用两个字节，U+0800 至 U+FFFF 使用三个字节，而 U+10000 至 U+10FFFF 使用四个字节。UTF-8 设计原理为：字节值 0x00 至 0x7F 始终表示代码点 U+0000 至 U+007F（Basic Latin 字符子集，它对应 ASCII 字符集）。这些字节值永远不会表示其他代码点，这一特性使 UTF-8 可以很方便地在软件中将特殊的含义赋予某些 ASCII 字符。


经修订的 UTF-8

Java 平台对经修订的 UTF-8 已经很熟悉，但是，问题是应用程序开发人员在可能包含增补字符的文本和 UTF-8 之间进行转换时需要更加留神。需要特别注意的是，某些 J2SE 接口使用的编码与 UTF-8 相似但与其并不兼容。以前，此编码有时被称为“Java modified UTF-8”（经 Java 修订的 UTF-8）或（错误地）直接称为“UTF-8”。对于 J2SE 5.0，其说明文档正在更新，此编码将统称为“modified UTF-8”（经修订的 UTF-8）。

经修订的 UTF-8 和标准 UTF-8 之间之所以不兼容，其原因有两点。其一，经修订的 UTF-8 将字符 U+0000 表示为双字节序列 0xC0 0x80，而标准 UTF-8 使用单字节值 0x0。其二，经修订的 UTF-8 通过对其 UTF-16 表示法的两个代理代码单元单独进行编码表示增补字符 。每个代理代码单元由三个字节来表示，共有六个字节。而标准 UTF-8 使用单个四字节序列表示整个字符。

Java 虚拟机及其附带的接口（如 Java 本机接口、多种工具接口或 Java 类文件）在 java.io.DataInput 和 DataOutput 接口和类中使用经修订的 UTF-8 实现或使用这些接口和类 ，并进行序列化。Java 本机接口提供与经修订的 UTF-8 之间进行转换的例程。而标准 UTF-8 由 String 类、java.io.InputStreamReader 和 OutputStreamWriter 类、java.nio.charset 设施 (facility) 以及许多其上层的 API 提供支持。

由于经修订的 UTF-8 与标准的 UTF-8 不兼容，因此切勿同时使用这两种版本的编码。经修订的 UTF-8 只能与上述的 Java 接口配合使用。在任何其他情况下，尤其对于可能来自非基于 Java 平台的软件的或可能通过其编译的数据流，必须使用标准的 UTF-8。需要使用标准的 UTF-8 时，则不能使用 Java 本机接口例程与经修订的 UTF-8 进行转换。

因此通常来说，0x00-0x20 都会引起一定的问题，又因为这些字符不可见，因此用通常的编辑器进行编辑的时候找不到问题所在。
上面的文档转自：http://okone96.itpub.net/post/9033/290859

解决方案是：
把这些非法字符去掉就OK了
下面是用java分析xml时处理的例子：

import java.io.StringReader;

import org.jdom.Document;
import org.jdom.input.SAXBuilder;

public class CheckUnicode {
    /**
     * 为了能够正常读取xml文件,把非法字符过滤掉
     *
     * @param value
     * @return
     */
    public static StringBuilder CheckUnicodeString(StringBuilder value) {
        if (hasLuanMa(value)) {
            return CheckUnicodeString2(value);
        } else {
            return value;
        }
    }

    private static boolean hasLuanMa(StringBuilder value) {
        boolean hasLuanMa = false;
        if (null != value && value.length() > 0) {
            for (int i = 0; i < value.length(); ++i) {

                if (value.charAt(i) > 0xFFFD
                        || (value.charAt(i) < 0x20 && value.charAt(i) != '\t'
                                && value.charAt(i) != '\n' && value.charAt(i) != '\r')) {
                    hasLuanMa = true;
                    break;
                }
            }
            return hasLuanMa;
        } else {
            return false;
        }
    }

    private static StringBuilder CheckUnicodeString2(StringBuilder value) {
        StringBuilder sb = new StringBuilder();
        if (null != value && value.length() > 0) {
            for (int i = 0; i < value.length(); ++i) {
                if (value.charAt(i) > 0xFFFD
                        || (value.charAt(i) < 0x20 && value.charAt(i) != '\t'
                                && value.charAt(i) != '\n' && value.charAt(i) != '\r')) {
                    continue;
                } else {
                    sb.append(value.charAt(i));
                }
            }
            return sb;
        } else {
            return sb;
        }
    }

    /**
     * 传进来已经过滤过的xml字符串
     *
     * @param xml
     * @return
     */
    public static boolean loadXmlString(String xml) {
        try {
            SAXBuilder builder = new SAXBuilder();
            Document document = builder.build(new StringReader(xml));
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("从xml文件读具体内容");
        StringBuilder sbEnd = CheckUnicodeString(sb);
        if (loadXmlString(sbEnd.toString())) {
            System.out.println("OK");
        } else
            System.out.println("FAIL");
    }

}

windows 和 linux 系统换行符号研究

有个上海的朋友问了我一个正则匹配空行的问题，虽然当时解决了他的需求但感觉概念没有弄清楚，直到上周五跟同事们研究后才恍然大悟。好了废话少说开门见山直奔主题。

首先要弄清楚windows 和 linux的换行怎么表示，
1. window 系统中一个文件里的每一行都以 《\r\n》结束
2. linux 系统中一个文件里的每一行都以 《\n》结束

以前以为都是用《\n》结束每行，读了JDK LineNumberInputStream#read()的源码后才明白不是这么回事。好、让我们来解决一个实际问题。上海的朋友需求是这样的：读一个文本文件并要求把第一个空行之前的所有的字符串用正则表达式匹配出来。 因当时不是很清楚上面两个语法，所以虽然解决了但是《瞎猫碰死耗子》了 呵呵。
问题的关键是怎么用正则表示空行呢？

window下每行都以《\n\r》结束，所以空行用正则《\n\r》表示
linux 下每行都以《\n》结束，所以空行用正则《\n\n》表示

注意：windows 和 linux下的空行表示是不同的

下面是用JAVA写的一个例子(windows)：

import java.io.File;
import java.io.FileInputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class NTest {

    private StringBuilder content = new StringBuilder();

    /**
     * 空行正则里是\n\r
     * 测试文件内容为
        a
        b
    
        c
        d
    
        e
     */
    private Pattern pattern = Pattern.compile("(.*?)\n\r", Pattern.DOTALL);

    @Before
    public void setUp() throws Exception {
        FileInputStream fis= null;
        try {
            fis = new FileInputStream(new File("c:/test.txt"));
            byte[] b = new byte[1024];
            int len = -1;
            while ((len = fis.read(b)) != -1) {
                content.append(new String(b, 0, len));
            }
        } finally {
            if(null != fis)
                fis.close();
        }
    }

    @After
    public void tearDown() throws Exception {
        content = null;
    }

    @Test
    public void Ntest() {
        Matcher matcher = pattern.matcher(content);
        int g = matcher.groupCount();
        System.out.println("groupCount="+g);
        while(matcher.find()){
            System.out.println("finded it");
            for (int i = 0; i < g ;i++){
               System.out.println(matcher.group(i));
            }
            break;
        }
    }

}
运行结果为：

groupCount=1
finded it
------
a
b