财富猪java站 - java随写

nginx+tomcat架构下获取真实IP的办法

zhouhaizhe@126.com(admin) — Sun,14 Feb 2010 13:07:50 +0800

第一步：在nginx.conf中配置反向代理时把真实IP带上，例如：

server {
    listen 80;
    server_name  boyan.com;
    location ~ ^/(WEB-INF)/ {
        deny all;
     }

    location / {
      proxy_pass http://localhost:8888;
      proxy_set_header  X-Real-IP  $remote_addr;
    }
  }

第二步：应用程序中用 String ip = request.getHeader("X-Real-IP");替代String ip = request.getRemoteAddr();即可
转：http://www.blogjava.net/boyanxiu/archive/2010/02/09/312411.html

eclipse插件开发:使用AST生成类

zhouhaizhe@126.com(admin) — Sun,14 Feb 2010 13:06:55 +0800

本代码演示如何通过AST生成一个完整的类, 最终生成的代码比较乱, 编译无法通过,重点在于对AST的使用, 无需考虑最后生成的结果.

以下是最终生成的代码(语法有严重错误, 请不要计较这些):
package com.aptech.lzh;

import java.util.Date;
import java.util.Random;

public class Program {
    public static void main(String[] arg) {
        Program program = new Program();
        String r = program.getString("中国");
        System.out.println(r);
    }

    public Program(int a, int[] b, final Integer c) {
        super(null);
    }

    public String getString(String p) {
        String newString = new String("初始值");
        newString = "你好";
        String result = newString.indexOf("值");
        newString = name + "你好";
        return newString;
    }

    public String isOdd(int a) throws NullPointerException, Exception {
        if (a < 0)
            throw new Exception("数字不能为负数");
        if (a % 2 == 0)
            return "偶数";
        else {
            System.out.println("完");
            return "奇数";
        }
    }
}

源代码:
package ast.test.demo;

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ExpressionStatement;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.NumberLiteral;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
import org.eclipse.jdt.core.dom.ThrowStatement;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.TypeLiteral;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.Assignment.Operator;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;

public class Demo {
    public static void main(String[] args) {
        AST ast = AST.newAST(AST.JLS3);
        CompilationUnit compilationUnit = ast.newCompilationUnit();

        //创建类
        TypeDeclaration programClass = ast.newTypeDeclaration();
        programClass.setName(ast.newSimpleName("Program"));
        programClass.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
        compilationUnit.types().add(programClass);

        //创建包
        PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
        packageDeclaration.setName(ast.newName("com.aptech.lzh"));
        compilationUnit.setPackage(packageDeclaration);

        //要导入的包
        String[] imports = {"java.util.Date", "java.util.Random"};
        for(String imp : imports){
            ImportDeclaration importDeclaration = ast.newImportDeclaration();
            importDeclaration.setName(ast.newName(imp));
            compilationUnit.imports().add(importDeclaration);
        }

        //创建一个main方法
        {
            MethodDeclaration main = ast.newMethodDeclaration();
            main.setName(ast.newSimpleName("main"));
            main.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
            main.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));
            main.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
            programClass.bodyDeclarations().add(main);
            Block mainBlock = ast.newBlock();
            main.setBody(mainBlock);

            //给main方法定义String[]参数
            SingleVariableDeclaration mainParameter = ast.newSingleVariableDeclaration();
            mainParameter.setName(ast.newSimpleName("arg"));
            mainParameter.setType(ast.newArrayType(ast.newSimpleType(ast.newName("String"))));
            main.parameters().add(mainParameter);

            //创建Pragram对象: Program program=new Program();
            VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
            fragment.setName(ast.newSimpleName("program"));
            VariableDeclarationStatement statement = ast.newVariableDeclarationStatement(fragment);
            statement.setType(ast.newSimpleType(ast.newSimpleName("Program")));

            ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation();
            classInstanceCreation.setType(ast.newSimpleType(ast.newSimpleName("Program")));

            fragment.setInitializer(classInstanceCreation);

            mainBlock.statements().add(statement);

            //调用getString方法:String r = program.getString("中国");
            MethodInvocation methodInvocation = ast.newMethodInvocation();
            methodInvocation.setExpression(ast.newSimpleName("program"));
            methodInvocation.setName(ast.newSimpleName("getString"));

            //String参数
            StringLiteral stringLiteral = ast.newStringLiteral();
            stringLiteral.setLiteralValue("中国");
            methodInvocation.arguments().add(stringLiteral);

            //创建变量
            VariableDeclarationFragment fragment2 = ast.newVariableDeclarationFragment();
            fragment2.setName(ast.newSimpleName("r"));
            VariableDeclarationStatement statement3 = ast.newVariableDeclarationStatement(fragment2);
            statement3.setType(ast.newSimpleType(ast.newSimpleName("String")));
            fragment2.setInitializer(methodInvocation);

            mainBlock.statements().add(statement3);


            //输出r的值: System.out.println(r);
            MethodInvocation methodInvocation2 = ast.newMethodInvocation();
            methodInvocation2.setExpression(ast.newName("System.out"));
            methodInvocation2.setName(ast.newSimpleName("println"));
            methodInvocation2.arguments().add(ast.newSimpleName("r"));
            ExpressionStatement statement2 = ast.newExpressionStatement(methodInvocation2);

