语源科技BlogJava-airwalk的成长空间

target

airwalk — Sun, 02 Sep 2007 11:39:00 GMT

是将基本链接的目标框架都改为新页打开，如果对HTML、CSS和JS不是很熟悉，不建议使用这种方法，改为独立控制。

其实、

如果不加这一句，默认均为本页刷新，即target="_self"。

airwalk 2007-09-02 19:39 发表评论

String与StringBuffer

airwalk — Fri, 31 Aug 2007 09:21:00 GMT

2006年11月21日星期二 16:25

String的创建

String s = "hello";
JVM先根据内容"hello"查找对象，如果没有找到，则在heap上创建新对象，并将其赋予s1，否则使用已经存在的对象

String s = new String("hello");
JVM直接在heap上创建新的对象，所以在heap中会出现内容相同，地址不同的String对象

String的比较

"==" 比较地址
"equals" 比较内容

举例:
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

s1 == s2;               // true        地址相同
s1 == s3;               // false       地址不同
s1.equals(s2);          // true        内容相同
s1.equals(s3);          // true        内容相同

intern() 方法

查找内容相同(equals())的字符串

   String s1 = "hello";                // hello不存在，jvm创建新对象 (1)
   String s2 = new String("hello");    // 创举新对象 (2)，这时heap中存在两个内容为hello的对象
   s1 == s2;           // false        // 地址不同
   s1.equals(s2);      // true         // 内容相同
   s2 = s2.intern();   // true         // 找到对象(1) 并赋予s2
   s1 == s2;           // true !!      // 注意：此时s1,s2同指向(1)

效率：String 与 StringBuffer

    情景1：
    (1) String result = "hello" + " world";
    (2) StringBuffer result = new String().append("hello").append(" world");

        (1) 的效率好于 (2)，不要奇怪，这是因为JVM会做如下处理
        编译前   String result = "hello" + " world";
        编译后   String result = "hello world";

    情景2：
    (1) public String getString(String s1, String s2) {
            return s1 + s2;
        }
    (2) public String getString(String s1, String s2) {
            return new StringBuffer().append(s1).append(s2);
        }

        (1) 的效率与 (2) 一样，这是因为JVM会做如下处理
        编译前   return s1 + s2;
        编译后   return new StringBuffer().append(s1).append(s2);

    情景3：
    (1) String s = "s1";
              s += "s2";
              s += "s3";
    (2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

(2) 的效率好于(1)，因为String是不可变对象，每次"+="操作都会造成构造新的String对象

    情景4：
    (1) StringBuffer s = new StringBuffer();
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }
    (2) StringBuffer s = new StringBuffer(250000);
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }

        (2) 的效率好于 (1)，因为StringBuffer内部实现是char数组，默认初始化长度为16，每当字符串长度大于char
        数组长度的时候，JVM会构造更大的新数组，并将原先的数组内容复制到新数组，(2)避免了复制数组的开销

关键点
    1). 简单的认为 .append() 效率好于 "+" 是错误的！
    2). 不要使用 new 创建 String
    3). 注意 .intern() 的使用
    4). 在编译期能够确定字符串值的情况下，使用"+"效率最高
    5). 避免使用 "+=" 来构造字符串
    6). 在声明StringBuffer对象的时候，指定合适的capacity，不要使用默认值(18)
    7). 注意以下二者的区别不一样
        - String s = "a" + "b";
        - String s = "a";
          s += "b";

String和StringBuffer之概览
　　创建字符串的较佳途径
　　滞留字符串带来的优化
　　连接字符串时的优化技巧
　　借助StringBuffer的初始化过程的优化技巧
　　关键点

String和StringBuffer之概览
　　非可变对象一旦创建之后就不能再被改变，可变对象则可以在创建之后被改变。String对象是非可变对象，StringBuffer对象则是可变对象。为获得更佳的性能你需要根据实际情况小心谨慎地选择到底使用这两者中的某一个。下面的话题会作详细的阐述。（注意：这个章节假设读者已经具备Java的String和StringBuffer的相关基础知识。）

创建字符串的较佳途径

你可以按照以下方式创建字符串对象：
1. String s1 = "hello";
String s2 = "hello";
2. String s3 = new String("hello");
String s4 = new String("hello");

上面哪种方式会带来更好的性能呢？下面的代码片断用来测量二者之间的区别。

StringTest1.java

package com.performance.string;

/** This class shows the time taken for creation of
* String literals and String objects.
*/

public class StringTest1 {

public static void main(String[] args){

    // create String literals
    long startTime = System.currentTimeMillis();
    for(int i=0;i<50000;i++){

    String s1 = "hello";
    String s2 = "hello";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                  + (endTime - startTime) + " milli seconds" );

    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<50000;i++){

    String s3 = new String("hello");
    String s4 = new String("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects : "
                  + (endTime1 - startTime1)+" milli seconds");
    }
}
这段代码的输出：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects : 170 milli seconds

