Queue

posted @ 2009-10-18 18:29 forgood 阅读(198) | 评论 (0) | 编辑 收藏

java中的编码方法

package src;

import java.io.UnsupportedEncodingException;

public class ChangeCharset {
  /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */
  public static final String US_ASCII = "US-ASCII";

  /** ISO 拉丁字母表 No.1，也叫作 ISO-LATIN-1 */
  public static final String ISO_8859_1 = "ISO-8859-1";

  /** 8 位 UCS 转换格式 */
  public static final String UTF_8 = "UTF-8";

  /** 16 位 UCS 转换格式，Big Endian（最低地址存放高位字节）字节顺序 */
  public static final String UTF_16BE = "UTF-16BE";

  /** 16 位 UCS 转换格式，Little-endian（最高地址存放低位字节）字节顺序 */
  public static final String UTF_16LE = "UTF-16LE";

  /** 16 位 UCS 转换格式，字节顺序由可选的字节顺序标记来标识 */
  public static final String UTF_16 = "UTF-16";

  /** 中文超大字符集 */
  public static final String GBK = "GBK";

  /**
   * 将字符编码转换成US-ASCII码
   */
  public String toASCII(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, US_ASCII);
  }
  /**
   * 将字符编码转换成ISO-8859-1码
   */
  public String toISO_8859_1(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, ISO_8859_1);
  }
  /**
   * 将字符编码转换成UTF-8码
   */
  public String toUTF_8(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, UTF_8);
  }
  /**
   * 将字符编码转换成UTF-16BE码
   */
  public String toUTF_16BE(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, UTF_16BE);
  }
  /**
   * 将字符编码转换成UTF-16LE码
   */
  public String toUTF_16LE(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, UTF_16LE);
  }
  /**
   * 将字符编码转换成UTF-16码
   */
  public String toUTF_16(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, UTF_16);
  }
  /**
   * 将字符编码转换成GBK码
   */
  public String toGBK(String str) throws UnsupportedEncodingException{
   return this.changeCharset(str, GBK);
  }
 
  /**
   * 字符串编码转换的实现方法
   * @param str  待转换编码的字符串
   * @param newCharset 目标编码
   * @return
   * @throws UnsupportedEncodingException
   */
  public String changeCharset(String str, String newCharset)
    throws UnsupportedEncodingException {
   if (str != null) {
    //用默认字符编码解码字符串。
    byte[] bs = str.getBytes();
    //用新的字符编码生成字符串
    return new String(bs, newCharset);
   }
   return null;
  }
  /**
   * 字符串编码转换的实现方法
   * @param str  待转换编码的字符串
   * @param oldCharset 原编码
   * @param newCharset 目标编码
   * @return
   * @throws UnsupportedEncodingException
   */
  public String changeCharset(String str, String oldCharset, String newCharset)
    throws UnsupportedEncodingException {
   if (str != null) {
    //用旧的字符编码解码字符串。解码可能会出现异常。
    byte[] bs = str.getBytes(oldCharset);
    //用新的字符编码生成字符串
    return new String(bs, newCharset);
   }
   return null;
  }

  public static void main(String[] args) throws UnsupportedEncodingException {
   ChangeCharset test = new ChangeCharset();
   String str = "This is a 中文的 String!";
   System.out.println("str: " + str);
   String gbk = test.toGBK(str);
   System.out.println("转换成GBK码: " + gbk);
   System.out.println();
   String ascii = test.toASCII(str);
   System.out.println("转换成US-ASCII码: " + ascii);
   gbk = test.changeCharset(ascii,ChangeCharset.US_ASCII, ChangeCharset.GBK);
   System.out.println("再把ASCII码的字符串转换成GBK码: " + gbk);
   System.out.println();
   String iso88591 = test.toISO_8859_1(str);
   System.out.println("转换成ISO-8859-1码: " + iso88591);
   gbk = test.changeCharset(iso88591,ChangeCharset.ISO_8859_1, ChangeCharset.GBK);
   System.out.println("再把ISO-8859-1码的字符串转换成GBK码: " + gbk);
   System.out.println();
   String utf8 = test.toUTF_8(str);
   System.out.println("转换成UTF-8码: " + utf8);
   gbk = test.changeCharset(utf8,ChangeCharset.UTF_8, ChangeCharset.GBK);
   System.out.println("再把UTF-8码的字符串转换成GBK码: " + gbk);
   System.out.println();
   String utf16be = test.toUTF_16BE(str);
   System.out.println("转换成UTF-16BE码:" + utf16be);
   gbk = test.changeCharset(utf16be,ChangeCharset.UTF_16BE, ChangeCharset.GBK);
   System.out.println("再把UTF-16BE码的字符串转换成GBK码: " + gbk);
  }
}

posted @ 2009-09-23 14:25 forgood 阅读(288) | 评论 (0) | 编辑 收藏

byte数组和String之间的转化

JAVA里面关于byte数组和String之间的转换问题

把byte转化成string，必须经过编码。

例如下面一个例子:

import java.io.UnsupportedEncodingException;

public class test{
 public static void main(String g[]) {
  String s = "12345abcd";
  byte b[] = s.getBytes();
  String t = b.toString();

  System.out.println(t);

 }
}
输出字符串的结果和字符串s不一样了.

经过以下方式转码就可以正确转换了:

public class test{
 public static void main(String g[]) {
  String s = "12345abcd";
  byte b[] = s.getBytes();
  try {
   String t = new String(b);
   System.out.print(t);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

引用：
String   str   =   "String"; 
          byte[]   byte1   =   str.getBytes(); 
          String   str1   =   new   String(byte1); 
          byte[]   byte2   =   str1.getBytes(); 
          String   str2   =   new   String(byte2); 
          System.out.println("str<<<"   +   str); 
          System.out.println("byte1<<<"   +   byte1); 
          System.out.println("str1<<<"   +   str1); 
          System.out.println("byte2<<<"   +   byte2); 
          System.out.println("str2<<<"   +   str2); 
  ------------------------------------- 
  输出结果 
  str<<<String 
  byte1<<<[B@192d342 
  str1<<<String 
  byte2<<<[B@6b97fd 
  str2<<<String 
  
  想请教为什么两个byte输出的不一样呢? 
 

String   str   =   "String"; 
          byte[]   byte1   =   str.getBytes(); 
          String   str1   =   new   String(byte1); 
          byte[]   byte2   =   str1.getBytes(); 
  ---------- 
  注意byte1是str得到的byte数组，而byte2是另一个字符串str1得到的数组 
  他们本身也是两个对象  
   
  直接打印实际上调用的是toString()方法，而toString()的默认实现是打印对象类型+hashCode()  
  [B表示byte数组  @表示之后的是地址  后面跟着的是hashCode，其实就是其虚拟机地址  
  

posted @ 2009-09-23 14:19 forgood 阅读(3052) | 评论 (0) | 编辑 收藏

jvm的内存模型

posted @ 2009-09-18 09:12 forgood 阅读(283) | 评论 (0) | 编辑 收藏

财务公司概述

posted @ 2009-09-06 16:19 forgood 阅读(212) | 评论 (0) | 编辑 收藏

英语常用语

　　2、“收买某人”：有个比较正式的词叫bribe，名词时为“贿赂”的意思，动词时就有“收买”之意。既然提到了“买”，那么我们能不能用上buy呢？当然，那就是buy sb off。

　　3、“向前看！”：我们会说Look forward！而美语里有个更贴切的说法是Eyes front！“眼睛朝前”，是不是很生动？

　　4、“头等大事”：你会怎么翻译呢？The most important thing吗？看这个吧“It's on the top of my list”。

　　5、“看在主的份上，你就……”：两种说法，其一是For the love of God，另外For God's sake(sake的意思是缘故、关系)二者之中，后者更常用

　　6、“我不是傻子！”：I am not a fool？对，语法完全正确。但再看这个I am no fool。比上面的只少两个字母，但是不是感觉不一样？同样的道理，我们常说I have no idea，而不常说I dont have any idea。

　　7、short hairs：是说“短头发”吗？呵呵，它就是我们说的“小辫子”！

　　8、one-time thing：帅哥跟一美女过了一夜，回来后室友问帅哥：Do you really love her？帅哥回答：Oh, it was just a one-time thing!那么one-time thing是什么呢？我就不罗嗦喽！

　　9、She knew red was her color。“她知道红色是她的颜色”？恰当的翻译是：她知道自己和红色很相配。Then, what's your color？

　　10、“停电”：No electricity？恩，够直白！其实提到“电”，老外更多是用power，停电就可以是Ther is a power failure或Power goes out

posted @ 2009-08-30 12:49 forgood 阅读(216) | 评论 (0) | 编辑 收藏

html中的标签

有一次编网页的时候,把base 标签给删掉了,超链接怎么也行不通,老是路径不对,原来是base 标签在做怪:
       <base>标记定义了文档的基础URL地址，在文档中所有的相对地址形式的URL都是相对于这里定义的URL而言的。一篇文档中的<base>标记不能多于一个，必须放于头部，并且应该在任何包含URL地址的语句之前。
      （1）href 属性
       href属性指定了文档的基础URL地址，该属性在<base>标记中是必须存在的。
例如：如果希望将文档的基础URL定义为“www.abc.com”，则可以使用如下语句：
<base href = "www.abc.com"> 当定义了基础URL地址之后，文档中所有引用的URL地址都从该基础URL地址开始，例如，对于上面的语句，如果文档中一个超级链接指向gsl/welcome.htm，则它实际上指向的是如下URL地址：www.abc.com/gsl/welcome.htm
       （2）target
        target属性同框架一起使用，它定义了当文档中的链接被点击后，在哪一个框架中展开页面。如果文档中超级链接没有明确指定展开页面的目标框架集，则就使用这里定义的地址代替。常用的target的属性值有：
        _blank，表明在新窗口中打开链接指向的页面。
        _self，在当前文档的框架中打开页面。
        _parent，在当前文档的父窗口中打开页面。
        _top，在链接所在的完整窗口中展开页面。

posted @ 2009-08-26 11:12 forgood 阅读(178) | 评论 (0) | 编辑 收藏

改变原虚拟硬盘的大小

    如果是在vmware里面安装的windows系统，添加个硬盘很容易，

（1）先打开要添加硬盘的虚拟系统（不要启动该系统），选择虚拟机菜单---设置-----选添加，

（2）然后在弹出添加硬件向导窗口中------选择硬盘-------一路next就好了，后面的操作和新建一个虚拟机的时候配置硬盘是一样的。

（3）添加了新的硬盘后，启动windows进到系统中，在控制面板中找“管理工具”->“计算机管理”，然后选“磁盘管理”，添加新磁盘就好了。

其实很简单的..如果想继续给VMware增加硬盘的话,重复上述动作。

2、改变原虚拟硬盘的大小

界面中并没有提供增加硬盘容量的方法。

只能在命令行形式下执行。

安装所在盘的c:\Program Files\VMware\VMware Workstation下有一个vmware-vdiskmanager.exe，就是它。

命令参数如下：
------------------------------------------------------------------
Usage: vmware-vdiskmanager.exe OPTIONS <disk-name> | <mount-point>

Offline disk manipulation utility

   Options:
      -c                    : create disk; need to specify other create options
      -d                    : defragment the specified virtual disk
      -k                    : shrink the specified virtual disk
      -n <source-disk>      : rename the specified virtual disk; need to
                             specify destination disk-name
      -p                    : prepare the mounted virtual disk specified by
                             the drive-letter for shrinking
      -q                    : do not log messages
      -r <source-disk>      : convert the specified disk; need to specify
                             destination disk-type
      -x <new-capacity>     : expand the disk to the specified capacity

      Additional options for create and convert:
         -a <adapter>       : (for use with -c only) adapter type (ide, buslogic o
r lsilogic)
         -s <size>          : capacity of the virtual disk
         -t <disk-type>     : disk type id

      Disk types:
         0                  : single growable virtual disk
         1                  : growable virtual disk split in 2Gb files
         2                  : preallocated virtual disk
         3                  : preallocated virtual disk split in 2Gb files

      The capacity can be specified in sectors, Kb, Mb or Gb.
      The acceptable ranges:
                            ide adapter : [100.0Mb, 950.0Gb]
                            scsi adapter: [100.0Mb, 950.0Gb]

         ex 1: vmware-vdiskmanager.exe -c -s 850Mb -a ide -t 0 myIdeDisk.vmdk
         ex 2: vmware-vdiskmanager.exe -d myDisk.vmdk
         ex 3: vmware-vdiskmanager.exe -r sourceDisk.vmdk -t 0 destinationDisk.vm
dk
         ex 4: vmware-vdiskmanager.exe -x 36Gb myDisk.vmdk
         ex 5: vmware-vdiskmanager.exe -n sourceName.vmdk destinationName.vmdk
         ex 6: vmware-vdiskmanager.exe -k myDisk.vmdk
         ex 7: vmware-vdiskmanager.exe -p <mount-point>
               (A virtual disk first needs to be mounted at <mount-point>)
-----------------------------------------------------------------
其中的-x参数就是用来扩容的……

如这个：vmware-vdiskmanager.exe -x 36Gb myDisk.vmdk

    解析： vmware-vdiskmanager.exe -x 大小 虚拟硬盘文件
-------------------------------------------------------

我的执行过程：

D:\Program files\VMware\VMware Workstation>vmware-vdiskmanager.exe -x 12GB "F:\Windows Server 2003 Enterprise Edition\Windows Server 2003 Enterprise Edition.vmdk"
==================================================================
总结一下：
1。文件名应该用双引号括起来。
2。vmdk文件名要连同路径。
3。GB，MB，别忘了B。

posted @ 2009-08-20 11:22 forgood 阅读(516) | 评论 (0) | 编辑 收藏

财务公司金融债券的概念

posted @ 2009-08-09 22:48 forgood 阅读(395) | 评论 (0) | 编辑 收藏

正则表达式学习资料

学习资源：

http://www.cnblogs.com/jimmyzhang/archive/2007/10/24/936151.html （花上1-2个小时仔细学习，然后反复实践，能够很快上手）

正则表达式工具：

我首推RegexBuddy了。下面这个地址里有RegexBuddy3.2.1完整版的下载地址（如果你仔细浏览这个网站，会发现此人是一个正则表达式狂热分子）：

http://iregex.org/blog/regexbuddy321.html

posted @ 2009-07-19 18:03 forgood 阅读(215) | 评论 (0) | 编辑 收藏

js判断页面关闭的方法

1、<script language="javascript">

window.onbeforeunload = function()

{

 if(((event.clientX > document.body.clientWidth - 43) && (event.clientY < 23)) || event.altKey) {

  window.event.returnValue = '关闭。';   

 }

}

</script>

2、<script language="javascript">

window.onbeforeunload = function()

{

var n = window.event.screenX - window.screenLeft;

var b = n > document.documentElement.scrollWidth-20;

if(b && window.event.clientY < 0 || window.event.altKey)

{

alert("是关闭而非刷新");

window.open(this.location); 

//return false;

//window.event.returnValue = ""; }

}

</script>

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ajaxchen_615/archive/2009/07/06/4325917.aspx

posted @ 2009-07-06 22:17 forgood 阅读(1302) | 评论 (0) | 编辑 收藏

ie7和ie8浏览器中网页不兼容的问题处理

posted @ 2009-07-06 22:12 forgood 阅读(306) | 评论 (0) | 编辑 收藏

记录今天

posted @ 2009-07-06 09:13 forgood 阅读(141) | 评论 (0) | 编辑 收藏

js对象学习笔记（二）

1.对象和属性

    对象是一种复核数据类型，它们将多个数据值几种在一个单元中，而且允许使用名字来存取这些值，即对象是一个无序的属性集合，这个属性都有自己的名字和值，存储在对象中的以命名的值可以是数字和字符串这样的原始值，也可以是对象。

2.对象的创建

    对象是由运算符new来创建的，在这个运算符之后必须有用于初始化对象的构造函数名。

    创建一个空对象（即没有属性的对象）

    var o = new Object();

    js还支持内部构造函数，它们以另一种简洁的方式初始化新创建的对象

    var now = new Date();

    var new_year = new Date(2009,09,19);

3.属性的设置和查询

4.属性的枚举

    for/in循环列出的属性并没有特定顺序，而且它只能枚举出所有用户定义的属性，但是却不能枚举出那些预定义的属性或方法,并且它可以

枚举出被设为undefined的属性，但是它不能列出被delete删除的属性。

5.未定义的属性

    如果要读取一个不存在属性的值，那么得到的结果是一个特殊的js值，undefined

    可以使用delete来删除一个对象的属性，注意：删除一个属性并不仅仅是把该属性设置为undefined，而是真正从对象中移除了该属性。

6.构造函数

    它由new运算符调用，传递给它的是一个新创建的空对象引用，将该引用作为关键字this的值，而且它还要对新创建的对象进行适当的初始化。

    注意：构造函数如何使用它的参数来初始化this关键字所引用的对象的属性，记住，构造函数只是初始化了特定的对象，但并不返回这个对象。

    构造函数通常没有返回值，他们只是初始化由this值传递进来的对象，并且什么也不返回..但是，构造函数可以返回一个对象值，如果这样做，被返回的对象就成了new表达式的值了，在这种情况下，

this值所引用的对象就被丢弃了。

7.方法

    方法有一个非常重要的属性，即在方法主体内部，关键字this的值变成了调用该方法的对象。

    方法和函数的区别，其实他们没有什么技术上的差别，真正的区别存在于设计和目的上，方法是用来对this对象进行操作的，而函数通常是独立的，并不需要使用this对象。

8.原型对象和继承

    js对象都“继承”原型对象的属性，每个对象都有原型对象，原型对象的所有属性是以它为原型的对象的属性，也就是说，每个对象都继承原型对象的所有属性，

    一个对象的原型是有创建并初始化该对象的构造函数定义的，js中的所有函数都有prototype属性，它引用一个对象，虽然原型对象初始化时是空的，但是你在其中定义的任何属性都会被构造函数创建

的所有对象继承。

    构造函数定义了对象的类，并初始化了类中状态变量的属性，因为原型对象和构造函数关联在一起，所以类的每个成员都从原型对象继承了相同的属性，这说明原型对象是存放方法和其他常量属性的理

想场所。

    继承是在查询一个属性值时自动发生的，属性并非从原型对象赋值到新的对象的，他们只不过看起来像是那些对象的属性，有两点重要的含义，一是：使用原型对象可以大量减少每个对象对内存的需求

量，因为对象可以继承许多属性；而且即使属性在对象被创建之后才添加属性到它的原型对象中，对象也能够继承这些属性。

    属性的继承只发生在读属性值时，而在写属性值时不会发生。

    因为原型对象的属性被一个类的所有对象共享，所以通常只用他们来定义类中所有对象的相同的属性，这使得原型对象适合于方法定义，另外原型对象还适合于具有常量的属性的定义，

a.原型和内部类

 不只是用户定义的类有原型对象，像内部类同样具有原型对象，也可以给他们赋值，

e.g    String.prototype.endsWith = function(o){

            return (e == this,charAt(this.length-1));

        }

9.面向对象的js

    在面向对象的程序设计中，共有的概念是强类型和支持以类为基础的继承机制，根据这个评判标准，就可以证明js不是面向对象语言。

    js对象可以具有大量的属性，而且还可以动态的将这些属性添加到对象中，这是对面对象c++和java做不到的，

    虽然js没有类的概念，但是它用构造函数和原型对象模拟了类。

    js和以类为基础的面向对象语言中，同一个类可以具有多个对象，对象是它所属的那个类的实力，所以任何类都可以有多个实例，js中的命名延勇了java中的命名约定，即命名类时以大写字母开头，命名对象时以小写字母开头，类帮助我们区分代码中的类和对象。

实例属性

    每个对象都有它自己单据的实力属性的副本，为了模拟面向对象的程序设计语言，js中的实例属性是那些在对象中用构造函数创建的或初始化的属性。

实例方法

    实例方法和实例数据非常的相似，实例方法是由特定对象或实例调用的，实例方法使用了关键字this来引用他们要操作的对象或实例，但是和实例属性不同额一点是每个实例方法都是由类的所有实例共享的，在js中，给类定义一个实例方法，是通过把构造函数的原型对象中的一个属性设置为函数值类实现的，这样，由那个构造函数创建的所有对象都会共享一个以继承的对函数的引用，而且使用上面素数的方法调用语法就能够调用这个函数。

类属性

   类属性是一个与类相关联的变量，而不是和类的每个实例相关联的变量，每个类属性只有一个副本，它是通过类存取的，可以简单的定义了构造函数自身的一个属性来定义类属性

类方法

    类方法是一个与类关联在一起的方法，而不是和类的实例关联在一起的方法，要调用类方法，就必须使用类本身，而不是使用类的特定实例。由于类方法不能通过一个特定对象调用，所以使用关键字this对它来说没有意义，和类属性一样，类方法是全局性的，

超类和子类

    面向对象语言中有类层次的概念，每个类都有一个超类，他们从超类中继承属性和方法，类还可以被扩展，或者说子类化，这样其他子类就能继承它的行为，js中继承是以原型为基础的，而不是以类基础的继承机制，但是我们仍旧能够总结出累世的类层次图，在js中，类Object是最通用的类，其他所有类都是专用化了的版本，或者说的是Object的子类，另一种解释方法是Object是所有内部类的超类，所有类都继承了Object的基本方法。

   举例说明：

        类Complex的对象就继承了Complex.prototype对象的属性，而后者又继承了Object.prototype的属性，由此可以推出，对象Complex继承了两个对象的属性，在Complex对象中查询某个属性时，首先查询的是这个对象本身，如果在这个对喜爱那个中没有发现要查询的属性，就查询Complex.prototype对象，最后，如果在那个对象中还没有最后按到要查询的属性，就查询Object.prototype对象，注意类层次关系中的属性隐藏。参考P153

10.作为关联数组的对象

    运算符“.”类存取一个对象属性，而数组更常用的存取书香运算赋是[],下面的两行代码是等价的：

    obj.property   ====== obj["property"],他们的语法区别是，前者的属性名是标识符，后者的属性名却是一个字符串，

    在c、c++、java和其他类似的强类型语言中，一个对象的属性数是固定，而且必须预定义这些属性的名字，由于js是一种弱类型语言，它并没有采用这一规则，所以在用js编写的程序，可以为对象创建任意数目的属性，但是当你采用“.”运算符来存取一个对象的属性时，属性名时是用标识符表示的，而js程序性中，标识符必须被逐字的输入，他们不是一种数据类型，因此程序不能对他们进行操作。

    constructor属性

        每个对象都有constructor属性，它引用的是用来初始化该对象的构造函数。但是并不是所有的对象都具有自己唯一的constructor属性，相反，如果这个属性是从原型对象继承来的。

        js会为我们定义的每一个构造函数都创建一个原型对象，并且将那个对象赋给构造函数的prototype属性。但是之前没有说明原型对象初始时是非空的，在原型对象创建之初，它包括一个constructor属性， 用来引用构造函数，也就是说，如果有一个函数f，那么属性f.prototype.constructor就总是等于f的。

        由于构造函数定义了一个对象的类，所以属性construtor在确定给定对象的类型时是一个功能强大的工具。

        并不能保证constructor属性总是存在的，例如，一个类的创建者可以用一个全新的对象来替换构造函数的原型对象，而新对象可能不具有有效的constructor属性。

    toString()方法

    toLocaleString()方法

    valueOf()方法

        js需要将一个对象转化成字符创之外的原型类型时，就调用它，这个函数返回的是能代表关键字this所引用的对象的值的数据。

    hasOwnProperty()

        如果兑现局部定义了一个非继承的属性，属性名是由一个字符串实际参数指定的，那么该方法就返回true，否则，它将返回false。

    propertyIsEnumerable()

        如果对象定义了一个属性，属性名是由一个字符串实际参数指定的，而且该属性可以用for/in循环枚举出来，那么该方法返回true，否则返回false。

    注意：该方法只考虑对象直接定义的属性，而不考虑继承的属性，因为返回false可能是因为那个属性是不可枚举的，也可能是因为它虽然是可以枚举的，但却是个继承的属性。

    怎么判断一个属性是可枚举的？

    isPrototypeOf()

     如果调用对象是实际参数指定的对象的原型对象，该方法返回true，否则返回false，该方法的用途和对象的constructoe属性相似。

posted @ 2009-03-26 14:32 forgood 阅读(970) | 评论 (1) | 编辑 收藏

js中的函数学习（一）

1.函数

    注意：定义函数时可以使用个数可变的参数，而且函数既可以有return语句，也可以没有return语句；如果函数不包含return语句，它就只执行函数体中的每条语句，然后返回给调用者undefined。

    使用运算符typeof来检测参数的数据类型，使用if(!param)return;来判断是否存在该参数，因为js是一种无类型语言，所以你不能给函数的参数制定一个数据类型，而且js也不会检测传递的数据是不是那个函数所需要的类型，如果参数很重要时，就使用前面介绍的运算符进行检测。

    不可变参数js的处理：如果传递的参数比函数需要的个数多，那么多余的几个参数被忽略掉，如果传递的参数比函数需要的个数少，那么多余的几个参数就会被赋予undefined，在大多数情况下，这回使得函数产生错误。

2.嵌套函数

    a，函数定义中可以嵌套其他函数的定义，但是只能在在顶层全局代码和顶层函数代码中，不能出现在循环或条件语句中，并且这些限制只应用于由function语句声明的函数，函数直接量可以出现在任何js表达式中。

3.Function()构造函数

    可以使用Function()构造函数和new运算符动态地定义函数， var f = new Function("x","y","return x*y;");它等价于：function f(x,y){return x*y;}

    Function构造函数可以接受任意多个字符串参数，它的最后一个参数是函数的主体，其中可以包含任何js语句，语句之间用分号分隔。由于传递给构造函数Function()的参数中没有一个用于说明它要创建的函数名，用Function()构造函数创建的未命名函数有时被称作为“匿名函数”。

    Function()函数存在的意义：因为Function()构造函数允许我们动态地建立和编译一个函数，它不会将我们限制在function语句预编译的函数体中；另一个原因是它能将函数定义为js表达式的一部分，而不是将其定义为一个语句；缺点是：这样做每次调用一个函数时，Function()构造函数都要对它进行编译，

4.函数直接量

    函数直接量是一个表达式，它可以定义匿名函数。

    function f(x){return x*x;}                  //function语句

    var f = new Function("x","return x*x;");    //Function()构造函数

    var f = function(X){return x*x;};           //函数直接量

    虽然函数直接量创建的是未命名函数，但是它的语法也规定它可以指定函数名，这在编写调用自身的递归函数时特别的有用，e.g

var f= function fact(x){if(x<=1)return 1; else return x*fact(x-1);}

总结：function()函数可以任意的使用，具有通用性，Function()函数和函数直接量具有很多的相似性，他们都是未命名函数（函数直接量可以有函数名，尤其是在子调用函数中），函数直接量有个重要的有点，函数直接量只被解析和编译一次，而作为字符串传递给Function()构造函数的js代码则在每次调用构造函数时只需要被解析和编译一次。

函数最重要的特性就是他们能够被定义和调用，但是在js中函数并不只是一种语法，还可以是数据，可以把函数赋给变量、存储在对象的属性中或存储在数组的元素中，传递给函数。其实函数名并没有什么实际意义，它只是保存函数的变量的名字，可以将这个函数赋给其他的变量，它仍然以相同的方式起作用，

e.g    function square(x){x*x;}

var a = square(4);

var b = square;//这种情况下b引用的函数和square的作用相同

var c = b(5);

除了赋给全局变量之外，还可以将函数赋给对象的属性，这是称函数为方法;也可以赋给数组元素。

e.g

    var a =  new Object;     var a = new Object();

    a.square = new Function("x","return x*x";);

    y = o.square(16);

e.g   

    var a = new Array(3);

    a[0] = function(x){return x*x;};

    a[1] = 20;

    a[2] = a[0](a[1]);

    除这些之外，如何将函数作为参数传递给其他函数，

e.g

function  add(x,y){return x+y;}

function subtract(x,y){return x-y;}

function multiply(x,y){return x*y;}

function dibide(x,y){return x/y;}

function operate(operator,operand1,operand2){

    return operator(operand1,operand2);

}

var i = operate(add,operate(add,2,3),operate(multiply,4,5));

var operators = new Object();

operators["add"] = function(x,y){return x+y;}

operators["multiply"] = function(x,y){return x*y;}

operators["divide"] = function(x,y){return x/y;}

operators["pow"] = Math.pow;

function operate2(op_name,operand1,operand2){

    if(operators[op_name] == null)return "unknow operator";

    else    return operators[op_name](operand1,operand2);

}

var j = operate2('add',"hello",operate2("add","","world"));

var k = operate2('pow',10,2);

5.函数的作用域，调用对象

    函数的作用域中除了全局变量、函数内部的局部变量和形式参数外，函数还定义了一个特殊属性，

    arguments，这个属性应用了另外一个特殊的对象-----Arguments对象，因为arguments属性是调用对象的一个属性，所以它的状态和局部变量以及函数的形式参数是相同的。

    所以arguments标识符被看做是保留字，不能将它作为变量名或形式参数名。

6.Arguments对象

    arguments它具有特殊的意义，是调用对象的一个特殊属性，用来引用Arguments对象，Arguments对象就像数组，可以按照数字获取传递给函数的参数值，但是它并非真正的Array对象。

    arguments具有length属性，

    可以使用arguments来检测调用函数使用了正确数目的实际参数，

注意：arguments并非真正的数组，它是一个Arguments对象，Arguments对象有一个非同寻常的特征，当函数具有命名了的参数时，Arguments对象的数组元素是存放函数参数的局部变量的同义词。

e.g 

  function(x){

    alert(x);  //显示参数的初始值

    arguments[0] = null;//改变数组预算也会改变x

    alert(x);  //现在显示为“null”

除了数组元素，Arguments对象还定义了callee属性，用来引用当前正在执行的函数，这对未命名的函数调用自身非常有用。

e.g

 function(x){

    if(x<-1)return 1;

    return x*arguments.callee(x-1);

}

7.函数的属性和方法

    由于函数是对象，所以它具有数据和方法。

函数的length属性

    函数的属性length和arguments属性的length不同，arguments数组的length属性指定了传递给该函数的实际参数数目，并且arguments属性的length只在函数内部起作用，而函数自身的length属性它是只读的，返回的是函数需要的实际参数的数目，并且函数的属性length函数体的内部和外部都在是有效的。

函数的prototype属性

    每个函数都有一个prototype属性，它引用的是预定义的原型对象，原型对象在使用new运算符把函数作为构造函数时起作用。

函数自定义属性

    有时候定义全局变量比较乱，可以通过自定义函数属性来解决

函数的apply()和call()方法

    他们的第一个参数都是要调用的函数的对象，在函数体内这一参数是关键字this的值，call()的剩余参数是传递给要调用的函数的值，apply()的剩余参数是由数组指定的参数。

posted @ 2009-03-21 12:45 forgood 阅读(1082) | 评论 (0) | 编辑 收藏

漂亮代码七法

Java代码

1. 1 function findShape(flags, point, attribute, list) {   
2.   
3. 2    if(!findShapePoints(flags, point, attribute)) {   
4.   
5. 3        if(!doFindShapePoints(flags, point, attribute)) {   
6.   
7. 4            if(!findInShape(flags, point, attribute)) {   
8.   
9. 5                if(!findFromGuide(flags,point) {   
10.   
11. 6                    if(list.count() > 0 && flags == 1) {   
12.   
13. 7                          doSomething();   
14.   
15. 8                    }   
16.   
17. 9                }   
18.   
19. 10            }   
20.   
21. 11       }   
22.   
23. 12    }      
24.   
25. 13  }  

1 function findShape(flags, point, attribute, list) {
2    if(!findShapePoints(flags, point, attribute)) {
3        if(!doFindShapePoints(flags, point, attribute)) {
4            if(!findInShape(flags, point, attribute)) {
5                if(!findFromGuide(flags,point) {
6                    if(list.count() > 0 && flags == 1) {
7                          doSomething();
8                    }
9                }
10            }
11       }
12    }
13  }

Java代码

1. 1 function findShape(flags, point, attribute, list) {   
2.   
3. 2    if(findShapePoints(flags, point, attribute)) {   
4.   
5. 3        return;   
6.   
7. 4    }   
8.   
9. 5    
10.   
11. 6    if(doFindShapePoints(flags, point, attribute)) {   
12.   
13. 7        return;   
14.   
15. 8    }   
16.   
17. 9    
18.   
19. 10    if(findInShape(flags, point, attribute)) {    
20.   
21. 11        return;   
22.   
23. 12    }   
24.   
25. 13    
26.   
27. 14    if(findFromGuide(flags,point) {   
28.   
29. 15        return;   
30.   
31. 16    }   
32.   
33. 17    
34.   
35. 18    if (!(list.count() > 0 && flags == 1)) {   
36.   
37. 19        return;   
38.   
39. 20    }   
40.   
41. 21    
42.   
43. 22    doSomething();   
44.   
45. 23    
46.   
47. 24 }  

1 function findShape(flags, point, attribute, list) {
2    if(findShapePoints(flags, point, attribute)) {
3        return;
4    }
5
6    if(doFindShapePoints(flags, point, attribute)) {
7        return;
8    }
9
10    if(findInShape(flags, point, attribute)) {
11        return;
12    }
13
14    if(findFromGuide(flags,point) {
15        return;
16    }
17
18    if (!(list.count() > 0 && flags == 1)) {
19        return;
20    }
21
22    doSomething();
23
24 }

Java代码

1. 1 function isStringEmpty(str){   
2.   
3. 2    if(str === "") {    
4.   
5. 3        return true;   
6.   
7. 4    }   
8.   
9. 5    else {   
10.   
11. 6        return false;   
12.   
13. 7    }   
14.   
15. 8 }  

1 function isStringEmpty(str){
2    if(str === "") {
3        return true;
4    }
5    else {
6        return false;
7    }
8 }

Java代码

1. 1 function isStringEmpty(str){   
2.   
3. 2    return (str === "");   
4.   
5. 3 }  

1 function isStringEmpty(str){
2    return (str === "");
3 }

Java代码

1.  function getSomeAngle() {   
2.   
3. 2    // Some code here then   
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));   
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));   
8.   
9. 5    firstAngle = getStartAngle(radAngle1, point1, center);   
10.   
11. 6    secondAngle = getStartAngle(radAngle2, point2, center);   
12.   
13. 7    radAngle1 = degreesToRadians(firstAngle);   
14.   
15. 8    radAngle2 = degreesToRadians(secondAngle);   
16.   
17. 9    baseRadius = distance(point, center);   
18.   
19. 10    radius = baseRadius + (lines * y);   
20.   
21. 11    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);   
22.   
23. 12    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);   
24.   
25. 13    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);   
26.   
27. 14    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");   
28.   
29. 15    // Now some more code   
30.   
31. 16 }  

 function getSomeAngle() {
2    // Some code here then
3    radAngle1 = Math.atan(slope(center, point1));
4    radAngle2 = Math.atan(slope(center, point2));
5    firstAngle = getStartAngle(radAngle1, point1, center);
6    secondAngle = getStartAngle(radAngle2, point2, center);
7    radAngle1 = degreesToRadians(firstAngle);
8    radAngle2 = degreesToRadians(secondAngle);
9    baseRadius = distance(point, center);
10    radius = baseRadius + (lines * y);
11    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
12    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
13    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
14    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
15    // Now some more code
16 }

Java代码

1. 1 function getSomeAngle() {   
2.   
3. 2    // Some code here then   
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));   
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));   
8.   
9. 5    
10.   
11. 6    firstAngle = getStartAngle(radAngle1, point1, center);   
12.   
13. 7    secondAngle = getStartAngle(radAngle2, point2, center);   
14.   
15. 8    
16.   
17. 9    radAngle1 = degreesToRadians(firstAngle);   
18.   
19. 10    radAngle2 = degreesToRadians(secondAngle);   
20.   
21. 11    
22.   
23. 12    baseRadius = distance(point, center);   
24.   
25. 13    radius = baseRadius + (lines * y);   
26.   
27. 14    
28.   
29. 15    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);   
30.   
31. 16    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);   
32.   
33. 17    
34.   
35. 18    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);   
36.   
37. 19    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");   
38.   
39. 20    // Now some more code   
40.   
41. 21 }   
42.   
43.   
44.   
45. 4， 不要使用无谓的注释   
46.   
47. 无谓的注释让人费神，这实在很讨厌。不要标出很明显的注释。在以下的例子中，每个人都知道代码表达的是“students id”，因而没必要标出。   
48.   
49. 1 function existsStudent(id, list) {   
50.   
51. 2    for(i = 0; i < list.length; i++) {   
52.   
53. 3       student = list[i];   
54.   
55. 4    
56.   
57. 5       // Get the student's id   
58.   
59. 6       thisId = student.getId();   
60.   
61. 7    
62.   
63. 8       if(thisId === id) {   
64.   
65. 9           return true;   
66.   
67. 10       }   
68.   
69. 11    }   
70.   
71. 12    return false;      
72.   
73. 13 }  