            mainBlock.statements().add(statement2);
        }

        //构造方法
        {
            MethodDeclaration constructorMethod = ast.newMethodDeclaration();
            constructorMethod.setConstructor(true);
            constructorMethod.setName(ast.newSimpleName("Program"));
            constructorMethod.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
            {
                //基本类型的参数
                SingleVariableDeclaration p1 = ast.newSingleVariableDeclaration();
                p1.setName(ast.newSimpleName("a"));
                p1.setType(ast.newPrimitiveType(PrimitiveType.INT));

                //int[]类型的参数
                SingleVariableDeclaration p2 = ast.newSingleVariableDeclaration();
                p2.setName(ast.newSimpleName("b"));
                p2.setType(ast.newArrayType(ast.newPrimitiveType(PrimitiveType.INT)));

                //引用类型的参数
                SingleVariableDeclaration p3 = ast.newSingleVariableDeclaration();
                p3.setName(ast.newSimpleName("c"));
                p3.setType(ast.newSimpleType(ast.newName("Integer")));
                p3.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD));

                constructorMethod.parameters().add(p1);
                constructorMethod.parameters().add(p2);
                constructorMethod.parameters().add(p3);
            }

            Block constructBlock = ast.newBlock();
            constructorMethod.setBody(constructBlock);

            programClass.bodyDeclarations().add(constructorMethod);

            SuperConstructorInvocation superConstructorInvocation = ast.newSuperConstructorInvocation();
            constructBlock.statements().add(superConstructorInvocation);
            superConstructorInvocation.arguments().add(ast.newNullLiteral());
        }

        /**//*定义一个方法,形如:
        public String getString(String name){
            String newString = name + "你好";
            return newString;
        }
        */

        {
            MethodDeclaration getString = ast.newMethodDeclaration();
            getString.setName(ast.newSimpleName("getString"));
            getString.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
            SingleVariableDeclaration p = ast.newSingleVariableDeclaration();
            p.setName(ast.newSimpleName("p"));
            p.setType(ast.newSimpleType(ast.newName("String")));
            getString.parameters().add(p);
            getString.setReturnType2(ast.newSimpleType(ast.newSimpleName("String")));


            //创建块
            Block block = ast.newBlock();
            getString.setBody(block);
            programClass.bodyDeclarations().add(getString);

            //方法内容----定义String变量
            VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
            fragment.setName(ast.newSimpleName("newString"));
            VariableDeclarationStatement statement = ast.newVariableDeclarationStatement(fragment);

            //String newString = "初始值";
            /**//*StringLiteral stringLiteral2 = ast.newStringLiteral();
            stringLiteral2.setLiteralValue("初始值");
            fragment.setInitializer(stringLiteral2);*/

            ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation();
            classInstanceCreation.setType(ast.newSimpleType(ast.newName("String")));
            SingleVariableDeclaration p1 = ast.newSingleVariableDeclaration();
            StringLiteral stringLiteral3 = ast.newStringLiteral();
            stringLiteral3.setLiteralValue("初始值");
            classInstanceCreation.arguments().add(stringLiteral3);
            fragment.setInitializer(classInstanceCreation);

            statement.setType(ast.newSimpleType(ast.newName("String")));

            Assignment assignment = ast.newAssignment();
            assignment.setLeftHandSide(ast.newSimpleName("newString"));
            StringLiteral stringLiteral = ast.newStringLiteral();
            stringLiteral.setLiteralValue("你好");

            assignment.setRightHandSide(stringLiteral);
            assignment.setOperator(Operator.ASSIGN);
            ExpressionStatement statement2 = ast.newExpressionStatement(assignment);

            block.statements().add(statement);
            block.statements().add(statement2);

            //方法调用
            MethodInvocation methodInvocation = ast.newMethodInvocation();
            methodInvocation.setExpression(ast.newName("newString"));
            methodInvocation.setName(ast.newSimpleName("index")); //方法名
            StringLiteral stringLiteral2 = ast.newStringLiteral();
            stringLiteral2.setLiteralValue("值");
            methodInvocation.arguments().add(stringLiteral2);

            VariableDeclarationFragment fragment2 = ast.newVariableDeclarationFragment();
            fragment2.setInitializer(methodInvocation);
            fragment2.setName(ast.newSimpleName("result"));
            VariableDeclarationStatement statement3 = ast.newVariableDeclarationStatement(fragment2);
            statement3.setType(ast.newSimpleType(ast.newName("String")));

            block.statements().add(statement3);

            StringLiteral stringLiteral4 = ast.newStringLiteral();
            stringLiteral4.setLiteralValue("你好");

            InfixExpression infixExpression = ast.newInfixExpression();
            infixExpression.setLeftOperand(ast.newName("name"));
            infixExpression.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.PLUS);
            infixExpression.setRightOperand(stringLiteral4);

            Assignment assignment2 = ast.newAssignment();
            assignment2.setLeftHandSide(ast.newSimpleName("newString"));
            assignment2.setOperator(Operator.ASSIGN);
            assignment2.setRightHandSide(infixExpression);

            ExpressionStatement statement4 = ast.newExpressionStatement(assignment2);

            block.statements().add(statement4);

            ReturnStatement rs = ast.newReturnStatement();
            rs.setExpression(ast.newName("newString"));
            block.statements().add(rs);
        }

        /** *//**
         * 定义一个方法,形如:
         * public String isOdd(int a) throws NullPointerException, Exception{
         *     if(a < 0) throw new Exception("数字不能为负数");
         *
         *     if(a % 2 == 0){
         *         return "偶数";
         *     }else{
         *         System.out.println("完");
         *         return "奇数";
         *     }
         */
        {
            MethodDeclaration methodDeclaration = ast.newMethodDeclaration();
            methodDeclaration.setName(ast.newSimpleName("isOdd"));
            methodDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
            methodDeclaration.setReturnType2(ast.newSimpleType(ast.newSimpleName("String")));
            //设置参数
            SingleVariableDeclaration singleVariableDeclaration = ast.newSingleVariableDeclaration();
            singleVariableDeclaration.setName(ast.newSimpleName("a"));
            singleVariableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT));
            methodDeclaration.parameters().add(singleVariableDeclaration);

            //抛出异常
            methodDeclaration.thrownExceptions().add(ast.newSimpleName("NullPointerException"));
            methodDeclaration.thrownExceptions().add(ast.newSimpleName("Exception"));

            //创建块{}
            Block isOddBlock = ast.newBlock();
            methodDeclaration.setBody(isOddBlock);

            //创建if与异常
            IfStatement ifStatement = ast.newIfStatement();
            //表达式 a < 0
            InfixExpression infixExpression = ast.newInfixExpression();
            infixExpression.setLeftOperand(ast.newSimpleName("a"));
            infixExpression.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.LESS);

            NumberLiteral numberLiteral = ast.newNumberLiteral("0");
            infixExpression.setRightOperand(numberLiteral);

            ifStatement.setExpression(infixExpression);

            //设置if中的内容
            ThrowStatement throwStatement = ast.newThrowStatement();
            ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation();
            classInstanceCreation.setType(ast.newSimpleType(ast.newSimpleName("Exception")));
            StringLiteral stringLiteral = ast.newStringLiteral();
            stringLiteral.setLiteralValue("数字不能为负数");
            classInstanceCreation.arguments().add(stringLiteral);
            throwStatement.setExpression(classInstanceCreation);
            ifStatement.setThenStatement(throwStatement);

            //if(a % 2 == 0)
            IfStatement ifStatement2 = ast.newIfStatement();
            InfixExpression infixExpression2 = ast.newInfixExpression();
            infixExpression2.setLeftOperand(ast.newSimpleName("a"));
            infixExpression2.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.REMAINDER);
            NumberLiteral numberLiteral2 = ast.newNumberLiteral("2");
            infixExpression2.setRightOperand(numberLiteral2);

            InfixExpression infixExpression3 = ast.newInfixExpression();
            infixExpression3.setLeftOperand(infixExpression2);
            infixExpression3.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.EQUALS);
            NumberLiteral numberLiteral3 = ast.newNumberLiteral("0");
            infixExpression3.setRightOperand(numberLiteral3);

            ifStatement2.setExpression(infixExpression3);

            //return "偶数";
            ReturnStatement returnStatement = ast.newReturnStatement();
            StringLiteral stringLiteral2 = ast.newStringLiteral();
            stringLiteral2.setLiteralValue("偶数");
            returnStatement.setExpression(stringLiteral2);
            ifStatement2.setThenStatement(returnStatement);

            //else
            Block elseBlock = ast.newBlock();
            MethodInvocation methodInvocation = ast.newMethodInvocation();
            methodInvocation.setExpression(ast.newName("System.out"));
            methodInvocation.setName(ast.newSimpleName("println"));
            StringLiteral stringLiteral4 = ast.newStringLiteral();
            stringLiteral4.setLiteralValue("完");
            methodInvocation.arguments().add(stringLiteral4);
            ExpressionStatement statement = ast.newExpressionStatement(methodInvocation);
            elseBlock.statements().add(statement);

            ReturnStatement returnStatement2 = ast.newReturnStatement();
            StringLiteral stringLiteral3 = ast.newStringLiteral();
            stringLiteral3.setLiteralValue("奇数");
            returnStatement2.setExpression(stringLiteral3);
            elseBlock.statements().add(returnStatement2);

            ifStatement2.setElseStatement(elseBlock);

            isOddBlock.statements().add(ifStatement);
            isOddBlock.statements().add(ifStatement2);
            programClass.bodyDeclarations().add(methodDeclaration);
        }

        System.out.println(compilationUnit.toString());

    }
}