JVM是怎样处理字符串的呢？
　　Java虚拟机会维护一个内部的滞留字符串对象的列表（唯一字符串的池）来避免在堆内存中产生重复的String对象。当JVM从class文件里加载字符串字面量并执行的时候，它会先检查一下当前的字符串是否已经存在于滞留字符串列表，如果已经存在，那就不会再创建一个新的String对象而是将引用指向已经存在的String对象，JVM会在内部为字符串字面量作这种检查，但并不会为通过new关键字创建的String对象作这种检查。当然你可以明确地使用String.intern()方法强制JVM为通过new关键字创建的String对象作这样的检查。这样可以强制JVM检查内部列表而使用已有的String对象。

　　所以结论是，JVM会内在地为字符串字面量维护一些唯一的String对象，程序员不需要为字符串字面量而发愁，但是可能会被一些通过new关键字创建的String对象而困扰，不过他们可以使用intern()方法来避免在堆内存上创建重复的String对象来改善Java的运行性能。下一小节会向大家展示更多的信息。

下图展示了未使用intern()方法来创建字符串的情况。

　　你可以自己使用==操作符和String.equals()方法来编码测试上面提到的区别。==操作符会返回true如果一些引用指向一个相同的对象但不会判断String对象的内容是否相同；String.equals()方法会返回true如果被操作的String对象的内容相同。对于上面的代码会有s1==s2，因为s1和s2两个引用指向同一个对象，对于上面的代码，s3.equals(s4)会返回true因为两个对象的内容都一样为”hello”。你可以从上图看出这种机制。在这里有三个独立的包含了相同的内容（”hello”）的对象，实际上我们不需要这么三个独立的对象――因为要运行它们的话既浪费时间又浪费内存。

　　那么怎样才能确保String对象不会重复呢？下一个话题会涵盖对于内建String机制的兴趣。

滞留字符串的优化作用
　　同一个字符串对象被重复地创建是不必要的，String.intern()方法可以避免这种情况。下图说明了String.intern()方法是如何工作的，String.intern()方法检查字符串对象的存在性，如果需要的字符串对象已经存在，那么它会将引用指向已经存在的字符串对象而不是重新创建一个。下图描绘了使用了intern()方法的字符串字面量和字符串对象的创建情况。

下面的例程帮助大家了解String.intern()方法的重要性。
StringTest2.java

package com.performance.string;

// This class shows the use of intern() method to improve performance
public class StringTest2 {

public static void main(String[] args){

    // create String references like s1,s2,s3...so on..
    String variables[] = new String[50000];
    for( int i=0;i         variables[i] = "s"+i;
    }

    // create String literals
    long startTime0 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = "hello";
    }

    long endTime0 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                         + (endTime0 - startTime0) + " milli seconds" );

    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = new String("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with 'new' key word : "
                        + (endTime1 - startTime1)+" milli seconds");

    // intern String objects with intern() method
    long startTime2 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = new String("hello");
        variables[i] = variables[i].intern();
    }

    long endTime2 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with intern(): "
                        + (endTime2 - startTime2)+" milli seconds");
    }
}

这是上面那段代码的输出结果：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects with 'new' key word : 160 milli seconds
Time taken for creation of String objects with intern(): 60 milli seconds

连接字符串时候的优化技巧
　　你可以使用+操作符或者String.concat()或者StringBuffer.append()等办法来连接多个字符串，那一种办法具有最佳的性能呢？

　　如何作出选择取决于两种情景，第一种情景是需要连接的字符串是在编译期决定的还是在运行期决定的，第二种情景是你使用的是StringBuffer还是String。通常程序员会认为StringBuffer.append()方法会优于+操作符或String.concat()方法，但是在一些特定的情况下这个假想是不成立的。

1) 第一种情景：编译期决定相对于运行期决定
请看下面的StringTest3.java代码和输出结果。

package com.performance.string;

/** This class shows the time taken by string concatenation at compile time and run time.*/
public class StringTest3 {

public static void main(String[] args){
    //Test the String Concatination
    long startTime = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    String result = "This is"+ "testing the"+ "difference"+ "between"+
            "String"+ "and"+ "StringBuffer";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
         + (endTime - startTime)+ " milli seconds");

    //Test the StringBuffer Concatination
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    StringBuffer result = new StringBuffer();
         result.append("This is");
        result.append("testing the");
        result.append("difference");
        result.append("between");
       result.append("String");
       result.append("and");
       result.append("StringBuffer");
     }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for String concatenation using StringBuffer : "
           + (endTime1 - startTime1)+ " milli seconds");
}
}
这是上面的代码的输出结果：
Time taken for String concatenation using + operator : 0 milli seconds
Time taken for String concatenation using StringBuffer : 50 milli seconds
很有趣地，+操作符居然比StringBuffer.append()方法要快，为什么呢？