1 function getSomeAngle() {
2    // Some code here then
3    radAngle1 = Math.atan(slope(center, point1));
4    radAngle2 = Math.atan(slope(center, point2));
5
6    firstAngle = getStartAngle(radAngle1, point1, center);
7    secondAngle = getStartAngle(radAngle2, point2, center);
8
9    radAngle1 = degreesToRadians(firstAngle);
10    radAngle2 = degreesToRadians(secondAngle);
11
12    baseRadius = distance(point, center);
13    radius = baseRadius + (lines * y);
14
15    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
16    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
17
18    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
19    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
20    // Now some more code
21 }
4， 不要使用无谓的注释
无谓的注释让人费神，这实在很讨厌。不要标出很明显的注释。在以下的例子中，每个人都知道代码表达的是“students id”，因而没必要标出。
1 function existsStudent(id, list) {
2    for(i = 0; i < list.length; i++) {
3       student = list[i];
4
5       // Get the student's id
6       thisId = student.getId();
7
8       if(thisId === id) {
9           return true;
10       }
11    }
12    return false;
13 }

Java代码

1. //function thisReallyHandyFunction() {   
2.   
3. //      someMagic();   
4.   
5. //      someMoreMagic();   
6.   
7. //      magicNumber = evenMoreMagic();   
8.   
9. //      return magicNumber;   
10.   
11. //}  