求一组序列的全排列

zhouhaizhe@126.com(admin) — Wed,29 Jul 2009 21:23:30 +0800

先来复习一下概率论的基础知识：
n 个数，从中取 m 个进行进行排列，有多少中排法。
如果不同位置可以重复：
第 1 个位置有 n 种选法
第 2 个位置有 n 种选法
......
第 m 个位置有 n 种选法
根据乘法原理：总共 n**m 种排法

如果不能重复
第 1 个位置有 n 种选法
第 2 个位置有 n-1 种选法
......
第 m 个位置有 n-m+1 种选法
根据乘法原理：
总共 n*(n-1)*....*(n-m+1)种排法
全排列就是 n! 种排法

如果我们要编程生成所有的排列，基本上都是嵌套循环

假如 list 有 n 个元素，从中选 2 个进行排列，伪代码基本如下

for i=0 to list.length-1
    for j=0 to list.length-1{
        //找到一种排列方法
        temp=list[i,j]

        //根据情况排除重复
        ..
    }

问题是上面的例子，我们知道选 2 个元素排列，所以循环是 2 层。
但是，如果我们求得是 P(list,n)，n 并不确定，我们不知道循环是几层，要想写一个通用的函数，只能借鉴上面的思想，但是不能使用上面的形式

我的想法是：
1、用一个数组 repeat[] 来保存每层的循环变量：repeat[0] 保存第 0 层循环变量的位置，repeat[1] 保存第 1 层循环变量的位置......repeat[n-1] 保存第 n-1 层循环变量的位置
2、标记当前正在第几层循环：layer
3、集合长度已知：size = list.length
4、临时数组：temp[]，长度为 n
3、算法描述如下：
循环体（layer == 0 且 repeat[0]== size  则退出循环）
{
      如果（前 n-1 层）
      {
            取出该层循环变量：pos=repeat[layer]
            如果 (pos 到达该层末尾，即 pos==size)
            {
                  temp[layer]=null
                  repeat[layer]=0//该层循环变量归零
                  layer--//回到上一层
                  continue
            }
            否则
            {
                  temp[layer]=list[pos]
                  repeat_count[layer]++//该层循环变量增加1
                  layer++//层数增加 1
                  continue
            }
      否则（在最内层）
      {
            不停改变 temp 最后一个元素，每改变一次，就得到一种新的组合，该层循环变量增加1
            当最内层也到达 List 末尾：将该层循环变量归零，回到上层
      }
}

下面是我用 Python 编写的 permutation 函数，接受三个参数
第一个参数：如果数字则返回排列数；如果是集合，则返回排列的集合
第二个参数：选几个数排列，默认全排序
第三个参数：是否允许重复，默认不允许
例子：
print permutation(10),'\n'   #全排列数
print permutation(10,2),'\n' #10 选 2 排列数
print permutation(10,duplicate=True),'\n'  #允许重复的全排列

li=['a','b','c']
print '全排列：',permutation(li),'\n'
print '选2 ：',permutation(li,2),'\n'
print '允许重复：',permutation(li,duplicate=True),'\n'

运行结果：

下面给出源代码：

pdf生成的解决方案

zhouhaizhe@126.com(admin) — Wed,29 Jul 2009 21:22:24 +0800

《根据批量URL生成有书签的pdf文档的解决方案》一文作为一个完整的解决方案，主要有四个要点

（1）详细描述了解决方案的思路，

（2）提出了一种描述URL的xml文件，称之为h2p文件

（3）根据h2p文件生成pdf文档的工具称为h2p-tool，同时h2p-tool还能对h2p文件进行编辑，从而制作自己的pdf电子书。

（4）h2p文件是该解决方案的资源文件，收集url是件费时费力的事情，所以该解决方案还提供了下载h2p文件的链接

H2p是我自己定义的一种xml格式，我私下里是希望这种格式能够被大家接受，所以我定义了dtd，并且开发了一个编辑h2p文件的工具h2p-tool，而且在javaei网站上提供了大量的h2p文件作为资源下载。有了h2p，制作自己的pdf电子书将变得很容易。

如果想让h2p为大家所接受，h2p必须不断的发展。因为现在h2p应用还是很简单很原始。主要表现在，生成的pdf是原html的完全再现，这是他的优点也是他的弱点。

说是优点，是因为pdf的呈现效果和在浏览器里风格一样。

说是缺点，是因为既然生成了pdf，我们希望pdf里主要突出文章的主题内容，而不希望有原来网页里的那么多的图片和广告，而且还希望原来是分页的内容自动合并到一个pdf里。

所以，就此缺点，我提出两个可能的展望。

（1）制定一种规范，该规范要求网站为每篇博客提供一个为h2p专用的链接（姑且叫h2p链接吧），根据这个链接打开的博客文章是没有广告的，那么h2p文件的连接采用这种h2p链接，生成的pdf就没有上述的缺点了。这个想法可能与网站的盈利相悖，因为如果提供h2p链接，很多人将会之点击h2p链接，这样，就避开了网站投放的广告。

（2）第二种可能的展望就是，各网站提供一个webservice的编程接口，通过该编程接口，用程序访问每篇博客文章，这样得到的文章就是没有广告的干净的文章。

这两种展望的目的主要是为了生成干净的pdf文档，显然，要实现这两个展望是很困难的，除非大家都很接受h2p这个思路，并且对这种应用很迫切，才会有人来大力推动。想想rss的普及，那也是一波三折，最终还是因为其便捷的使用模式而被大家所接受。

私下里是希望大家能接受并喜欢h2p的。

事半功倍学习Struts框架的方法

zhouhaizhe@126.com(admin) — Sat,04 Jul 2009 11:38:56 +0800

来源: 51cto

由于Struts框架在全球的广泛使用，学习它的人也非常之多，但是大部分人花费了太多不必要的时间和精力在一些不太重要的地方，导致学习代价高昂，成效也不是很好。我这里根据多年培训经验的总结，精心设计了一套学习Struts框架的曲线，让大伙学习Struts框架既快且准，节省大伙宝贵的时间，一定会对各位学习者大有帮助。

　　大家知道，Struts是Apache基金会Jakarta项目组的一个开源项目，它采用MVC设计模式，是一个基于SunJ2EE平台的WEB表现层框架。这里有几个概念值得大家关注：开源，MVC，J2EE，WEB表现层，框架。我来逐一解释。
　　开源：不用多说，源代码可以让你一行一行仔细分析，深入了解其内部实现机制。
　　MVC：它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。MVC享有“全球第一设计模式”的美誉，是当前很流行的一种设计理念和思想，你要学好Struts，必要要让这种思想深入骨髓。(我在另一篇文章中对MVC进行过阐述，关于MVC的流程及例子请参阅拙作：http://blog.csdn.net/lenotang/archive/2008/06/18/2562348.aspx)
　　J2EE：J2EE是使用Java技术开发企业级应用的一种事实上的工业标准。J2EE将组成一个完整企业级应用的不同部分纳入不同的容器(Container)，每个容器中都包含若干组件(这些组件是需要部署在相应容器中的)，同时各种组件都能使用各种J2EEService/API。其中最常用的容器就是WEB容器（就是我们常说的WEB服务器），里面最核心的两个组件就是JSP和SERVLET。而Struts就是基于这两种技术，依赖于WEB容器。
　　WEB表现层：我们常说的J2EE四层体系架构：WEB表现层，业务逻辑层，持久层，数据库层。这是一种逻辑划分。WEB表现层的特点就是依靠WEB服务器，直接跟客户端（一般是WEB浏览器）打交道。Struts处于WEB表现层，主要就是接受并处理用户请求，并将处理结果响应给用户。
　　框架：通俗地讲，框架就是一个“半成品”，它做了一些通用的东西让你去配置和扩展。框架的强大之处不是说它能让你做什么，而是它不能让你做什么！它使混乱的东西变得结构化。我们来打个比方。框架就像是一间有很多屋梁的房子，当你需要扩建房子的时候，譬如增加新的房间、窗户和过道或者在卧室增加一个壁炉，由于屋梁的限制，你并没有什么其他的选择。虽然较少的屋梁会让你有更多的选择，但是当台风来袭或者发生地震的时候，你让家人住在这样一间只有屋顶的房子里，恐怕不会觉得安全吧。总之，框架是在结构和创造力之间的一个精确的天平。
　　好了。这里假设大家已经理解了上述概念，并会用JSP/SERVLET做一些普通的WEB应用程序。现在就让我们来看看如何学习Struts框架吧。这里我以Struts1.2版本为例。（Struts2.0的实现跟以前的版本有很大不同，我以后会讲到。）让我们出发吧！
　　首先，你要照书本或者网上的例子跑一个最简单的Struts应用，就是在客户端显示一个HELLOWORLD的那种，这叫先睹为快。在这里你开始接触到做Struts应用需要的东西：Struts的JAR包，核心控制器ActionServlet在web.xml上的配置，针对具体用户请求URL的Action的编写以及Struts应用的核心配置文件Struts-config.xml。做完后停下来思考一下。
　　然后，你开始跑一个稍微大点的用户登陆的应用，成功就跳转到我们的主页面，失败就继续回到登陆页面。我们引入ActionForm组件和对后台数据库的操作。这个时候MVC发挥作用了。ActionServlet和自己编写的Action分别充当前，后端控制器组件，DAO/DTO充当了模型组件，JSP充当视图组件。Struts-config.xml也变的饱满起来，上面开始多了些配置datasources，form-beans,action-mappings。做完后到网上找一些好的参考资料或者利用自己经典的Struts的案头书（最好是有图解），开始认真琢磨Struts的运行原理和执行流程，特别要好生体会ActionForm组件的作用和Struts-config.xml这个核心配置文件每一处用到的配置。这个时候，你应该开始有些领悟：我们自己写的Action还有ActionForm类一定要继承框架已有的Action和ActionForm，写完了之后还必须得将它们配置到Struts-config.xml中去。
　　接着，你已经对Struts框架有了大致的了解，可能开始对Struts的其他主题感兴趣了，OK,现在扩充你的登陆应用吧。先加上验证，不然你的系统会不堪一击。验证分为客户端验证和服务器端验证。服务器端的验证我们可以在ActionForm里面的validate()方法里做，也可以在随后的Action类的execute()方法里做，甚至可以使用验证框架。这里大家要把重点方在验证框架的学习上。做好后再加上资源国际化I18N，针对不同区域不同语言的客户提供不同语言版本的页面显示。我们开始写资源属性文件，开始在Struts-config.xml里面配置,开始使用Struts自带的标签,等。这个里面涉及的知识点都很多，需要大家耐心细致地学习。大家在跑这个应用的时候会发现各种各样的异常和问题。不要害怕，这些错误都是我们的好朋友，我们要把它们通通都记录下来，并坚韧地排除掉它们。这里要记住：尽量避免重复犯错，不要在同一个地方跌倒两次。
做完后，认真总结和思考
　　再接着，你把上面的都基本消化了，但是总隐隐觉得不够系统和完整，你就开始做几个CRUD的应用，完成普通的增删查改的工作。在做这些应用的过程中，你要认真总结核心配置文件Struts-config.xml里面的8个重要节点元素的配置以及它们的顺序，每个节点的重要属性，特别是里的子节点的属性是重中之重，一定要好好理解并灵活运用。
你也要开始系统地学习Struts里面的标签。但这个时候千万不要追求大而全，只学习几种常用的标签就可以了，重点放在html,bean,还有logic标签上。这时候还有些小知识点你也许要用到，譬如：文件上传控件，防止信息重复提交，自定义标签，cookie的使用等等。这就是个相对比较耗时间和精力的阶段了，你要做的就是不断地参考，不断地思考，不断地总结，最好还能和志同道合的人不断地争论。
　　慢慢地，你对Struts框架有了一个全局性的宏观把握，用它来完成一些小模块的开发已经没有太大问题，你已经开始志得意满了：Struts不过如此嘛！如果你到了这一步，我首先要恭喜你，你接近成功了。但我也要小心地提醒你：Struts里面还有很多东西值得挖掘！你不妨多问一下自己，软件有一个人开发的吗？页面我使用了良好的布局吗？页面导航都是那么简单吗？我的所有做法就不能有更简单的实现了吗？我对学习Struts框架的好处了如指掌了吗？好的，如果你想通了，带着这些问题，你就会重新披挂上阵，开始学习Struts的多模块开发，开始学习tiles框架，开始认真研读Struts的源代码，开始学习一些更简单有效的Action组件类和ActionForm组件类……，真应了一句古语：吾生也有涯，知也无涯！最后呢，大家可能会悟出一些道理：譬如Struts框架基本的好处就是用配置代替编码，它是一个半成品，是让我们扩展和配置的等等。
　　上面我粗略地勾勒了一下学习Struts的曲线。归纳一下：学习框架需要循序渐进，实例驱动，思考总结。实际上，我在做培训的过程中发现，如果我们在学习Struts之前，自己动手写过一个简易的MVC框架，学习Struts将会非常轻松，大概只需要五天的时间，而且可以学的非常好。大家不要认为框架就是很庞大很复杂的怪兽，自己绝对无法写出来。其实，无非就是将我们所理解的朴素思想用代码实现出来罢了。好了，时间关系，今天就写到这里，祝愿大家学的开心！

星星跟随鼠标

zhouhaizhe@126.com(admin) — Tue,23 Jun 2009 22:21:22 +0800

这段程序放在与之间

style="position:absolute;visibility:hidden;clip:rect(0 150 50 0);width:150px;background-color:lightyellow">

style="position:absolute; left:10px; top:50px; width:3px; height:3px; z-index:1; background-color: #19636c; layer-background-color: #19636c; border: 1px none #000000; clip: rect(0 3 3 0)">

      id="yyd1"
style="position:absolute; left:20px; top:50px; width:3px; height:3px; z-index:1; background-color: #708574; layer-background-color: #708574; border: 1px none #000000; clip: rect(0 3 3 0)">
      id="yyd2"
style="position:absolute; left:30px; top:50px; width:3px; height:3px; z-index:1; background-color: #379bbf; layer-background-color: #379bbf; border: 1px none #000000; clip: rect(0 3 3 0)">
      id="yyd3"
style="position:absolute; left:40px; top:50px; width:3px; height:3px; z-index:1; background-color: #25184c; layer-background-color: #25184c; border: 1px none #000000; clip: rect(0 3 3 0)">
      id="yyd4"
style="position:absolute; left:50px; top:50px; width:3px; height:3px; z-index:1; background-color: #31bd3c; layer-background-color: #31bd3c; border: 1px none #000000; clip: rect(0 3 3 0)">
      id="yyd5"
style="position:absolute; left:60px; top:50px; width:3px; height:3px; z-index:1; background-color: #c11efd; layer-background-color: #c11efd; border: 1px none #000000; clip: rect(0 3 3 0)">

javamail sendMail

zhouhaizhe@126.com(admin) — Tue,16 Jun 2009 12:16:40 +0800

/*

此篇僅介紹用javamail實現發送郵件功能，其中涉及smtp認證，郵件附件發送，及HTML內容郵件等。
其他有關多郵箱的實現，接收POP3郵件及IMAP等內容。

如下程式需要：javamail，JAF包，j2ee.jar包含了上述兩個包，建議大家安裝J2SDKEE或直接拷貝j2ee.jar，將其添加到jbuilder的library中，
或系統ClassPath中

*/

/**
* @author Haley haley_hj@163.com
* @QQ:87823050
* @homepage:http://haley.yeah.net
* @12/18/2002
*/

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Date;
import javax.activation.*;
import java.io.*;

public class sendMail {

private MimeMessage mimeMsg; //MIME郵件物件

private Session session; //郵件會話物件
private Properties props; //系統屬性
private boolean needAuth = false; //smtp是否需要認證

private String username = ""; //smtp認證用戶名和密碼
private String password = "";

private Multipart mp; //Multipart物件,郵件內容,標題,附件等內容均添加到其中後再生成MimeMessage物件

public sendMail() {
setSmtpHost("172.24.15.228");//指定郵件伺服器
createMimeMessage();
}

public sendMail(String smtp){
setSmtpHost(smtp);
createMimeMessage();
}

/**
* @param hostName String
*/
public void setSmtpHost(String hostName) {
System.out.println("設置系統屬性：mail.smtp.host = "+hostName);
if(props == null)props = System.getProperties(); //獲得系統屬性物件

props.put("mail.smtp.host",hostName); //設置SMTP主機
}

/**
* @return boolean
*/
public boolean createMimeMessage()
{
try{
System.out.println("準備獲取郵件會話對象！");
session = Session.getDefaultInstance(props,null); //獲得郵件會話對象
}
catch(Exception e){
System.err.println("獲取郵件會話物件時發生錯誤！"+e);
return false;
}

System.out.println("準備創建MIME郵件對象！");
try{
mimeMsg = new MimeMessage(session); //創建MIME郵件物件
mp = new MimeMultipart();

return true;
}
catch(Exception e){
System.err.println("創建MIME郵件物件失敗！"+e);
return false;
}
}

/**
* @param need boolean
*/
public void setNeedAuth(boolean need) {
System.out.println("設置smtp身份認證：mail.smtp.auth = "+need);
if(props == null)props = System.getProperties();

if(need){
props.put("mail.smtp.auth","true");
}else{
props.put("mail.smtp.auth","false");
}
}

/**
* @param name String
* @param pass String
*/
public void setNamePass(String name,String pass) {
username = name;
password = pass;
}

/**
* @param mailSubject String
* @return boolean
*/
public boolean setSubject(String mailSubject) {
System.out.println("設置郵件主題！");
try{
mimeMsg.setSubject(mailSubject);
return true;
}
catch(Exception e) {
System.err.println("設置郵件主題發生錯誤！");
return false;
}
}

/**
* @param mailBody String
*/
public boolean setBody(String mailBody) {
try{
BodyPart bp = new MimeBodyPart();
bp.setContent(""+mailBody,"text/html;charset=GB2312");
mp.addBodyPart(bp);

return true;
}
catch(Exception e){
System.err.println("設置郵件正文時發生錯誤！"+e);
return false;
}
}

/**
* @param name String
* @param pass String
*/
public boolean addFileAffix(String filename) {

System.out.println("增加郵件附件："+filename);

try{
BodyPart bp = new MimeBodyPart();
FileDataSource fileds = new FileDataSource(filename);
bp.setDataHandler(new DataHandler(fileds));
bp.setFileName(fileds.getName());

mp.addBodyPart(bp);

return true;
}
catch(Exception e){
System.err.println("增加郵件附件："+filename+"發生錯誤！"+e);
return false;
}
}

/**
* @param name String
* @param pass String
*/
public boolean setFrom(String from) {
System.out.println("設置發信人！");
try{
mimeMsg.setFrom(new InternetAddress(from)); //設置發信人
return true;
}
catch(Exception e)
{ return false; }
}

/**
* @param name String
* @param pass String
*/
public boolean setTo(String to){
if(to == null)return false;

try{
mimeMsg.setRecipients(Message.RecipientType.TO,InternetAddress.parse(to));
return true;
}
catch(Exception e)
{ return false; }

}

/**
* @param name String
* @param pass String
*/
public boolean setCopyTo(String copyto)
{
if(copyto == null)return false;
try{
mimeMsg.setRecipients(Message.RecipientType.CC,(Address[])InternetAddress.parse(copyto));
return true;
}
catch(Exception e)
{ return false; }
}

/**
* @param name String
* @param pass String
*/
public boolean sendout()
{
try{
mimeMsg.setContent(mp);
mimeMsg.saveChanges();
System.out.println("正在發送郵件....");

Session mailSession = Session.getInstance(props,null);
Transport transport = mailSession.getTransport("smtp");
transport.connect((String)props.get("mail.smtp.host"),username,password);
transport.sendMessage(mimeMsg,mimeMsg.getRecipients(Message.RecipientType.TO));
//transport.send(mimeMsg);

System.out.println("發送郵件成功！");
transport.close();

return true;
}
catch(Exception e)
{
System.err.println("郵件發送失敗！"+e);
return false;
}
}

/**
* Just do it as this
*/
public static void main(String[] args) {

String mailbody = ""+
"

Haley

";

sendMail themail = new sendMail("172.24.15.228");
themail.setNeedAuth(true);

if(themail.setSubject("JavaMail") == false) return;
if(themail.setBody(mailbody) == false) return;
if(themail.setTo("haley@172.24.15.228") == false) return;
if(themail.setFrom("haley@172.24.15.228") == false) return;
if(themail.addFileAffix("c:\\sqlnet.log") == false) return;
themail.setNamePass("haley","584520");

if(themail.sendout() == false) return;
}
}

四个有害的Java编码习惯

zhouhaizhe@126.com(admin) — Tue,16 Jun 2009 12:14:32 +0800

程序中的编码风格让我们的编程工作变得轻松，特别是程序维护员，他们要经常阅读其他人编写的程序编码，这一点尤其突出。编码规范从根本上解决了程序维护员的难题；规范的编码阅读和理解起来更容易，也可以快速的不费力气的借鉴别人的编码。对将来维护你编码的人来说，你的编码越优化，他们就越喜欢你的编码，理解起来也就越快。

　　同样，高水平的编码风格（例如固定的封闭结构）目的在于改善设计和使编码更易于理解。事实上，最后有些人会认为改善设计和提高编码的易读性是一回事。
　　本文中你会看到一些流行的编码风格被面向读者的更易于接受的风格所替代。有人争论说这些风格都已经被大家广泛使用，不应该简单的为了达到读者的期望而抛弃。然而，读者的期待只是其中一方面的原因，不可能凌驾于所有因素之上。列出四种常见的问题：
　　1.对局域变量(localvariables)、参数(methodarguments)、字段(fields)这三种变量的命名没有区分:
　　对看编码的人来说，首先要弄清这些数据如何定义的？看一个类时，得弄清楚每个条目是局域变量？字段？还是参数？有必要使用一个简单的命名约定来定义这些变量，增加易读性。
　　很多权威机构规范过字段变量用以区分它与其它的变量，但这远远不够。可以把对字段的合理的命名约定逻辑也应用在参数上面。先看示例1：没有进行区分这三种变量的类定义，如下所示：
　　示例1：
　　public boolean equals (t arg)
　　if (! (arg instanceof Range)) return false;
　　Range other = (Range) arg;
　　return start.equals(other.start)&&end.equals(other.end);
　　在这个方法中，arg直接用argument的缩写，虽然大家一看就知道这是参数了，但这种命名方式却丢失了参数代表的对象本身的含义。大家知道这是参数，却不知道这是什么参数。如果方法的参数多一点，都按照arg1，arg2这样的方式命名，阅读代码的时候很头疼。另外两个字段变量，start和end，突然凭空而出，想一下才知道这应该是字段。当然，这个方法很短，造成的困难还不大，如果这个方法比较长的话，突然看到start和end两个变量，一般会先在前面找一下是不是局部变量，然后才能确定是类的字段变量。
　　这个问题貌似微不足道，但为什么要让代码阅读者花费额外时间在这些琐碎的问题上呢？如果有个方案能让代码阅读者一目了然的明白变量是那种变量，为什么不采用呢？就如同SteveMcConnell在《代码大全》中说的:"让人费神去琢磨神秘杀人凶手这没有问题，但你不需要琢磨程序代码，代码是用来阅读的。
　　接下来看示例2，使用命名约定后对示例1重写以后的代码，用到的命名约定有：
　　参数定义时名字加前缀a
　　字段定义时名字加前缀f
　　局域变量定义时不加任何前缀
　　示例2：对变量类型进行区分
　　public boolean equals (t aOther)
　　if (! (aOther instanceof Range)) return false;
　　Range other = (Range) aOther;
　　return fStart.equals(other.fStart)&&fEnd.equals(other.fEnd);
　　你可能反对示例2中的风格，反对过时了的匈牙利符号，但是我认为反对是错误的，因为匈牙利符号能详细说明信息的类型。上面的命名约定区分了类型。而且这样做分清了字段、变量和局域变量，这是两种完全不同的概念。这种命名约定的方式并不像看起来那么微不足道：当这些约定用在程序编码中时，会大大降低理解的难度，因为你可以不需要先分辨这些变量，省去不少时间。
　　2.按层次划分包，而不是根据特征或功能划分最常见的划分应用序就是按层次命名包：
　　com.blah.action 、com.blah.dao 、com.blah.model、com.blah.util
　　也就是说，把具有同样特征或者功能的类划分到了不同的包里。因为成员的属性对其他成员应该是可见的，这就意味着几乎应用程序中所有的类都是公共的。实际上，这种按层次划分包的方法完全扔掉了Java的包内私有。包内私有应该彻底不使用。现在，包内私有是Java程序语言中设计者的默认作用域。这种包的划分习惯也违反了面向对象编程的核心原则之--尽量保持私有以减少影响,因为这种习惯强迫你必须扩大类的作用域。由于一些奇怪的原因，一些Java组织不赞成这种命名，似乎不公正的。
　　另一种风格是按特征划分命名：
　　com.blah.painting 、com.blah.buyer、com.blah.seller、com.blah.auction 、com.blah.webmaster、com.blah.useraccess、com.blah.util
　　这里，成员不按行为划分，而是按照不同特征的类划分，每个成员都关联不同的特征。这种方法下包在最初使用是被定义。
　　例如：在Web应用程序中，“com.blah.painting”包可能由下列成员组成：
　　Painting.java: 一个model对象
　　PaintingDAO.java: 一个数据存取对象Dao
　　PaintingAction.java: 一个控制或者行为对象
　　statements.sql: Dao对象使用的SQl文件
　　view.jsp: Jsp文件
　　需要特别说是的是，这种划分方法，每一个包都包含所有成员有关的特征文件，而不仅仅是Java源文件。这种按特征划分包的方法，要求在做删除操作时要注意，删除一个特征时要删掉它的整个目录，不能保存在源码中。
　　这种方法优于按层次划分包的方法，表现在以下几点：
　　包是高内聚的，并且模块化，包与包之间的耦合性被降到最低。
　　代码的自描述性增强. 读者只需看包的名字就对程序有些什么功能或特征有了大概的印象。在《代码大全》中, SteveMcConnell将自描述性的代码比作 "易读的圣杯"，来表达它的易读性。
　　把类按照每个特征和功能区分开可以很容易实现分层设计。
　　相关的成员在同一个位置。不需要为了编辑一个相关的成员而去浏览整个源码树。
成员的作用域默认是包内私有。只有当另外的包需要访问某个成员的时候，才把它修改为public.(需要注意的是修改一个类为public，并不意味着它的所有类成员都应该改为public。public成员和包内私有(package-private)成员是可以在同一个类里共存的。)
　　删除一个功能或特征只需要简单的删除一个文件夹。
　　每个包内一般只有很少的成员，这样包可以很自然的按照进化式发展。如果包慢慢变的太大，就可以再进行细分，把它重构为两个或者更多新的包，类似于物种进化。而按照层次划分的方式，就没办法进化式发展，重构也不容易。
　　一些框架推荐使用层层定义包的传统的方式做为包的命名方法：由于使用传统的包命名，开发者总能知道在哪个位置可以找到这些项目，但是为什么避免人们这样做呢？使用另一种按特征定义包的风格，就不需要这种单调的操纵，因此，按特征定义完全超越了任何其它命名约定。约书亚布洛赫在《高效的Java》一书中说到：区分一个设计好坏的唯一重要因素是模块内部隐藏的数据和其它模块中涉及的实现过程的程度。
　　共2页: 1 [2]
　　内容导航
　　第 1 页：变量的命名区分第 2 页：习惯用JavaBeans而不是不可变对象
　　 3.习惯用JavaBeans而不是不可变对象
　　不可变对象是构造后状态不改变。Scala的主要创造者MartinOdersky最近还称赞过这种不可变对象。在《高效的Java》一书中，JoshuaBloch列举了大量实例支持使用不可变对象，并总结了很多优点。但他的意见，似乎很大程度上被忽略。大多数程序使用JavaBeans来替代不可变对象。JavaBean明显要比不可变对象复杂的多，因为它的巨大的声明空间。粗略的讲，你可以把JavaBean看作是与不可变对象完全相反的对象：它允许最大的可变性。JavaBean常被用来做数据库记录的映射。假如你要从数据库记录集映射一行为对象，不考虑现有的持久化方案和框架，你会将这个对象设计成什么样子？跟javabean相似呢还是完全不一样？我认为会完全不一样，说明如下：
　　它不包含一个无参数构造方法（这一特征是javabean必备的。）。作者认为一个数据库记录的对象如果不包含任何数据是没有意义的。一个数据库表的所有字段都是可选的情况有多少？
　　It would likely not have anything to say about eventsandlisteners.(不太明白作者的意思)
　　它不强迫你用可变的对象。
　　它内部有一个数据验证机制。这样一个验证机制对大多数数据库应用非常重要。(记住对象的第一原则：一个对象应该同时封装数据和对数据的操作。在这种情况下，操作就是验证数据。)
　　数据验证机制可以给最终用户(end user)报错。
　　按照javabeans的说明，javabeans是用来解决特殊领域的问题:在图形界面程序的设计中充当小部件。说明中绝对没有提到数据库。但现在通常用javabean来做数据库记录的映射。从实际角度来讲，许多被广泛使用的框架要求应用程序使用JavaBeans（或者其它类似的规范）来映射数据库记录。这种滥用不利于编程者了解和使用不可变对象。
　　4.私有成员排在其它成员的前面类成员的排序没有按照成员的作用域的大小排列，而是把private放在前面。
　　以前的好莱坞影片开头总是长篇的荣誉。同样地，大多数Java类把私有成员放在最前面。示例3给出这种风格的典型例子：
　public class OilWell implements EnergySource
　　private Long id;
　　private String name;
　　private String location;
　　private Date discoveryDate;
　　private Long totalReserves;
　　private Long productionToDate;
　　public Long getId()
　　return id;
　　public void setId(Long id)
　　this.id = id; //..elided
　　然而，如果把私有成员定义放在后面，读者阅读会更容易。因为人们认识一个事物的通常过程都是从一般到特殊，从抽象层次来说，是从高层次到低层次的认识过程。如果你倒过来的话，读者就不能从整体上把握事物，也不能抓住事物的本质，只能在一堆具体的片段中迷失。
　　整体的抽象让你忽略了细节。抽象的层次越高，你可以忽略越多的细节。读者阅读一个类时可以忽略的细节越多他会越高兴。脑袋里填充太多的细节是痛苦的，所以细节越少越好。因此，将私有成员放在最后会显得更富有同情心，因为这样阻止了不必要的细节显露给读者。
　　本来C++程序的习惯也是像Java一样把private成员放在最开始。然而，C++社区迅速的认识到这是一个有害的规范，这个规范现在已经被修正。这里给出一个经典的C＋＋风格指南里的注释：
　　注意:public 接口应该放在class的最开始，其次是protected成员，最后是private成员。原因是:
　　程序员应该更关心接口而不是具体实现。
　　当程序员需要用一个类的时候，他们需要的是接口而不是实现。
　　把接口放在开始是非常有意义的。把实现部分，私有部分，放在开始是一个历史遗留问题。最后还是要反复强调一下，一个类的接口的重要性超过实现细节。
　　同样，伦敦大学帝国学院关于C++的指面中也说到：把公有的部分放在前面，读者会更感兴趣阅读，然后是保护的部分，最后是私有的部分。
　　有人会持反对意见，认为读者可以使用程序文档来理解类，而不是直接看源代码。这种理由似乎不成立，因为程序文档中没有相关的实现细节，这时看源代码是很有必要的。
　　所有的技术文档，通常都把难理解的信息放在开头，比如抽象的学术论文。为什么Java不打破这种常规呢？把私有成员放在最开头部分看起来是不是打破常规的好习惯。这种习惯似乎是sun早期的编码规范造成的。
　　将代码按照javadoc的顺序编排是非常好的：首先是构造方法，然后是非私有方法，最后是私有部分和方法。这样读者阅读的时候很自然的从抽象层次的高向低运动。
　　本文所讲的是一些Java的不好习惯和风格需要改变。最终的目地是希望我们的代码易读性更强，让读者更易于理解。

　自动跳转

zhouhaizhe@126.com(admin) — Wed,13 May 2009 18:05:23 +0800