　　这里编译器的优化起了关键作用，编译器像下面举例的那样简单地在编译期连接多个字符串。它使用编译期决定取代运行期决定，在你使用new关键字来创建String对象的时候也是如此。

编译前：
String result = "This is"+"testing the"+"difference"+"between"+"String"+"and"+"StringBuffer";
编译后：
String result = "This is testing the difference between String and StringBuffer";

这里String对象在编译期就决定了而StringBuffer对象是在运行期决定的。运行期决定需要额外的开销当字符串的值无法预先知道的时候，编译期决定作用于字符串的值可以预先知道的时候，下面是一个例子。

编译前：
public String getString(String str1,String str2) {
return str1+str2;
}
编译后：
return new StringBuffer().append(str1).append(str2).toString();
运行期决定需要更多的时间来运行。

2) 第二种情景：使用StringBuffer取代String
看看下面的代码你会发现与情景一相反的结果――连接多个字符串的时候StringBuffer要比String快。
StringTest4.java

package com.performance.string;

/** This class shows the time taken by string concatenation
using + operator and StringBuffer */
public class StringTest4 {

public static void main(String[] args){
    //Test the String Concatenation using + operator
    long startTime = System.currentTimeMillis();
    String result = "hello";
    for(int i=0;i<1500;i++){
        result += "hello";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
                  + (endTime - startTime)+ " milli seconds");

    //Test the String Concatenation using StringBuffer
    long startTime1 = System.currentTimeMillis();
    StringBuffer result1 = new StringBuffer("hello");
    for(int i=0;i<1500;i++){
        result1.append("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using StringBuffer : "
                  + (endTime1 - startTime1)+ " milli seconds");
    }
}
这是上面的代码的输出结果：
Time taken for string concatenation using + operator : 280 milli seconds
Time taken for String concatenation using StringBuffer : 0 milli seconds

看得出StringBuffer.append()方法要比+操作符要快得多，为什么呢？

　　原因是两者都是在运行期决定字符串对象，但是+操作符使用不同于StringBuffer.append()的规则通过String和StringBuffer来完成字符串连接操作。（译注：什么样的规则呢？）

借助StringBuffer的初始化过程的优化技巧
　　你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。

StringBuffer的缺省行为：
　　StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。

　　如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。

　　我利用两个StringBuffer重新测试了上面的StringTest4.java代码，一个未使用初始化容量值而另一个使用了。这次我追加了50000个’hello’对象没有使用+操作符。区别是我使用StringBuffer(250000)的构造函数来初始化第二个StringBuffer了。

输出结果如下：
Time taken for String concatenation using StringBuffer with out setting size: 280 milli seconds
Time taken for String concatenation using StringBuffer with setting size: 0 milli seconds

StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

关键点
1. 无论何时只要可能的话使用字符串字面量来常见字符串而不是使用new关键字来创建字符串。
2. 无论何时当你要使用new关键字来创建很多内容重复的字符串的话，请使用String.intern()方法。
3. +操作符会为字符串连接提供最佳的性能――当字符串是在编译期决定的时候。
4. 如果字符串在运行期决定，使用一个合适的初期容量值初始化的StringBuffer会为字符串连接提供最佳的性能。

String与StringBuffer的比较
String类提供了一些方法，用来进行字符串的比较。这个类实现了Object父类的equals()方法，用来比较两种字符串的值是否相等。同时还增加了equalsIgnoreCase()方法可以忽略两个字符串大小写的区别。下面是这两种方法的例子。
【例6-6】
public class E6_6{
public static void main(String args[]) {
  String s1="a";
  String s2=new String("a");
  String s3="A";
  System.out.println(s1.equals(s2));
  System.out.println(s1.equals(s3));
  System.out.println(s1.equalsIgnoreCase(s3));
}
}
上例的输出是
true
flase
true

但是StringBuffer类并没有实现Objcet类的Equals方法，所以不能用这个方法来比较两个StringBuffer类的字符串是否相等，如下例所示。
【例6-7】
public class E6_7{
public static void main(String args[]) {
  StringBuffer s1=new StringBuffer("a");
  StringBuffer s2=new StringBuffer("a");
  System.out.println(s1.equals(s2));

}
}
程序输出：false

除了用equalse方法来比较两个字符串外，还可以用==来比较字符串。与equalse方法不同的是，==不是比较两个字符串的值是否相等，而是比较几个字符串的引用是否指向同一个实例。如例6-8所示。
【例6-8】
public class E6_8{
public static void main(String args[]) {
  String s1="a";
  String s2="a";
  String s3=new String("a");
  String s4=new String("a");
  System.out.println(s1==s2);
  System.out.println(s3==s4);
  System.out.println(s1==s3);

}

}
上面的程序段输出：
true
false
false
与上例进行比较，不仅可以看出来==与equals的区别，还可以看到字面量的String的特殊之外。
对于字面量的String，只要字符串的值是相等的，不论有多少个引用都是指向同一块内存，不再另外分配空间。而用new关键字生成的实例则不同，每当用new实例化一次，分配该实例自己的内存空间。上例的存储方式如图所示：

图6-1 s1、s2、s3、s4的区别
下面再通过另一个例子来看String和StringBuffer的区别。
【例6-9】
public class E6_9{
public static void main(String args[]) {
  String s1="a";
  StringBuffer sb1=new StringBuffer("a");

  StringBuffer sb2=sb1;
  String s2="a"+"b";
  sb1.append("b");

  System.out.println(s1==s2);
  System.out.println(sb1==sb2);

}
}
上例输出的是：
flase
true
上例可以证明这样的结论：String是不可变长的字符串，对String做任何的修改将生成新的字符串，而StringBuffer是可变长的字符串，不论怎么更动还是同一个字符串。

airwalk 2007-08-31 17:21 发表评论

SQL 增加或删除一列

airwalk — Thu, 23 Aug 2007 02:11:00 GMT

alter table tablename drop column columnname;
alter table tabelname add columnname varchar2(8) NULL;

airwalk 2007-08-23 10:11 发表评论

xp 架设DNS FW

airwalk — Wed, 22 Aug 2007 02:58:00 GMT

一、使用WINDOWS系统自带的DNS

1. 准备xp安装光盘，win2000server安装光盘（adv ser也可）各1张
将win2000server安装光盘中的 \i386 目录下EXPAND.EXE,iis.dl_,iis.in_,netdns.in_ 的4个档案
复制到硬盘，分别在这4个档案所在目录于命令提示字符下执行:（注：使用批处理更为简单）

EXPAND.EXE iis.dl_ iis2.dll
EXPAND.EXE iis.in_ iis2.inf
EXPAND.EXE netdns.in_ netdns.inf

产生 iis2.dll,iis2.inf,netdns.inf 3个档案

2. 寻找 c :\windows\inf\netoc.inf 并用记事本打开它（XP下可能没有，从2003相同相同路径下拷贝一个到XP里）

在 [Optional Components] 栏目下面有以下内容：

[Optional Components]

NetOC ;Top level option
NetServices
FileAndPrint
SNMP
......
在NetServices下面添加2行
DNS
NNTP

3. 寻找 C:\WINDOWS\INF\SYSOC.INF 并用记事本打开它
找这一行
iis=iis.dll,OcEntry,iis.inf,hide,7
改成
iis=iis2.dll,OcEntry,iis2.inf,,7
4. 将iis2.inf,netdns.inf文件复制到c:\windows\inf目录下
将iis2.dll复制到C:\WINDOWS\system32\Setup
5. 重新开机，之后选择
开始 → 设定 → 控制台 → 新增移除程序 → 新增移除Windows组件就能出现IIS及Networking service的 DNS选项
6. 注意，安装期间会有2次提示，第一次放入win2000server(adv server)安装光盘，浏览i386目录，然后确定；第二次放入xp安装盘，确定。
这样，xp系统下就安装了IIS & DNS

二、使用BIND DNS Server 服務

參考這篇：
http://forums.devshed.com/t66341/s.html?highlight=netstat:

大概描述如下：

安裝：

1.到以下網址下載 BIND 9 回來
http://www.isc.org/products/BIND/bind9.html

2.解開 ZIP 檔，並執行 BINDInstall.exe

3.選擇 Target Directory 。(就是要安裝到哪的意思啦！)

4.不要勾選 "Start BIND Service After Install" 。

5.按下 "Install" 安裝。

設定：

1.安裝目錄中要有以下子目錄：
bin : 可執行檔存放的目錄
etc : 設定檔存放的目錄
log : 記錄檔存放的目錄
(亦即當您按下 BINDInstall.exe 時，所選的安裝目錄底下要建立以上目錄，bin 是事先程式自動產生的，預設是 "C:\WINDOWS\system32\dns" )

2.etc 底下要有：
named.conf : named 服務執行時的設定。
root.hint : 這個不知道是什麼，一定要有，但內容小弟是留空白。
rndc.key : 用 bin 底下的 rndc-confgen.exe 產生出來的。
example.com.zone : 網域的 Zone。
0.168.192.in-addr.arpa.zone : 反查用記錄的 Zone。

3.named.conf 的內容參考以下網址：
http://serialcoders.sytes.net/BIND/named.conf

4.在 bin 底下執行：
rndc-confgen.exe > rndc.key

5.將產生的 rndc.key 移到 etc 底下

6.直接下載此檔並更名為 root.hint：
ftp://rs.internic.net/domain/named.root

7.參考以下網址建立 Zone 檔：
http://serialcoders.sytes.net/BIND/example.com.zone
(也可以拿原來 2000 Server 的 .dns 檔來用)

8.參考以下網址建立反查 Zone ：
http://serialcoders.sytes.net/BIND/0.0.127.IN-ADDR.ARPA.zone
(也可以拿原來 2000 Server 的 .dns 檔來用)

9.還有不懂的地方參考 BIND 所附的 HTML 檔。
或是參考這裡：
http://linux.vbird.org/linux_server/0350dns.php

10.重新啟動 ISC BIND 服務，應該就可以執行了。

這樣不就用安裝 Windows 2000 Server 或是 Windows 2003 Server 囉。

補充：

1. 每次新增一筆 Record 時，要重新啟動服務。

2. 在防火牆或IP分享器內時，記得打開虛擬伺服器PORT 53。

3. 設定檔 (*.zone) 最後一行要有 (也只能有) 一個換行字元。

4. 記得到你申請 DNS 的單位，把 DNS 對應回來你架 BIND 的 IP ，這樣別人才能找到你。

airwalk 2007-08-22 10:58 发表评论

网络命令

airwalk — Wed, 22 Aug 2007 02:53:00 GMT

Win2000以上：Ipconfig/all
C.NSLOOKUP：如查看河北的DNS
C:\>nslookup
Default Server: ns.hesjptt.net.cn
Address: 202.99.160.68
>server 202.99.41.2 则将DNS改为了41.2
> pop.pcpop.com
Server: ns.hesjptt.net.cn
Address: 202.99.160.68

Non-authoritative answer:
Name: pop.pcpop.com
Address: 202.99.160.212

3.网络信使
Net send 计算机名/IP|* (广播) 传送内容，注意不能跨网段
net stop messenger 停止信使服务，也可以在面板－服务修改
net start messenger 开始信使服务

4.探测对方对方计算机名，所在的组、域及当前用户名
ping －a IP －t ，只显示NetBios名
nbtstat -a 192.168.10.146 比较全的

5.netstat -a 显示出你的计算机当前所开放的所有端口
netstat -s -e 比较详细的显示你的网络资料，包括TCP、UDP、ICMP 和 IP的统计等

6.探测arp绑定（动态和静态）列表，显示所有连接了我的计算机，显示对方IP和MAC地址
arp -a

7.在代理服务器端
捆绑IP和MAC地址，解决局域网内盗用IP：
ARP －s 192.168.10.59 00－50－ff－6c－08－75
解除网卡的IP与MAC地址的绑定：
arp -d 网卡IP

8.在网络邻居上隐藏你的计算机
net config server /hidden:yes
net config server /hidden:no 则为开启

9.几个net命令
A.显示当前工作组服务器列表 net view，当不带选项使用本命令时，它就会显示当前域或网络上的计算机上的列表。
比如：查看这个IP上的共享资源，就可以
C:\>net view 192.168.10.8
在 192.168.10.8 的共享资源
资源共享名类型用途注释
--------------------------------------
网站服务 Disk
命令成功完成。

B.查看计算机上的用户帐号列表 net user
C.查看网络链接 net use
例如：net use z: [url=]file://192.168.10.8/movie[/url] 将这个IP的movie共享目录映射为本地的Z盘

D.记录链接 net session
例如：
C:\>net session
计算机用户名客户类型打开空闲时间
-------------------------------------------------------------------------------
[url=]file://192.168.10.110/[/url] ROME Windows 2000 2195 0 00:03:12

[url=]file://192.168.10.51/[/url] ROME Windows 2000 2195 0 00:00:39
命令成功完成。

10.路由跟踪命令
A.tracert pop.pcpop.com
B.pathping pop.pcpop.com 除了显示路由外，还提供325S的分析，计算丢失包的％

11.关于共享安全的几个命令
A.查看你机器的共享资源 net share
B.手工删除共享
net share c$ /d
net share d$ /d
net share ipc$ /d
net share admin$ /d
注意$后有空格。
C.增加一个共享：
c:\net share mymovie=e:\downloads\movie /users:1
mymovie 共享成功。
同时限制链接用户数为1人。

12.在DOS行下设置静态IP
A.设置静态IP
CMD
netsh
netsh>int
interface>ip
interface ip>set add "本地链接" static IP地址 mask gateway
B.查看IP设置
interface ip>show address

Arp
显示和修改“地址解析协议 (ARP)”缓存中的项目。ARP 缓存中包含一个或多个表，它们用于存储 IP 地址及其经过解析的以太网或令牌环物理地址。计算机上安装的每一个以太网或令牌环网络适配器都有自己单独的表。如果在没有参数的情况下使用，则 arp 命令将显示帮助信息。

语法
arp [-a [InetAddr] [-N IfaceAddr]] [-g [InetAddr] [-N IfaceAddr]] [-d InetAddr [IfaceAddr]] [-s InetAddr EtherAddr [IfaceAddr]]

参数
-a [InetAddr] [-N IfaceAddr]
显示所有接口的当前 ARP 缓存表。要显示指定 IP 地址的 ARP 缓存项，请使用带有 InetAddr 参数的 arp -a，此处的 InetAddr 代表指定的 IP 地址。要显示指定接口的 ARP 缓存表，请使用 -N IfaceAddr 参数，此处的 IfaceAddr 代表分配给指定接口的 IP 地址。-N 参数区分大小写。
-g [InetAddr] [-N IfaceAddr]
与 -a 相同。
-d InetAddr [IfaceAddr]
删除指定的 IP 地址项，此处的 InetAddr 代表 IP 地址。对于指定的接口，要删除表中的某项，请使用 IfaceAddr 参数，此处的 IfaceAddr 代表分配给该接口的 IP 地址。要删除所有项，请使用星号 (*) 通配符代替 InetAddr。
-s InetAddr EtherAddr [IfaceAddr]
向 ARP 缓存添加可将 IP 地址 InetAddr 解析成物理地址 EtherAddr 的静态项。要向指定接口的表添加静态 ARP 缓存项，请使用 IfaceAddr 参数，此处的 IfaceAddr 代表分配给该接口的 IP 地址。
/?
在命令提示符显示帮助。
注释
InetAddr 和 IfaceAddr 的 IP 地址用带圆点的十进制记数法表示。
物理地址 EtherAddr 由六个字节组成，这些字节用十六进制记数法表示并且用连字符隔开（比如，00-AA-00-4F-2A-9C）。
通过 -s 参数添加的项属于静态项，它们不会 ARP 缓存中超时。如果终止 TCP/IP 协议后再启动，这些项会被删除。要创建永久的静态 ARP 缓存项，请在批处理文件中使用适当的 arp 命令并通过“计划任务程序”在启动时运行该批处理文件。
只有当网际协议 (TCP/IP) 协议在网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要显示所有接口的 ARP 缓存表，可键入：

arp -a

对于指派的 IP 地址为 10.0.0.99 的接口，要显示其 ARP 缓存表，可键入：

arp -a -N 10.0.0.99

要添加将 IP 地址 10.0.0.80 解析成物理地址 00-AA-00-4F-2A-9C 的静态 ARP 缓存项，可键入：

arp -s 10.0.0.80 00-AA-00-4F-2A-9C

At
计划在指定时间和日期在计算机上运行命令和程序。at 命令只能在“计划”服务运行时使用。如果在没有参数的情况下使用，则 at 列出已计划的命令。

语法
at [\\ComputerName] [{[ID] [/delete]|/delete [/yes]}]

at [[\\ComputerName] hours:minutes [/interactive] [{/every:date[,...]|/next:date[,...]}] command]

参数
[url=]file://computername/[/url]
指定远程计算机。如果省略该参数，则 at 计划本地计算机上的命令和程序。
ID
指定指派给已计划命令的识别码。
/delete
取消已计划的命令。如果省略了 ID，则计算机中所有已计划的命令将被取消。
/yes
删除已计划的事件时，对来自系统的所有询问都回答“是”。
hours:minutes
指定命令运行的时间。该时间用 24 小时制（即从 00:00 [午夜] 到 23:59）的小时: 分钟格式表示。
/interactive
对于在运行 command 时登录的用户,允许 command 与该用户的桌面进行交互。
/every:
在每个星期或月的指定日期（例如，每个星期四，或每月的第三天）运行 command 命令。
date
指定运行命令的日期。可以指定一周的某日或多日（即，键入 M、T、W、Th、F、S、Su）或一个月中的某日或多日（即，键入从 1 到31 之间的数字）。用逗号分隔多个日期项。如果省略了 date，则 at 使用该月的当前日。
/next:
在下一个指定日期（比如，下一个星期四）到来时运行 command。
command
指定要运行的 Windows 命令、程序（.exe 或 .com 文件）或批处理程序（.bat 或 .cmd 文件）。当命令需要路径作为参数时，请使用绝对路径，也就是从驱动器号开始的整个路径。如果命令在远程计算机上，请指定服务器和共享名的通用命名协定 (UNC) 符号，而不是远程驱动器号。
/?
在命令提示符显示帮助。
注释
Schtasks 是功能更为强大的超集命令行计划工具，它含有 at 命令行工具中的所有功能。对于所有的命令行计划任务，都可以使用 schtasks 来替代 at。有关 schtasks 的详细信息，请参阅“相关主题”。

使用 at
使用 at 命令时，要求您必须是本地 Administrators 组的成员。

加载 Cmd.exe
在运行命令之前，At 不会自动加载 Cmd.exe （命令解释器）。如果没有运行可执行文件 (.exe)，则在命令开头必须使用如下所示的方法专门加载 Cmd.exe：

cmd /c dir > c:\test.out。

查看已计划的命令
当不带命令行选项使用 at 时，计划任务会出现在类似于以下格式的表中：

Status ID Day Time Command Line
OK 1 Each F 4:30 PM net send group leads status due
OK 2 Each M 12:00 AM chkstor > check.file
OK 3 Each F 11:59 PM backup2.bat
包含标识号 (ID)
当在命令提示下使用带有标识号 (ID) 的 at 命令时，单个任务项的信息会显示在类似于下面的格式中：

Task ID： 1

Status:OK

Schedule:Each F

Time of Day:4:30 PM

Command:net send group leads status due当计划带有 at 的命令（尤其是带有命令行选项的命令）后，要通过键入不带命令行选项的 at 来检查该命令语法是否输入正确。如果显示在“命令行”列中的信息不正确，请删除该命令，然后重新键入它。如果还不正确，则可以在重新键入该命令时让它少带些命令行选项。

查看结果
使用 at 的已经计划的命令作为后台程序运行。运行结果不会显示在计算机上。要将输出重定向到文件，请使用重定向符号 (>)。如果将输出重定向到文件，则不论是在命令行还是在批处理文件中使用 at，都需要在重定向符号之前使用转义符 (^)。例如，要重定向输出到 Output.text 文件，则要键入：

at 14:45 c:\test.bat ^>c:\output.txt

执行命令的当前目录为 systemroot 文件夹。

更改系统时间
在使用 at 命令计划了要运行的命令之后，如果更改了计算机的系统时间，则通过键入不带命令行选项的 at 可使 at 计划程序与修改后的系统时间同步。

存储命令
已计划的命令存储在注册表中。这样，如果重新启动“计划”服务，则不会丢失计划任务。

连接到网络驱动器
对于需要访问网络的计划作业，请不要使用已重新定向的驱动器。“计划”服务可能无法访问这些重定向的驱动器，或者，在该计划任务运行时如果有其他用户登录，则这些重定向的驱动器可能不会出现。因此，对于计划作业，请使用 UNC 路径。例如：

at 1:00pm my_backup [url=]file://server/share[/url]

请不要使用下述语法（其中 x: ?表示由用户建立的连接）：

at 1:00pm my_backup x:

如果计划了一个使用驱动器号的 at 命令来连接共享目录，则应包含一个 at 命令以使在完成该驱动器的使用时断开与驱动器的连接。如果不能断开与驱动器的连接，则在命令提示下，所指派的驱动器号将不可用。
范例
要显示 Marketing 服务器上已计划的命令列表，请键入：
at [url=]file://marketing/[/url]
要了解服务器 Corp 上标识号为 3 的命令的详细信息，请键入：

at [url=]file://corp/[/url] 3
要计划在上午 8:00 于 Corp 服务器上运行网络共享命令，并将该列表重定向到 Maintenance 服务器的 Corp.txt 文件（位于 Reports 共享目录下）中，请键入：

at [url=]file://corp/[/url] 08:00 cmd /c "net share reports=d:\marketing\reports >> [url=]file://maintenance/reports/corp.txt[/url]"
为了在每五天后的午夜将 Marketing 服务器的硬盘驱动器备份到磁带驱动器，首先创建名为 Archive.cmd 的批处理程序（它含有备份命令），然后计划该批处理程序的运行，为此请键入：

at [url=]file://marketing/[/url] 00:00 /every:5,10,15,20,25,30 archive
要取消当前服务器上已计划的所有命令，请按下述方法清除 at 计划信息：

at /delete
如果要运行的命令不是可执行 (.exe) 文件，请按如下所示的方法在该命令之前使用 cmd /c 来加载 Cmd.exe：

cmd /c dir > c:\test.out。
Rsh
在运行 RSH 服务的远程计算机上运行命令。Windows XP 和 Windows 2000 不提供 RSH 服务。Windows 2000 Server Resource Kit 提供名为 Rshsvc.exe 的 RSH 服务。使用不带参数的 rsh 显示帮助。

语法
rsh [Host] [-l UserName] [-n] [Command]

参数
Host
指定运行 command 的远程计算机。
-l UserName
指定远程计算机上使用的用户名。在省略情况下，使用当前登录用户的名称。
-n
将 rsh 的输入重定向到 NULL 设备。这防止本地计算机命令结果的显示。
Command
指定要运行的命令。
/?
在命令提示符显示帮助。
注释
标准操作
rsh 命令将标准输入复制到远程 command，将远程 command 的标准输出复制到其标准输出，将远程 command 的标准错误复制到其标准错误。Rsh 通常在远程命令终止时终止。

使用重定向符号
为了使重定向在远程计算机上发生，要以引号引住重定向符号（例如 ">>"）。如果不使用引号，重定向会在本地计算机发生。例如，以下命令将远程文件“RemoteFile”附加到本地文件“LocalFile”中：

rsh othercomputer cat remotefile >> localfile

以下命令将远程文件 Remotefile 附加到远程文件 otherremotefile 中：

rsh othercomputer cat remotefile ">>" otherremotefile

使用 rsh
在使用已登录到某个域并且运行 Windows XP Professional 的计算机时，该域的主域控制器必须可用于确认用户名或 rsh 命令失败。

.rhosts 文件
.rhosts 文件通常许可 UNIX 系统的网络访问权限。.rhosts 文件列出可以访问远程计算机的计算机名及关联的登录名。在正确配置了 .rhosts 文件的远程计算机上运行 rcp、rexec 或 rsh 命令时，您不必提供远程计算机的登录和密码信息。

.rhosts 文件是一个文本文件，该文件中每一行为一个条目。条目由本地计算机名、本地用户名和有关该条目的所有注释组成。每个条目均由制表符或空格分开，注释用符号 (#) 打头。例如：

host7 #This computer is in room 31A

.rhosts 文件必须在远程计算机的用户主目录中。有关远程计算机 .rhosts 文件特定执行的详细信息，请参阅远程系统的文档。

只有当网际协议 (TCP/IP) 协议在网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要以名称 admin1 在远程计算机 vax1 上执行 telcon 命令，请键入：

rsh vax1 -l admin1 telcon

airwalk 2007-08-22 10:53 发表评论

[转]Eclipse tomcat lomboz 配置

airwalk — Fri, 13 Apr 2007 09:06:00 GMT

一、系统环境配置1、win2k professional2、eclipse 3.1.2，可以到官方网站http://www.eclipse.org/downloads/index.php下载eclipse的最新版本，当前为eclipse3.1.2版，下载好后，将其解压缩（假设到d:\eclipse）；3、jdk1.5.0，目前sun 的站点上下载不了，可以到其他站点看看，到google搜一搜；4、tomcat5.5.0 （4.1以上均可），http://jakarta.apache.org/ 二、插件下载lomboz，到站点http://forge.objectweb.org/project/showfiles.php?group_id=97下载lomboz-wtp-emf-gef-jem-3.1.2.zip，老一点的版本如eclipse3.0.x要下两个文件，一个是lomboz，另外一个是emf，新的版本如eclipse3.1.2只需要一个lomboz-wtp-emf-gef-jem-3.1.2.zip，因为该文件已经包含了lomboz和emf，并且该插件的版本必须与eclipse的版本相对应；
  三、插件安装配置插件有两种方法，一是真接将插件解压缩到D:\eclipse\plugins文件夹中，二是写LINK文件，这种方法比较容易管理插件，添加、删除插件都很方便，推荐使用这种。下面主要说用第二种方法，以配置tomcatplugin插件为例：1、依次建下列文件夹，假设为d:\eclipse-plugins\tomcat\eclipse\plugins，不同的插件应该建立不同的目录，如lomboz的可以这样：d:\eclipse-plugins\lomboz\eclipse\plugins； 2  2、解压缩TomcatPluginV31.zip至刚才建立的文件夹中，最后的文件目录结构如下所示：
     d:\eclipse-plugins （手动建）
         |-tomcat（手动建，如果是其他插件，则换成其他的文件名）
             |-eclipse（有些文件解压缩后会自动建立，如果没有，手动建）
                |-plugins（同上）
                    |-com.sysdeo.eclipse.tomcat_3.1.0（这就是解压缩后的tomcatplugin） 3、到d:\eclipse\文件夹中，新建一个links目录，在该目录下，新建一个文件tomcat.link(文件名任意，可以先建一个文本文件，然后另存为link文件)，内容为：path=d:/eclipse-plugins/tomcat，表示指向插件所在位置，如果有多个插件，就建立多个相应的link文件，如lomboz的link文件可为lomboz.link，内容是：path=d:/eclipse-plugins/lomboz，文件目录结构如下所示：        d:\eclipse
           |--links
              |--tomcat.link(配置其它插件时，新建相应的link文件) 4、启动eclipse，即可看到菜单栏上多了tomcat选项。如果不成功，删除configuration下的org.eclipse.update文件夹，重启eclipse即可。

airwalk 2007-04-13 17:06 发表评论