//function thisReallyHandyFunction() {
//      someMagic();
//      someMoreMagic();
//      magicNumber = evenMoreMagic();
//      return magicNumber;
//}

Java代码

1. 1 public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {   
2.   
3. 2        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);   
4.   
5. 3    
6.   
7. 4        for(Category cat : Category.values()) {   
8.   
9. 5            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));   
10.   
11. 6        }  

1 public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {
2        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);
3
4        for(Category cat : Category.values()) {
5            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));
6        }

posted @ 2009-01-18 14:33 forgood 阅读(213) | 评论 (0) | 编辑 收藏

反射机制补充

package chb.test.reflect;
            public class Student {
            private int age;
            private String name;
            public int getAge() {
            return age;
            }
            public void setAge(int age) {
            this.age = age;
            }
            public String getName() {
            return name;
            }
            public void setName(String name) {
            this.name = name;
            }
            public static void hi(int age,String name){
            System.out.println("大家好，我叫"+name+"，今年"+age+"岁");
            }
            }
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Method m = cls.getDeclaredMethod("hi",new Class[]{int.class,String.class});
            m.invoke(cls.newInstance(),20,"chb");
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Method setMethod = cls.getDeclaredMethod("setAge",int.class);
            setMethod.invoke(cls.newInstance(), 15);
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Method setMethod = cls.getDeclaredMethod("setAge",Integer.class);
            setMethod.invoke(cls.newInstance(), 15);
            
 
            

