BlogJava-Java杂家

告别mod_jk,转向Apache Java Module(mod_java)

DoubleH — Thu, 19 Jun 2008 07:38:00 GMT

一直以来，整合Apache HTTP Server和其他Java容器时，可能你最好的选择就是mod_jk,但是mod_jk在Apache和外部Java服务器之间使用socket来进行协议转换，性能不能尽如人意。
正如我上一篇博客里说的，mod_java通过在apache嵌入的JVM中直接执行Java来响应HTTP请求，当然是要快于mod_jk的。

但是缺点是，不是Servlet API(虽然实现Servlet API不是很难，但是工作量肯定很大的），优点是，接口很清晰，很灵活，可以做到的事情也就很多。

那么如何开发一个基于mod_java的java handler呢？OK，假设你要在Apache里响应所有/test/*上的请求.
你要做的是：
1）配置Apache启用mod_java

LoadModule java_module modules/mod_java.so

<mod_java your_main_class>
JVMLibrary D:\jdk6\jre\bin\server\jvm.dll
CurDir D:\apache-tomcat-6.0.14
ADDJVMOpt -Djava.class.path=D:\apache-tomcat-6.0.14\bin\bootstrap.jar;D:\dev\vccode\mod_java\mod_java.jar
ADDJVMOpt -Djava.library.path=D:\apache-tomcat-6.0.14\bin
ADDJVMOpt -Dcatalina.home=D:\apache-tomcat-6.0.14
ADDJVMOpt -Duser.dir=D:\apache-tomcat-6.0.14
ADDJVMParam start
ADDJVMStopParam stop
ADDJavaHandler javatest com.yovn.apache.modj.HelloWorld
mod_java>

这里main_class是可选的，如果有，那么JVM启动时自动调用main方法。

2）在配置文件里加入你将要开发的Java Handler
想上面文件中的

ADDJavaHandler javatest com.yovn.apache.modj.HelloWorld

这里 javatest是handler名字，后面是你的实现的class
3）在配置文件里告诉Apache 你的handler名字对应的路径

<Location /test>
SetHandler javatest
Location>

完成这些配置动作后，apache在收到到/test/*的请求后mod_java会call你的handler class的processRequest方法了。

RequestHandler接口如下定义，你的Handler都需要实现该接口：

package com.yovn.apache.modj;

import java.io.IOException;

/**
* @author yovn
*
*/
public  interface RequestHandler {

    public abstract void processRequest(ModJRequest request) throws IOException,
            ModJavaException;

}

正如你看到的很简单的接口，但是ModJRequest就不简单了，该接口代表你跟Apache通行的直接的接口，目前定义如下：

package com.yovn.apache.modj;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;

/**
* @author yovn
*
*/
public interface ModJRequest {

    /**
     *
     * @param name
     * @return the request header value of that name
     */
    String getRequestHeader(String name);

    /**
     *
     * @return similar as HttpServletRequest.getRequestURI()
     */
    String getRequestURI();
    /**
     *
     * @param name header name
     * @param value header value
     */
    void setResponseHeader(String name,String value);

    /**
     *
     * @param type 'text/html' etc..
     */
    void setContentType(String type);

    /**
     *
     * @param code response code
     */
    void setResponseCode(int code);

    /**
     *
     * @return HTTP method
     */
    String getMethod();


    /**
     * Give you the  chance when you need push datas to client
     * Also,you can use it to close a connection
     * Note:
     * HTTP Server may close the connection when it timeout automatically.
     * When you pass use an invalid connection id to call some function , it will failed.
     * @see com.yovn.apache.modj.ApacheModule#flushConnection(long, byte[], int, int)
     * @see com.yovn.apache.modj.ApacheModule#closeConnection(long)
     * @return the connection id for this request.
     */
    long getConnectionId();

    /**
     * same as HttpServletRequest.getServletInputStream
     * @return
     */
    InputStream getRequestInputStream();

    /**
     * same as HttpServletResponse.getServletOutputStream
     * @return
     */
    OutputStream getResponseOutputStream();


    /**
     * You should not call the {@link #getRequestInputStream()} before you call this method this method.
     * In other words, You should either use this method or {@link #getRequestInputStream()}  to do read data from clients
     * @return the direct byte buffer from native side
     * @throws IOException
     */
    ByteBuffer readTotalRequestBody()throws IOException;


    /**
     * Use apache's apr_send_fd to send a file.
     * Before send file, you may need setup proper HTTP headers, such as 'Content-Disposition'
     * @param fileName
     * @return
     * @throws IOException
     */
    boolean sendFile(String fileName)throws IOException;

}

如你所看，基本可以做任何事情（如果还有你想要而没有请一定要告诉我哦）！

下面给个发送文件的例子：

/**
*
*/
package com.yovn.apache.modj;

import java.io.File;
import java.io.IOException;

/**
* @author yovn
*
*/
public class HelloWorld implements RequestHandler {

    /**
     *
     */
    public HelloWorld() {
        // TODO Auto-generated constructor stub
    }

    /*
     * (non-Javadoc)
     *
     * @see com.yovn.apache.modj.RequestHandler#processRequest(ModJRequest request)
     */

    public void processRequest(ModJRequest request) throws IOException,
            ModJavaException {

        request.setContentType("APPLICATION/OCTET-STREAM");


        File f=new File("D:\\cspace\\mod_java\\release\\ddd.bin");
        request.setResponseHeader("Content-Disposition", "attachment;filename=\"ddd.bin\"");
        request.setResponseHeader("Content-Length",f.length()+"");

        request.sendFile(f.getCanonicalPath());


    }

}

下载：
mod_java_0.1

DoubleH 2008-06-19 15:38 发表评论

Introduction To Apache Java Module

DoubleH — Tue, 17 Jun 2008 16:05:00 GMT

一。Apache Java Module是什么？

Apache Java Module是一个Apache2.2 Server下的一个模块，这个模块可以嵌入一个JVM，可以无缝地跟Apache整合在一块，从而便于发布高性能的基于Java的HTTP解决方案。

二。为什么要这么做
1）首先，Apache是HTTP服务器市场的领头羊
2）处于性能的考量。
3）Servlet API有它本身的局限性，例如连接相关的信息基本是被隐藏起来了，这样当你想要异步推数据给客户端时，只能去求助Comet了。
4）只要愿意，我可以同时跑Apache和Tomcat,并在一个进程内同时为两个端口服务。
三。示例

目前初步实现了基本框架，一个Hellow,world的例子见下：
首先配置Apache,在conf文件里加上：

LoadModule java_module modules/mod_java.so

JVMLibrary D:\jdk1.6\jre\bin\server\jvm.dll
CurDir D:\apache-tomcat-6.0.10
ADDJVMOpt -Djava.class.path=D:\apache-tomcat-6.0.10\bin\bootstrap.jar;D:\cspace\mod_java\mod_java.jar
ADDJVMOpt -Djava.library.path=D:\apache-tomcat-6.0.10\bin
ADDJVMOpt -Dcatalina.home=D:\apache-tomcat-6.0.10
ADDJVMOpt -Duser.dir=D:\apache-tomcat-6.0.10
ADDJVMParam start
ADDJVMStopParam stop
ADDJavaHandler javatest com.yovn.apache.modj.HelloWorld

SetHandler javatest

这段配置脚本，同时会启动一个Tomcat在一个新的线程。
并且，当你请求/javatest/*时，自动会执行com.yovn.apache.modj.HelloWorld来满足这个请求，下面看
这个示例程序：

/**
*
*/
package com.yovn.apache.modj;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;

/**
* @author yovn
*
*/
public class HelloWorld implements RequestHandler {

    /**
     *
     */
    public HelloWorld() {
        // TODO Auto-generated constructor stub
    }

    /* (non-Javadoc)
     * @see com.yovn.apache.modj.RequestHandler#processRequest(java.lang.String, int, long, long, java.io.InputStream, java.io.OutputStream)
     */
    @Override
    public void processRequest(String url, int method, long req, long conn,
            InputStream in, OutputStream out) throws IOException,
            ModJavaException {


        //ApacheModule.setHeader(req, "X-Server", "mod_java");
        out.write("Hello,World

Hello,World

".getBytes());
        out.close();



    }

}

这是个很简单的程序，当你在浏览器输入http://host:apache_port/javatest/时，显示Hello,World.

目前读取输入数据尚未实现，等完善了我再提供下载文件。

DoubleH 2008-06-18 00:05 发表评论

2008百度之星资格赛第二场第三题——传输方案规划

DoubleH — Sun, 01 Jun 2008 10:53:00 GMT

问题背景
面对艰巨复杂的技术挑战，百度所崇尚的系统设计哲学是“简单可依赖”，而百度的工程师们正在互联网世界中实践着这种理念。这里正好有一个挑战，让作为百度之星的你小试牛刀：

在处理数以百亿计的网络信息的过程中，有一个很常见的问题：
怎么样将一个集群上的信息以最低的成本传输到另外一个集群上？

数据源集群A有n台服务器，编号为 1, 2, ..., n，i号服务器上待传输的数据量为Ai ，单位是GB。
目的地集群B有m台服务器，编号为 1, 2, ..., m，j号服务器上的空闲容量为 Bj，单位为 GB。
A集群的i号服务器上的每GB数据对于B的集群的j号服务器收益为Vi,j，从 A 集群的 i 号服务器向 B 集群的 j 号服务器传输 1GB数据的开销为Ci,j。
你的任务是在保证A中的所有数据传输完毕的前提下，性价比V/C尽量高。其中V为所有数据在B集群上的价值之和，C为总开销。换句话说，若A集群的i号服务器向B集群的j号服务器发送了Ti,j个GB的数据（Ti,j不一定是整数），则性价比定义为：

输入格式
第1行两个整数n, m(1<=n,m<=50)，即集群A和B各自的服务器台数。
第2行包含n个不超过100的正整数A1,A2,…,An，即集群A中每台服务器的待传输数据量（单位：GB）。
第3行包含m个不超过100的正整数B1,B2,…,Bm，即集群B中每台服务器所能接受的最大数据量（单位：GB）。
第 4 ~ n+3 行每行包含m个不超过100的非负整数Vi,j，表示集群A的i号服务器中每GB数据对于集群B中的j号服务器的价值。
第 n+4 ~ 2n+3 行每行包含m个不超过100的正整数Ci,j，表示集群A的i号服务器中每GB数据传输到集群B中的j号服务器所需要的开销。

输出格式
仅一行，为最大性价比。输出保留三位小数（四舍五入）。如果A的数据无法传输完毕，输出字符串 “-1”（无引号）。

样例输入
2 2
1 2
2 1
11 0
7 5
6 1
3 2

样例输出
2.091

样例解释
一个方案是：
集群A的1号服务器把所有数据传输到集群B的1号服务器，价值11，开销6。
集群A的2号服务器把1GB数据传输到集群B的1号服务器，价值7，开销3，然后把剩下的1GB数据传输到集群B的2号服务器，价值5，开销2。
性价比：(11+7+5)/(6+3+2)=2.091

另一个方案是：
集群A的1号服务器把所有数据传输到集群B的2号服务器，价值0，开销1。
集群A的2号服务器把所有数据传输到集群B的1号服务器，价值14，开销6。
性价比：(0+14)/(1+6)=2。

第一种方案更优

我的解答：
该题应该是贪心法可解，每次求性价比最高的，跟部分背包问题很像。
可惜不是，子问题不是独立的，我的解法肯定不是最优解。sign~~~，据说是最大流的问题，改天研究研究。
我的解法用了N+1个最大值堆，一个是全局所有为传输完的源站点的最高性价比方案，
其余每个源站点一个最大值堆含该站点所有传输方案。

//============================================================================
// Name        : TransportOpt.cpp
// Author      : Yovn
// Version     :
// Copyright   : yovnchine@gmail.com
//============================================================================

#include
#include
#include
#include

using namespace std;

int numA;
int numB;
int* valuesA;
int* valuesB;
int** values=NULL;
int** costs=NULL;

typedef struct _HeapNode
{
    int a;
    int b;
    float vPerC;

}HeapNode;
class MaxHeap
{
public:
    MaxHeap(int n):nodes(new HeapNode[n]),total(n),len(0){

    }
    MaxHeap():nodes(NULL),total(0),len(0){

    }
    ~MaxHeap()
    {
        delete[] nodes;
    }
    bool isEmpty()
    {
        return len<=0;
    }
    void setSize(int n)
    {
        nodes=new HeapNode[n];
        total=n;
        len=0;
    }
    HeapNode removeMax()
    {

        HeapNode ret=nodes[0];
        nodes[0]=nodes[--len];
        shift_down(0);
        return ret;
    }
    void insert(HeapNode val)
    {

        nodes[len++]=val;
        shift_up(len-1);
    }

private :


    void shift_up(int pos) {

        HeapNode tmp=nodes[pos];
        int index=(pos-1)/2;

        while (index>=0) {
            if (tmp.vPerC>nodes[index].vPerC) {
                nodes[pos]=nodes[index];
                pos=index;
                if (pos==0)
                    break;
                index=(pos-1)/2;
            } else
                break;
        }
        nodes[pos]=tmp;
    }
    void shift_down(int pos) {

        HeapNode tmp=nodes[pos];
        int index=pos*2+1;//use left child
        while (index         {
            if (index+1nodes[index].vPerC)//right child is smaller
            {
                index+=1;//switch to right child
            }
            if (tmp.vPerC                 nodes[pos]=nodes[index];
                pos=index;
                index=pos*2+1;

            } else {
                break;
            }

        }
        nodes[pos]=tmp;

    }
    HeapNode* nodes;
    int total;
    int len;


};

void parseToInts(string& line, int* arr, int num) {
    int pos=0;
    for (int i=0; i         if (line[i]>='0'&&line[i]<='9') {
            if (line[i+1]>='0'&&line[i+1]<='9') {
                int a=(line[i]-'0')*10+(line[i+1]-'0');
                arr[pos++]=a;
                i++;
            } else {
                int a=(line[i]-'0');
                arr[pos++]=a;

            }

        }
    }
}
void input()
{
    string line;
    getline(cin,line);

    sscanf(line.c_str(),"%d %d",&numA,&numB);
    valuesA=new int[numA];
    valuesB=new int[numB];
    line.clear();
    getline(cin,line);
    parseToInts(line,valuesA,numA);

    line.clear();
    getline(cin,line);
    parseToInts(line,valuesB,numB);


    values=new int*[numA];
    costs=new int*[numA];
    for (int i=0; i         values[i]=new int[numB];
        line.clear();
        getline(cin, line);
        parseToInts(line, values[i], numB);
    }

    for (int i=0; i         costs[i]=new int[numB];
        line.clear();
        getline(cin, line);
        parseToInts(line, costs[i], numB);
    }



}
bool validate() {
    int sumA=0, sumB=0;
    for (int i=0; i         sumA+=valuesA[i];
    }
    for (int i=0; i         sumB+=valuesB[i];
    }
    return sumA<=sumB;
}
void calc() {
    MaxHeap totalHeap(numA);
    MaxHeap* aHeaps=new MaxHeap[numA];
    int totalC=0;
    int totalV=0;

    if(!validate())
    {
        printf("-1\n");
        return;
    }
    for (int i=0; i
        aHeaps[i].setSize(numB);
        for(int j=0;j         {
            HeapNode node;
            node.a=i;
            node.b=j;
            node.vPerC=(float)values[i][j]/(float)costs[i][j];
            aHeaps[i].insert(node);
        }
        totalHeap.insert(aHeaps[i].removeMax());
    }
    while(!totalHeap.isEmpty())
    {
        HeapNode node=totalHeap.removeMax();

        if(valuesA[node.a]==valuesB[node.b])
        {
            totalV+=values[node.a][node.b]*valuesA[node.a];
            totalC+=costs[node.a][node.b]*valuesA[node.a];
            valuesB[node.b]=0;
            valuesA[node.a]=0;

        }
        else if(valuesA[node.a]>valuesB[node.b])
        {
            totalV+=values[node.a][node.b]*valuesB[node.b];
            totalC+=costs[node.a][node.b]*valuesB[node.b];
            valuesA[node.a]-=valuesB[node.b];
            valuesB[node.b]=0;

        }
        else
        {
            totalV+=values[node.a][node.b]*valuesA[node.a];
            totalC+=costs[node.a][node.b]*valuesA[node.a];
            valuesB[node.b]-=valuesA[node.a];

            valuesA[node.a]=0;

        }
        while(!aHeaps[node.a].isEmpty())
        {
            HeapNode todo=aHeaps[node.a].removeMax();
            if(valuesA[todo.a]>0&&valuesB[todo.b]>0)
            {
                totalHeap.insert(todo);
                break;
            }
        }
    }
    printf("%lf\n",(float)totalV/totalC);
}
int main() {

    input();
    calc();

    return 0;
}

DoubleH 2008-06-01 18:53 发表评论

2008百度之星资格赛第二题——网页判重

DoubleH — Sat, 31 May 2008 15:20:00 GMT

问题背景

有一种简单的网页判重的方法，通过求两个网页内容的最长公共子序列(LCS)长度来判定两个网页的相似程度。如：
（网页A）老师：请用“果然”造句。
（网页B）学生：先吃水果，然后喝汽水……
它们的最长公共子序列为“果然”，长度为2。注意这里的“子序列”并不要求连续。

类似的，下面两个网页：
（网页A）老师：请用“果然”造句。
（网页B）学生：先吃水果，然后喝汽水，果然拉肚子……

最长公共子序列还是“果然”，长度为2。但不难看出，由于“果然”两个字在网页B中也曾连续出现，第二组网页比第一组更加“相似”。为了区分开这两种情况的区分度，我们改用一种称为LZW的理论。为了严格的叙述相似度的计算方法，我们首先定义“文本单元”。

假定网页用一个不包含空白字符（空格、回车换行、水平制表符）的字符串来表示。它只包含纯文本，没有标签。在计算相似度之前，你应该首先对该字符串进行处理，划分成一个个“文本单元”。每个文本单位可以是一个中文字、英文单词（由一个或多个连续的半角英文字母和数字组成，正规表达式为[a-zA-Z0- 9]+）、或者一个标点符号。

根据上述定义，同一个标点符号的全角和半角应该被作为不同的文本单元，尽管他们看起来可能很相近；每个单独全角英文和全角数字都应该被看成一个单独的文本单元，而连续的半角英文字母和数字应被看成一个整体。总之，全角的字符可以与中文字同等对待。

这样，网页被看成文本单元序列。例如，网页“内容？１２345６??web2.00#”切分出的文本单元序列为（为了显示方便，用下划线分隔各文本单元）：
内_容_？_１_２_345_６_?_?_web2_._00_#

而网页“why内容相似??1234567890,web#00”的切分结果为：
why_内_容_相_似_?_?_1234567890_,_web_#_00

黑体部分给出了两个网页的一个公共子序列。注意“内容”、“??”分别在两个网页中都是连续出现的文本单元。为了奖励这种情况，LZW规定一段由连续k个文本单元组成的字符串权值为k^2。在刚才的例子中，“内容”、“??”的权值均为4。但“00”是一个数字串，应当被看成一个单独的文本单元。所以权值仅为1。

根据上述规则，公共子序列“内容 ?? 00”的权值为2^2+2^2+1=9。在所有可能的子序列中，这个权值是最大的。

给定两个网页，求他们的LZW相似度，即所有可能的公共子序列中的最大权值。

注意

1) 输入的网页内容以GBK编码(参见FAQ)
2) 除了大小写英文字母和数字之外的其他半角字符均视为标点符号。
输入格式

包含两行，分别是网页A和B对应的字符串（不包含空白字符）。每行至少包含5个字节，最多包含200个字节。
输出格式

输出仅一行，包含一个整数，为两个网页的LZW相似度。
样例输入

内容？１２345６??web2.00#
why内容相似??1234567890,web#00
样例输出
9

解答：
该题主要分两部分，一部分就是解析成文本单元，另一部分就是LZW的实现，LZW其实是最长公共子序列算法的一个变形。

//============================================================================
// Name        : LZW.cpp
// Author      : Yovn
// Version     :
// Copyright   : yovnchine@gmail.com
//============================================================================

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

void parseToLZWLine(const char* in, int inLen, char**& out, int& actualLen) {
    int mark=0;
    actualLen=0;
    out=new char*[inLen];

    for (int i=0; i<inLen; i++) {
        char ch=in[i];
        if (ch<0) {
            if (mark<i) {
                out[actualLen]=new char[i-mark+1];
                strncpy(out[actualLen], in+mark, i-mark);
                out[actualLen][i-mark]='\0';
                actualLen++;
            }
            out[actualLen]=new char[3];
            out[actualLen][0]=ch;
            out[actualLen][1]=in[++i];
            out[actualLen][2]='\0';
            actualLen++;

            mark=i+1;
        } else if ((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9')) {
            continue;
        } else//only one case left
        {
            if (mark<i) {
                out[actualLen]=new char[i-mark+1];
                strncpy(out[actualLen], in+mark, i-mark);
                out[actualLen][i-mark]='\0';
                actualLen++;

            }
            out[actualLen]=new char[2];
            out[actualLen][0]=ch;
            out[actualLen][1]='\0';
            actualLen++;
            mark=i+1;
        }
    }
    if (mark<inLen) {
        out[actualLen]=new char[inLen-mark+1];
        strncpy(out[actualLen], in+mark, inLen-mark);
        out[actualLen][inLen-mark]='\0';
        actualLen++;

    }
}
void printLZWStr(char** lzwStr, int lzwLen) {
    for (int i=0; i<lzwLen; i++) {
        printf("%s", lzwStr[i]);
        if (i<lzwLen-1) {
            printf("_");
        }
    }
    printf("\n");
}
void freeLZWStr(char** lzwStr, int lzwLen) {
    for (int i=0; i<lzwLen; i++) {
        delete[] lzwStr[i];
    }
    delete[] lzwStr;
}

int calcLZW(char** left, int leftLen, char** right, int rightLen) {
    //printLZWStr(left, leftLen);
    //printLZWStr(right, rightLen);
    int** result=new int*[leftLen+1];
    int** len=new int*[leftLen+1];
    for (int i=0; i<=leftLen; i++) {
        result[i]=new int[rightLen+1];
        len[i]=new int[rightLen+1];
        result[i][0]=0;
        len[i][0]=0;
    }
    memset(result[0], 0, sizeof(int)*(rightLen+1));
    memset(len[0], 0, sizeof(int)*(rightLen+1));
    for (int i=1; i<=leftLen; i++) {
        for (int j=1; j<=rightLen; j++) {
            if (strcmp(left[i-1], right[j-1])==0) {
                //back trace one

                len[i][j]=len[i-1][j-1]+1;
                result[i][j]=result[i-1][j-1]-(len[i-1][j-1]*len[i-1][j-1])
                        +(len[i][j]*len[i][j]);

            } else if (result[i-1][j]>=result[i][j-1]) {
                result[i][j]=result[i-1][j];
            } else {
                result[i][j]=result[i][j-1];
            }

        }
    }

    int ret= result[leftLen][rightLen];
    for (int i=0; i<=leftLen; i++) {
        delete[] result[i];
        delete[] len[i];

    }
    delete[] result;
    delete[] len;
    return ret;

}

int main() {
    char** lzwStr1=NULL;
    char** lzwStr2=NULL;
    string str1;
    string str2;
    int lzwLen1=0;
    int lzwLen2=0;
    getline(cin,str1);
    getline(cin,str2);

    parseToLZWLine(str1.c_str(), strlen(str1.c_str()), lzwStr1, lzwLen1);
    parseToLZWLine(str2.c_str(), strlen(str2.c_str()), lzwStr2, lzwLen2);

    cout<<calcLZW(lzwStr1, lzwLen1, lzwStr2, lzwLen2)<<endl;

    freeLZWStr(lzwStr1, lzwLen1);
    freeLZWStr(lzwStr2, lzwLen2);

    return 0;
}

DoubleH 2008-05-31 23:20 发表评论

Jetty中异步发送文件

DoubleH — Fri, 28 Mar 2008 17:54:00 GMT

如果Web服务器需要频繁传送文件给客户端时，大多数web容器会提供异步发送的支持，像IIS中的通过ServerSupportFunction(),Apache里面apr_sendfile(),Tomcat6.X通过设置Servlet Request的请求属性等等。。。都可以做到异步发送文件，从而提高服务器性能。

Jetty6.X默认也不提供相关支持，本文提供一种hack方法，仅供参考：

先看测试Servlet:

package com.yovn.labs.testweb;

import java.io.File;
import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.yovn.labs.sendfile.JettySendFile;
import com.yovn.labs.sendfile.NormalSendFile;
import com.yovn.labs.sendfile.SendFile;

/**
* @author yovn
*
*/
public class SendFileServlet extends HttpServlet {

    protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {


        try {

            File f=new File("D:\\workspace\\TEST.rar");//about 45M
            String action=req.getParameter("action");
            SendFile sf=null;
            if("1".equals(action))
            {
                sf=new JettySendFile();
            }
            else
            {
                sf=new NormalSendFile();
            }
            long start=System.currentTimeMillis();
            sf.doSend(req, res, f, null);
            System.out.println(" service ok, action="+action+",use:"+(System.currentTimeMillis()-start)+"!!!");
        } catch (Exception e) {
            throw new ServletException(e);
        }

    }



}

代码很简单明了，action=1时使用Jetty的异步发送，action=2时使用正常方式。

下面是通过firefox直输入地址回车后，下载文件，后台的程序运行结果：

service ok, action=1,use:62!!!
service ok, action=2,use:10688!!!
service ok, action=2,use:9063!!!
service ok, action=1,use:47!!!

当运行1时，实际上客户端还没有下完文件，但是该段代码已经执行完了，IO的操作是异步的。
当运行2时，客户端下完代码才执行完。

以下是Jetty异步发送的代码：

package com.yovn.labs.sendfile;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mortbay.io.EndPoint;
import org.mortbay.io.nio.NIOBuffer;

/**
* @author yovn
*
*/
public class JettySendFile implements SendFile {

    static Field endpointField=null;
    static Class reqCls=null;
    static
    {
        try {
            reqCls=Class.forName("org.mortbay.jetty.Request");
            endpointField=reqCls.getDeclaredField("_endp");
            endpointField.setAccessible(true);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }




    public void doSend(HttpServletRequest req, HttpServletResponse res,File todo,String headerOpt)
            throws IOException {

        if(endpointField==null)throw new IOException("Jetty Not Available!!");
        if(!req.getClass().equals(reqCls))
        {
            throw new IOException("Not in Jetty Context!!");
        }
        EndPoint ep;
        try {
            ep = (EndPoint)endpointField.get(req);

            if(headerOpt==null)
            {
                headerOpt="HTTP/1.1 200 OK \r\nContent-Type: APPLICATION/OCTET-STREAM\r\n"+
                      "Content-Disposition: attachment;filename=\""+todo.getName()+"\"\r\n"+
                      "Content-Length: "+todo.length()+"\r\n\r\n";
            }
            byte[] headerBytes=headerOpt.getBytes("UTF-8");
            NIOBuffer header=new NIOBuffer(headerBytes.length,false);
            header.put(headerBytes);

            NIOBuffer buffer=new NIOBuffer(todo);

            ep.flush(header, buffer, null);
        } catch (IllegalArgumentException e) {
            throw new IOException(e);
        } catch (IllegalAccessException e) {
            throw new IOException(e);
        }



    }

}

正常发送文件的代码：

package com.yovn.labs.sendfile;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* @author yovn
*
*/
public class NormalSendFile implements SendFile {

    /* (non-Javadoc)
     * We simply ignore the 'headerOpt'
     * @see com.yovn.labs.sendfile.SendFile#doSend(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.io.File, java.lang.String)
     */
    public void doSend(HttpServletRequest req, HttpServletResponse res,
            File todo, String headerOpt) throws IOException {
        res.setHeader("Content-Type", "APPLICATION/OCTET-STREAM");
        res.setHeader("Content-Disposition", "attachment;filename=\""+todo.getName()+"\"");
        res.setHeader("Content-Length", todo.length()+"");
        res.setStatus(HttpServletResponse.SC_OK);
        OutputStream out=res.getOutputStream();
        InputStream in=new FileInputStream(todo);

        byte[] buffer=new byte[8192];

        int read=0;
        while((read=in.read(buffer))>0)
        {
            out.write(buffer, 0, read);
        }
        out.flush();
        in.close();



    }

}

DoubleH 2008-03-29 01:54 发表评论

有意思的“电灯泡问题”

DoubleH — Wed, 05 Mar 2008 07:00:00 GMT

过道里依次挂着标号是1，2，3, ......，100的电灯泡，开始它们

都是灭着的。当第一个人走过时，他将标号为 1 的倍数的电灯泡的开关

线拉了一下；当第二个人走过时，他将标号为 2 的倍数的电灯泡的开关

线拉了一下；当第三个人走过时，他将标号为 3 的倍数的电灯泡的开关

线拉了一下；......  如此进行下去，当第一百个人走过时，他将标号为

100 的倍数的电灯泡的开关线拉了一下。

问：当第一百个人走过后，过道里亮着的电灯泡标号是多少？





我的思路：

设标号为K的灯泡被拉了L(K)次，那么当L(K)为奇数的时候，灯泡是亮的。

那么那些标号被拉了奇数次呢？

K=1时，很显然是只拉了1次，最后是亮的。

其次K>=2时，据题意，K号灯第1次，和第K次肯定是拉下了，其余的只会被第K的因子次拉，

据因式分解定理，数K分解为

K=p1^(n1)*p2^(n2)*.....pi^(ni)

其中p1,p2,...pi为素数。

那么，K有那些因子呢？

其实可以考虑任一个因子，他可能是从n1个p1中选若干个（0个到n1个)，从n2个p2中选若干个。。。。。（当全是0个的时候，这个特殊的因子是1）

这样，根据乘法原理，总共有L(K)=(n1+1)*(n2+1)*(n3+1).....

比如，12=2^2*3

一种有3*2=6个因子，他们是1,2,3,4,6,12.



现在考虑要使L(K)为奇数，那么n1,n2,n3不能有一个是奇数，或则，有一个ni+1为偶数，而偶数与任何数相乘仍为偶数。

从而，n1,n2,n3都为偶数,都能被2除。

因为n1,n2,n3都为偶数，显然该数必须是个平方数，可写成K=(X)^2.

从而，1，4，9，16，25，36，49，64，81，100最后是亮的。

DoubleH 2008-03-05 15:00 发表评论