java.lang.NoSuchMethodException: chb.test.reflect.Student.setAge(java.lang.Integer)
            at java.lang.Class.getDeclaredMethod(Unknown Source)
            at chb.test.reflect.TestClass.testReflect(TestClass.java:23)
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Method staticMethod = cls.getDeclaredMethod("hi",int.class,String.class);
            staticMethod.invoke(cls,20,"chb");//这里不需要newInstance
            //staticMethod.invoke(cls.newInstance(),20,"chb");
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Object student = cls.newInstance();//得到一个实例
            Field field = cls.getDeclaredField("age");
            field.set(student, 10);
            System.out.println(field.get(student));
            
 
            

java.lang.IllegalAccessException: Class chb.test.reflect.TestClass can not access a member of class chb.test.reflect.Student with modifiers "private"
            at sun.reflect.Reflection.ensureMemberAccess(Unknown Source)
            at java.lang.reflect.Field.doSecurityCheck(Unknown Source)
            at java.lang.reflect.Field.getFieldAccessor(Unknown Source)
            at java.lang.reflect.Field.set(Unknown Source)
            at chb.test.reflect.TestClass.testReflect(TestClass.java:20)
            
 
            

Class cls = Class.forName("chb.test.reflect.Student");
            Object student = cls.newInstance();
            Field field = cls.getDeclaredField("age");
            field.setAccessible(true);//设置允许访问
            field.set(student, 10);
            System.out.println(field.get(student));
            
 
            

posted @ 2009-01-11 17:28 forgood 阅读(1195) | 评论 (1) | 编辑 收藏

java中的反射机制

1. Class cls = Class.forName("chb.test.reflect.Student");   
2. Method m = cls.getDeclaredMethod("方法名",new Class[]{int.class,String.class});   
3. m.invoke(cls.newInstance(),20,"chb");

package com.inspur.reflect;

import java.lang.reflect.Method;

public class Methodtest1 {
 
 
 private int abc(Object p,int x) throws NullPointerException{
  if(p==null)throw new NullPointerException();
  return x;
 }

 public static void main(String[] args) {
  
  try{
   Class cls = Class.forName("com.inspur.reflect.Methodtest1");
   Method methodlist[]= cls.getDeclaredMethods();
   for(int i = 0;i<methodlist.length;i++){
    Method m = methodlist[i];
    System.out.println("name=="+m.getName());//得到方法的名称
    System.out.println("decl class=="+m.getDeclaringClass());//得到定义的类名
    Class prev[] = m.getParameterTypes();   //取m方法中的所有参数
    //遍历所有的参数
    for(int j = 0; j<prev.length;j++){
     System.out.println("param["+j+"]=="+prev[j]);
    }
    Class exec[] = m.getExceptionTypes(); //得到所有的异常
    //遍历所有的异常
    for(int k=0;k<exec.length;k++){
     System.out.println("execption["+k+"]=="+exec[k]);
    }
   
    Class ret = m.getReturnType(); //得到每个方法的返回值
    System.out.println("return leixing=="+ret.toString()); 
   }
  }catch(Throwable e){
   System.err.println(e.getMessage());
  }
 }

}

posted @ 2009-01-11 17:27 forgood 阅读(234) | 评论 (0) | 编辑 收藏

oracle中sql优化

posted @ 2008-12-13 23:14 forgood 阅读(190) | 评论 (0) | 编辑 收藏

Spring和Struts整合的三种方式

1，使用Spring 的 ActionSupport

2，使用Spring 的 DelegatingRequestProcessor 类。

3，全权委托。

无论用那种方法来整合第一步就是要为struts来装载spring的应用环境。 就是在 struts 中加入一个插件。

struts-config.xml中

＜plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"＞
            ＜set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/＞
            ＜/plug-in＞

spring 的配置文件被作为参数配置进来。这样可以省略对web.xml 文件中的配置。确保你的applicationContext.xml 在WEB-INF目录下面

1、使用Spring的ActionSupport .

Spring 的ActionSupport 继承至org.apache.struts.action.Action

ActionSupport的子类可以或得 WebApplicationContext类型的全局变量。通过getWebApplicationContext（）可以获得这个变量。

这是一个 servlet 的代码：

public class LoginAction extends org.springframework.web.struts.ActionSupport {
            public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) {
            LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
            //获得  WebApplicationContext  对象
            WebApplicationContext ctx = this.getWebApplicationContext();
            LoginDao dao = (LoginDao) ctx.getBean("loginDao");
            User u = new User();
            u.setName(loginForm.getName());
            u.setPwd(loginForm.getPwd());
            if(dao.checkLogin(u)){
            return mapping.findForward("success");
            }else{
            return  mapping.findForward("error");
            }
            }
            }
            applicationContext.xml 中的配置
            ＜beans＞
            ＜bean id="loginDao" class="com.cao.dao.LoginDao"/＞
            ＜/beans＞
            

这中配置方式同直接在web.xml文件配置差别不大。

注意：Action继承自 org.springframework.web.struts.ActionSupport 使得struts和spring耦合在一起。

但实现了表示层和业务逻辑层的解耦（LoginDao dao = （LoginDao） ctx.getBean（"loginDao"））。

2、使用Spring 的 DelegatingRequestProcessor 类

DelegatingRequestProcessor  继承自 org.apache.struts.action.RequestProcessor 并覆盖了里面的方法。

sturts-config.xml  中 

processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/> 通过 来替代

org.apache.struts.action.RequestProcessor 的请求处理。

public class LoginAction extends Action {
            //利用spring来注入这个对象。
            private LoginDao dao ;
            public void setDao(LoginDao dao) {
            System.out.println("执行注入");
            this.dao = dao;
            }
            public LoginDao getDao() {
            return dao;
            }
            public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) {
            LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
            //这样一改这行代码似乎没有必要了。
            //WebApplicationContext ctx = this.getWebApplicationContext();
            //LoginDao dao = (LoginDao) ctx.getBean("loginDao");
            User u = new User();
            u.setName(loginForm.getName());
            u.setPwd(loginForm.getPwd());
            //直接用dao来调用spring会将这个对象实例化。
            if(dao.checkLogin(u)){
            return mapping.findForward("success");
            }else{
            return  mapping.findForward("error");
            }
            }
            }
            这里的。
            LoginAction extends Action 说明 struts没有和spring 耦合。
            看一下
            applicationContext.xml 中的配置。
            ＜beans＞
            ＜bean id="loginDao" class="com.cao.dao.LoginDao"/＞
            ＜bean name="/login" class="com.cao.struts.action.LoginAction"＞
            ＜property name="dao"＞
            ＜ref local="loginDao"/＞
            ＜/property＞
            ＜/bean＞
            ＜/beans＞
            

这里 name="/login" 与struts 中的path匹配

class="com.cao.struts.action.LoginAction" 与struts 中的type匹配

还要为 LoginAction 提供必要的setXXX方法。 获得ApplicationCotext和依赖注入的工作都在DelegatingRequestProcessor中完成。

3，全权委托：

Action 的创建和对象的依赖注入全部由IOC容器来完成。使用Spring的DelegatingAcionProxy来帮助实现代理的工作

org.springframework.web.struts.DelegatingActiongProxy继承于org.apache.struts.action.Action .

全权委托的配置方式同 方式 2 类似 （applcationContext.xml文件的配置和 Action类的实现方式相同）。

＜struts-config＞
            ＜data-sources /＞
            ＜form-beans ＞
            ＜form-bean name="loginForm" 

  type="com.cao.struts.form.LoginForm" /＞
            ＜/form-beans＞
            ＜global-exceptions /＞
            ＜global-forwards /＞
            ＜action-mappings ＞
            ＜!-- type指向的是spring 的代理类 --＞
            ＜action
            attribute="loginForm"
            input="login.jsp"
            name="loginForm"
            path="/login"
            scope="request"
            type="org.springframework.web.struts.DelegatingActionProxy" ＞
            ＜forward name="success" path="/ok.jsp" /＞
            ＜forward name="error" path="/error.jsp" /＞
            ＜/action＞
            ＜/action-mappings＞
            ＜message-resources parameter="com.cao.struts.ApplicationResources" /＞
            ＜plug-in className=

 "org.springframework.web.struts.ContextLoaderPlugIn"＞
            ＜set-property property="contextConfigLocation" 

  value="/WEB-INF/applicationContext.xml"/＞
            ＜/plug-in＞
            ＜/struts-config＞
            不同之处
            1， ＜action＞中 type指向的是spring 的代理类
            2， 去掉struts-config.xml中 ＜controller ＞
            

三种整和方式中我们优先选用 全权委托的方式。

理由：

1，第一种使得过多的耦合了Spring和Action .

2，RequestProcessor类已经被代理 如果要再实现自己的实现方式（如：编码处理）怕有点麻烦。

总结一下：

整合工作中的步骤：

1，修改struts-config.xml

2， 配置applicationContext.xml

3， 为Action添加get/set方法 来获得依赖注入的功能。

posted @ 2008-12-08 17:00 forgood 阅读(158) | 评论 (0) | 编辑 收藏

jQuery_AJAX学习

posted @ 2008-12-03 00:03 forgood 阅读(190) | 评论 (0) | 编辑 收藏

jquery API学习（2）

<button>Change colors</button>
<span></span>
<div></div>
<div></div>
<div></div>
<div></div>
<div id="stop">Stop here</div>
<div></div>
<div></div>
<div></div>

posted @ 2008-12-02 23:56 forgood 阅读(793) | 评论 (0) | 编辑 收藏

java和jsp中文件上传

jsp文件上传大多采用采用开源项目来简化处理，这里列出常用的两个jar包的实现，并进行比较，说明他们的优缺点和应该注意的问题。

 Commons FileUpload，可以在http://jakarta.apache.org/commons/fileupload/下载，这个包需要Commons IO的支持，可以在http://jakarta.apache.org/commons/io/下载

 com.oreilly.servlet，可以在http://www.servlets.com/cos/下载
Commons FileUpload提供三种文件上传处理方式，DiskFileUpload、ServletFileUpload和PortletFileUpload三种方式，其中DiskFileUpload已经在javadoc下已经被标记为过期的方法，建议用ServletFileUpload代替，而PortletFileUpload需要配合portlet-api来使用，所以这里我们只介绍ServletFileUpload，并且这个也是最常用的。

com.oreilly.servlet也提供了三种文件上传的处理方式，MultipartWrapper、MultipartRequest和MultipartParser三种方式，其中MultipartWrapper和MultipartRequest的用法基本相同，并且没有MultipartRequest提供的操作多，所以这里介绍MultipartRequest，MultipartParser和前两者有些不同，可以用来处理某些特殊情况，例如表单中有两个同名的文件上传选择框。

我们暂时称三面三种文件上传方式分别为：ServletFileUpload方式（MultipartTestServlet）、MultipartRequest方式（MultipartTestServlet2）、MultipartParser方式（MultipartTestServlet3）

代码如下：
test.html

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gbk" pageEncoding="gbk"%>
<html>
  <body>
    <form action="MultipartTestServlet" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
    <br/><br/><br/><br/>
    <form action="MultipartTestServlet2" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
    <br/><br/><br/><br/>
    <form action="MultipartTestServlet3" enctype="multipart/form-data" method="post">
     <input type="text" name="username" /><br />
     <input type="file" name="myfile" /><br/>
     <input type="file" name="myfile" /><br/>
     <input type="submit" />
    </form>
  </body>
</html>
MultipartTestServlet.java

package com.bug.servlet;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

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

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUpload;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;

public class MultipartTestServlet extends HttpServlet {

 public MultipartTestServlet() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  request.setCharacterEncoding("gbk");
  RequestContext requestContext = new ServletRequestContext(request);
 
  if(FileUpload.isMultipartContent(requestContext)){
  
   DiskFileItemFactory factory = new DiskFileItemFactory();
   factory.setRepository(new File("c:/tmp/"));
   ServletFileUpload upload = new ServletFileUpload(factory);
   //upload.setHeaderEncoding("gbk");
   upload.setSizeMax(2000000);
   List items = new ArrayList();
    try {
     items = upload.parseRequest(request);
    } catch (FileUploadException e1) {
     System.out.println("文件上传发生错误" + e1.getMessage());
    }

   Iterator it = items.iterator();
   while(it.hasNext()){
    FileItem fileItem = (FileItem) it.next();
    if(fileItem.isFormField()){     
     System.out.println(fileItem.getFieldName() + "   " + fileItem.getName() + "   " + new String(fileItem.getString().getBytes("iso8859-1"), "gbk"));
    }else{
     System.out.println(fileItem.getFieldName() + "   " +
        fileItem.getName() + "   " +
        fileItem.isInMemory() + "    " +
        fileItem.getContentType() + "   " +
        fileItem.getSize());
    
     if(fileItem.getName()!=null && fileItem.getSize()!=0){
      File fullFile = new File(fileItem.getName());
      File newFile = new File("c:/temp/" + fullFile.getName());
      try {
       fileItem.write(newFile);
      } catch (Exception e) {
       e.printStackTrace();
      }
     }else{
      System.out.println("文件没有选择 或 文件内容为空");
     }
    }
    
   }
  }
 }

}

MultipartTestServlet2.java

package com.bug.servlet;

import java.io.IOException;
import java.util.Enumeration;

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

import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;

public class MultipartTestServlet2 extends HttpServlet {

 public MultipartTestServlet2() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

  //request.setCharacterEncoding("gbk");  不起作用
  System.out.println("start ");
  MultipartRequest multi = new MultipartRequest(request, "c:/tmp/", 2*1024*1024, "gbk", new DefaultFileRenamePolicy());
  System.out.println("start ");
  Enumeration filesName = multi.getFileNames();
  Enumeration paramsName = multi.getParameterNames();
  while(paramsName.hasMoreElements()){
   String paramName = (String) paramsName.nextElement();
   System.out.println(multi.getParameter(paramName));
  }
  while(filesName.hasMoreElements()){
   String fileName = (String) filesName.nextElement();
   System.out.println(multi.getFilesystemName(fileName) + "  " +
          multi.getOriginalFileName(fileName) + "  " +
          multi.getContentType(fileName) + "  ");
   if(multi.getFilesystemName(fileName)!=null && !multi.getFilesystemName(fileName).equals(""))
    System.out.println(multi.getFile(fileName).toURI());
  }
 }
 
}

MultipartTestServlet3.java

package com.bug.servlet;

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.oreilly.servlet.multipart.FilePart;
import com.oreilly.servlet.multipart.MultipartParser;
import com.oreilly.servlet.multipart.ParamPart;
import com.oreilly.servlet.multipart.Part;

public class MultipartTestServlet3 extends HttpServlet {

 public MultipartTestServlet3() {
  super();
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {

      MultipartParser mp = new MultipartParser(request, 2*1024*1024, false, false, "gbk");
      Part part;
      while ((part = mp.readNextPart()) != null) {
        String name = part.getName();
        if (part.isParam()) {
          ParamPart paramPart = (ParamPart) part;
          String value = paramPart.getStringValue();
          System.out.println("param: name=" + name + "; value=" + value);
        }
        else if (part.isFile()) {
          // it's a file part
          FilePart filePart = (FilePart) part;
          String fileName = filePart.getFileName();
          if (fileName != null) {
            long size = filePart.writeTo(new File("c:/tmp/"));
            System.out.println("file: name=" + name + "; fileName=" + fileName +
              ", filePath=" + filePart.getFilePath() +
              ", contentType=" + filePart.getContentType() +
              ", size=" + size);
          }
          else {
           System.out.println("file: name=" + name + "; EMPTY");
          }
          System.out.flush();
        }
      }
    }

}

web.xml中加入

 <servlet>
    <servlet-name>MultipartTestServlet</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>MultipartTestServlet2</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet2</servlet-class>
  </servlet>
  <servlet>
    <servlet-name>MultipartTestServlet3</servlet-name>
    <servlet-class>com.bug.servlet.MultipartTestServlet3</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet</servlet-name>
    <url-pattern>/MultipartTestServlet</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet2</servlet-name>
    <url-pattern>/MultipartTestServlet2</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>MultipartTestServlet3</servlet-name>
    <url-pattern>/MultipartTestServlet3</url-pattern>
  </servlet-mapping>

问题1、中文问题：
 三种凡是都可以通过自己的方法来设置encoding为gbk开处理和解决中文问题，包括初始化的时候传入gbk作为参数，或是是初始化后通过setEncoding的方式来实现。
 另外ServletFileUpload方式也可以通过request.setCharacterEncoding("gbk");的方式来实现，而其它两种方式不支持这种方式。

问题2、文件大小限制
 ServletFileUpload方式可以设置文件大小限制，也可以不用设置，例子中的upload.setSizeMax(2000000)就可以注释掉。如果设置upload.setSizeMax(-1)，表明不限制上传的大小。文档中没有指明默认的限制的多少，我在不设置的情况下上传了一个9M的东西，可以上传，估计默认是不限制大小的。
 而MultipartRequest方式和MultipartParser方式是必须设置文件的上传文件的大小限制的，如果不设置，默认是1M的大小限制。

问题3、文件上传发生错误
 如果文件上传过程中发生任何错误，或者是文件的大小超出了范围，系统都将抛出错误。
 ServletFileUpload方式在upload.parseRequest(request)时抛出错误
 MultipartRequest方式在new MultipartRequest(。。。)时抛出错误
 MultipartParser方式在new MultipartParser(。。。)时抛出错误

问题4、上传同名文件时，他们保存到临时目录是的冲突问题
 ServletFileUpload方式，不会有冲突，系统会把上传得文件按照一定的规则重新命名，保证不会冲突
 MultipartParser方式，会产生冲突，系统会把文件按照上传时的文件名，保存到临时目录下，如果两个用会同时上传文件名相同的文件，那么就可能会产生冲突，一方把另一方的临时文件给替换了。
 MultipartRequest方式，在初始化时如果提供了一个名称转换策略，就不会有冲突，如果不提桶，就会有冲突。在上面的例子中我们提供了一个new DefaultFileRenamePolicy()保证了文件名不会有冲突发生。

问题5：表单中有两个同名的文件上传选择框，就像我们例子中的myfile一样，每个表单中有两个name=“myfile”的上传框
 ServletFileUpload方式，可以处理，可以分别得到他们各自的文件，
 MultipartRequest方式，不可以处理，会发生冲突，会有一个上传框的文件覆盖了另外一个。
 MultipartParser方式，可以处理，可以分别得到他们各自的文件，

备注：
 代码比较乱，主要是为了说明他们间的区别。他们的详细地使用说明还是要参考他的javadoc和domo。

参考：
 1、http://www.servlets.com/cos/#classes
 2、http://jakarta.apache.org/commons/fileupload/apidocs/index.html
 3、http://jakarta.apache.org/commons/fileupload/using.html
 4、http://www.onjava.com/pub/a/onjava/2003/06/25/commons.html?page=3

posted @ 2008-12-01 18:19 forgood 阅读(596) | 评论 (0) | 编辑 收藏

oracle中的锁表语句

posted @ 2008-12-01 11:47 forgood 阅读(586) | 评论 (0) | 编辑 收藏

jquery API学习（1）

posted @ 2008-11-30 15:48 forgood 阅读(554) | 评论 (0) | 编辑 收藏

jquery学习网站

posted @ 2008-11-30 14:40 forgood 阅读(195) | 评论 (1) | 编辑 收藏

Java栈与堆

posted @ 2008-11-30 14:29 forgood 阅读(176) | 评论 (0) | 编辑 收藏

java中压缩与解压缩的实现

posted @ 2008-09-16 20:52 forgood 阅读(169) | 评论 (0) | 编辑 收藏

JAVA解析XML配置文件的读取操作

    在apache的XML项目组中，目前有Xerces Xalan Cocoon几个开发XML相关技术的project.Tomcat本身使用的是 Sun 的 JAXP，而其XSL Taglib project中使用Xerces解析器。

    好了，上面都是比较烦人的理论问题，还是赶快切入XML的配置文件的读取吧。

    在我们的程序中，通常要有一些根据主机环境确定的变量。比如数据库访问用户名和密码，不同的主机可能设置不一样。只要更改XML配置文件，就可以正常运行。


localhost
sqlname
username
password

    上面这个myenv.xml配置文件一般是放在tomcat的WEB-INF/classes目录下.

    我们编制一个Java程序直接读取,将dbhost dbuser dbpassword提取出来供其他程序访问数据库用.

    目前使用SAX比较的多,与DOM主要区别是 SAX是一行一行读取XML文件进行分析,适合比较大文件,DOM是一次性读入内存,显然不能对付大文件.这里我们使用SAX解析,由于SAX解析器不断在发展,网上有不少文章是针对老版本的.如果你使用JDK1.4 ,可以参考 使用SAX处理XML文档 一文.这里的程序是根据其改进并且经过实践调试得来的.

对上面myenv.xml读取的Java程序:


import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.SAXException;
import java.util.Properties;

//使用DefaultHandler的好处 是 不必陈列出所有方法,
public class ConfigParser extends DefaultHandler {

////定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;

private String currentSet;
private String currentName;
private StringBuffer currentValue = new StringBuffer();

//构建器初始化props
public ConfigParser() {

this.props = new Properties();
}

public Properties getProps() {
return this.props;
}

//定义开始解析元素的方法. 这里是将 中的名称xxx提取出来.
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
currentValue.delete(0, currentValue.length());
this.currentName =qName;

}

//这里是将 之间的值加入到currentValue

public void characters(char[] ch, int start, int length) throws SAXException {

currentValue.append(ch, start, length);

}

//在遇到 结束后,将之前的名称和值一一对应保存在props中

public void endElement(String uri, String localName, String qName) throws SAXException {

props.put(qName.toLowerCase(), currentValue.toString().trim());
}

}

    上面的这个解析程序比较简单吧? 其实解析XML就是这么简单.

    现在我们已经将dbhost dbuser dbpassword的值localhost sqlname username password提取了出来.但是这只是在在解析器内部,我们的程序还不能访问.需要再编制一个程序.


import java.util.Properties;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.net.URL;

public class ParseXML{

//定义一个Properties 用来存放 dbhost dbuser dbpassword的值
private Properties props;

//这里的props
public Properties getProps() {
return this.props;
}

public void parse(String filename) throws Exception {

//将我们的解析器对象化
ConfigParser handler = new ConfigParser();

//获取SAX工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);

//获取SAX解析
SAXParser parser = factory.newSAXParser();

//得到配置文件myenv.xml所在目录. tomcat中是在WEB-INF/classes
//下例中BeansConstants是用来存放xml文件中配置信息的类,可以自己代替或定义
URL confURL = BeansConstants.class.getClassLoader().getResource(filename);

try
{
//将解析器和解析对象myenv.xml联系起来,开始解析
parser.parse(confURL.toString(), handler);
//获取解析成功后的属性 以后 我们其他应用程序只要调用本程序的props就可以提取出属性名称和值了
props = handler.getProps();
}finally{
factory=null;
parser=null;
handler=null;
}

}

}

    由于我们的XML文件是使用最简单的形式 ,因此解析器相对简单,但是这已经足够对付我们的配置文件了.

    判断一个程序系统的先进性,我们先看看他的配置文件,如果还在使用老套的xxx=123 这样类似.ini的文件,

posted @ 2008-09-09 12:49 forgood 阅读(385) | 评论 (0) | 编辑 收藏

怎么得到ucs2字符串中制定位数

posted @ 2008-09-08 23:02 forgood 阅读(312) | 评论 (0) | 编辑 收藏