yeshucheng
追逐自己,追逐方向,心随悟所动
posts - 24,comments - 24,trackbacks - 0

在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement.
基于以下的原因:
一.代码的可读性和可维护性.
虽然用PreparedStatement来代替Statement会使代码多出几行,但这样的代码无论从可读性还是可维护性上来说.都比直接用Statement的代码高很多档次:

stmt.executeUpdate("insert into tb_name (col1,col2,col2,col4) values ('"+var1+"','"+var2+"',"+var3+",'"+var4+"')");

perstmt = con.prepareStatement("insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)");
perstmt.setString(1,var1);
perstmt.setString(2,var2);
perstmt.setString(3,var3);
perstmt.setString(4,var4);
perstmt.executeUpdate();

不用我多说,对于第一种方法.别说其他人去读你的代码,就是你自己过一段时间再去读,都会觉得伤心.

二.PreparedStatement尽最大可能提高性能.
每一种数据库都会尽最大努力对预编译语句提供最大的性能优化.因为预编译语句有可能被重复调用.所以语句在被DB的编译器编译后的执行代码被缓存下来,那么下次调用时只要是相同的预编译语句就不需要编译,只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行.这并不是说只有一个 Connection中多次执行的预编译语句被缓存,而是对于整个DB中,只要预编译的语句语法和缓存中匹配.那么在任何时候就可以不需要再次编译而可以直接执行.而statement的语句中,即使是相同一操作,而由于每次操作的数据不同所以使整个语句相匹配的机会极小,几乎不太可能匹配.比如:
insert into tb_name (col1,col2) values ('11','22');
insert into tb_name (col1,col2) values ('11','23');
即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.这样每执行一次都要对传入的语句编译一次.

当然并不是所以预编译语句都一定会被缓存,数据库本身会用一种策略,比如使用频度等因素来决定什么时候不再缓存已有的预编译结果.以保存有更多的空间存储新的预编译语句.

三.最重要的一点是极大地提高了安全性.

即使到目前为止,仍有一些人连基本的恶义SQL语法都不知道.
String sql = "select * from tb_name where name= '"+varname+"' and passwd='"+varpasswd+"'";
如果我们把[' or '1' = '1]作为varpasswd传入进来.用户名随意,看看会成为什么?

select * from tb_name = '随意' and passwd = '' or '1' = '1';
因为'1'='1'肯定成立,所以可以任何通过验证.更有甚者:
把[';drop table tb_name;]作为varpasswd传入进来,则:
select * from tb_name = '随意' and passwd = '';drop table tb_name;有些数据库是不会让你成功的,但也有很多数据库就可以使这些语句得到执行.

而如果你使用预编译语句.你传入的任何内容就不会和原来的语句发生任何匹配的关系.(前提是数据库本身支持预编译,但上前可能没有什么服务端数据库不支持编译了,只有少数的桌面数据库,就是直接文件访问的那些)只要全使用预编译语句,你就用不着对传入的数据做任何过虑.而如果使用普通的statement, 有可能要对drop,;等做费尽心机的判断和过虑.

上面的几个原因,还不足让你在任何时候都使用PreparedStatement吗?

 

 

有的新人可能此时对于用法还不太理解下面给个小例子

Code Fragment 1:

String updateString = "UPDATE COFFEES SET SALES = 75 " + "WHERE COF_NAME LIKE ′Colombian′"; 
stmt.executeUpdate(updateString);

Code Fragment 2:

PreparedStatement updateSales = con.prepareStatement("UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ? "); 
updateSales.setInt(1, 75); 
updateSales.setString(2, "Colombian"); 
updateSales.executeUpdate();

set中的1对应第一个? 2对应第二个? 同时注意你set 的类型 是int还是string  哈哈很简单吧


原文出处:http://blog.csdn.net/spcusa/archive/2009/05/09/4164076.aspx

posted @ 2010-12-14 13:58 叶澍成| 编辑 收藏

//ValueObject类

public class AdEntity {
    
private String id;
    
private String name;
    
private String broker;
    
private String date;
    
private String body;
    
//get/set
    
    
public String toString(){
        
return "【编号为:"+id+",广告名称为:"+name+",代理商为:"+broker+",发布日期为:"+date+",内容为:"+body+"";
    }
}

//调用任务类

public class AdTask implements Callable<AdEntity> {
    @Override
    
public AdEntity call() throws Exception {
        
// 模拟远程调用花费的一些时间
        Thread.sleep(5*1000);
        AdEntity vo
=new AdEntity();
        vo.setId(String.valueOf(
new Random().nextInt(1000)));
        vo.setName(
"Ad@内衣广告");
        vo.setBroker(
"CHANNEL");
        Date date
=new Date();
        SimpleDateFormat sdf
=new SimpleDateFormat("yyyy-MM-dd");
        String dateStr
=sdf.format(date);
        vo.setDate(dateStr);
        vo.setBody(
"远端内容");
        
return vo;
    }
}

//主函数

public class TestQueryMemg {
    
    
/**
     * 
@param args
     * 
@throws ExecutionException 
     * 
@throws InterruptedException 
     
*/
    
public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService exec
=Executors.newCachedThreadPool();
        
//创建Future来完成网络调用任务
        Callable<AdEntity> returnAd=new AdTask();
        Future
<AdEntity> future=exec.submit(returnAd);
        
        
//开始执行本地化查询信息
        AdEntity localAd=new AdEntity();
        localAd.setId(String.valueOf(
new Random().nextInt(1000)));
        localAd.setName(
"Ad@食品广告");
        localAd.setBroker(
"蒙牛");
        SimpleDateFormat sdf
=new SimpleDateFormat("yyyy-MM-dd");
        String dateStr
=sdf.format(new Date());
        localAd.setDate(dateStr);
        localAd.setBody(
"内容本地");

        System.out.println(
"当前本地化查询内容为:"+localAd.toString());
        System.out.println(
"稍等片刻以获取远端信息");
        
        
while(!future.isDone()){
            
try {
                Thread.sleep(
1*1000);
            } 
catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        AdEntity entityRemote
=(AdEntity)future.get();

        System.out.println(
"合并查询内容为:\n"+localAd.toString()+"\n"+entityRemote.toString());
    }
}


 

 

 

posted @ 2010-12-12 14:44 叶澍成| 编辑 收藏

个人账户类:

public class PrivateAccount implements Callable {
    Integer total;
    
public Object call() throws Exception {
        Thread.sleep(
5*1000);
        total
=new Integer(new Random().nextInt(10000));
        System.out.println(
"您个人账户上还有"+total+" 存款可以支配");
        
return total;
    }
}

主函数测试:

public class SumTest {
    
/**
     * 
@param args
     * 
@throws ExecutionException 
     * 
@throws InterruptedException 
     
*/
    
public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable privateAccount
=new PrivateAccount();
        FutureTask task
=new FutureTask(privateAccount);
                
//创建新线程获取个人账户信息
        Thread thread=new Thread(task);
        thread.start();

        
int total=new Random().nextInt(1000);
        System.out.println(
"主线程在这工作");
        System.out.println(
"您目前操作金额为: "+total+" .");
        System.out.println(
"请等待计算个人账户的金额");
        
while(!task.isDone()){//判断是否已经获取返回值
            try {
                Thread.sleep(
3*1000);
            } 
catch (InterruptedException e) {
                
// TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        Integer privateSingle
=(Integer)task.get();
        
int post=privateSingle.intValue();
        
        System.out.println(
"您当前账户共有金额为:"+(total+post)+" ¥");
    }

}


 

 

posted @ 2010-12-10 20:53 叶澍成| 编辑 收藏
Memcached,人所皆知的remote distribute cache(不知道的可以javaeye一下下,或者google一下下,或者baidu一下下,但是鉴于baidu的排名商业味道太浓(从最近得某某事件可以看出),所以还是建议javaeye一下下),使用起来也非常的简单,它被用在了很多网站上面,几乎很少有大型的网站不会使用memcached。

曾经我也看过很多剖析memcached内部机制的文章,有一点收获,但是看过之后又忘记了,而且没有什么深刻的概念,但是最近我遇到一个问题,这个问题迫使我重新来认识memcache,下面我阐述一下我遇到的问题

问题:我有几千万的数据,这些数据会经常被用到,目前来看,它必须要放到memcached中,以保证访问速度,但是我的memcached中数据经常会有丢失,而业务需求是memcached中的数据是不能丢失的。我的数据丢失的时候,memcached server的内存才使用到60%,也就是还有40%内存被严重的浪费掉了。但不是所有的应用都是这样,其他应用内存浪费的就比较少。为什么内存才使用到60%的时候LRU就执行了呢(之所以确定是LRU执行是因为我发现我的数据丢失的总是前面放进去的,而且这个过程中,这些数据都没有被访问,比如第一次访问的时候,只能访问第1000w条,而第300w条或者之前的数据都已经丢失了,从日志里看,第300w条肯定是放进去了)。

带着这些疑问,我开始重新审视memcached这个产品,首先从它的内存模型开始:我们知道c++里分配内存有两种方式,预先分配和动态分配,显然,预先分配内存会使程序比较快,但是它的缺点是不能有效利用内存,而动态分配可以有效利用内存,但是会使程序运行效率下降,memcached的内存分配就是基于以上原理,显然为了获得更快的速度,有时候我们不得不以空间换时间。

也就是说memcached会预先分配内存,对了,memcached分配内存方式称之为allocator,首先,这里有3个概念:
1 slab
2 page
3 chunk
解释一下,一般来说一个memcahced进程会预先将自己划分为若干个slab,每个slab下又有若干个page,每个page下又有多个chunk,如果我们把这3个咚咚看作是object得话,这是两个一对多得关系。再一般来说,slab得数量是有限得,几个,十几个,或者几十个,这个跟进程配置得内存有关。而每个slab下得page默认情况是1m,也就是说如果一个slab占用100m得内存得话,那么默认情况下这个slab所拥有得page得个数就是100,而chunk就是我们得数据存放得最终地方。

举一个例子,我启动一个memcached进程,占用内存100m,再打开telnet,telnet localhost 11211,连接上memcache之后,输入stats  slabs,回车,出现如下数据:
Java代码 复制代码
  1. STAT 1:chunk_size 80  
  2. STAT 1:chunks_per_page 13107  
  3. STAT 1:total_pages 1  
  4. STAT 1:total_chunks 13107  
  5. STAT 1:used_chunks 13107  
  6. STAT 1:free_chunks 0  
  7. STAT 1:free_chunks_end 13107  
  8. STAT 2:chunk_size 100  
  9. STAT 2:chunks_per_page 10485  
  10. STAT 2:total_pages 1  
  11. STAT 2:total_chunks 10485  
  12. STAT 2:used_chunks 10485  
  13. STAT 2:free_chunks 0  
  14. STAT 2:free_chunks_end 10485  
  15. STAT 3:chunk_size 128  
  16. STAT 3:chunks_per_page 8192  
  17. STAT 3:total_pages 1  
  18. STAT 3:total_chunks 8192  
  19. STAT 3:used_chunks 8192  
  20. STAT 3:free_chunks 0  
  21. STAT 3:free_chunks_end 8192  


以上就是前3个slab得详细信息
chunk_size表示数据存放块得大小,chunks_per_page表示一个内存页page中拥有得chunk得数量,total_pages表示每个slab下page得个数。total_chunks表示这个slab下chunk得总数(=total_pages * chunks_per_page),used_chunks表示该slab下已经使用得chunk得数量,free_chunks表示该slab下还可以使用得chunks数量。

从上面得示例slab 1一共有1m得内存空间,而且现在已经被用完了,slab2也有1m得内存空间,也被用完了,slab3得情况依然如此。 而且从这3个slab中chunk得size可以看出来,第一个chunk为80b,第二个是100b,第3个是128b,基本上后一个是前一个得1.25倍,但是这个增长情况我们是可以控制得,我们可以通过在启动时得进程参数 –f来修改这个值,比如说 –f 1.1表示这个增长因子为1.1,那么第一个slab中得chunk为80b得话,第二个slab中得chunk应该是80*1.1左右。

解释了这么多也该可以看出来我遇到得问题得原因了,如果还看不出来,那我再补充关键的一句:memcached中新的value过来存放的地址是该value的大小决定的,value总是会被选择存放到chunk与其最接近的一个slab中,比如上面的例子,如果我的value是80b,那么我这所有的value总是会被存放到1号slab中,而1号slab中的free_chunks已经是0了,怎么办呢,如果你在启动memcached的时候没有追加-M(禁止LRU,这种情况下内存不够时会out of memory),那么memcached会把这个slab中最近最少被使用的chunk中的数据清掉,然后放上最新的数据。这就解释了为什么我的内存还有40%的时候LRU就执行了,因为我的其他slab中的chunk_size都远大于我的value,所以我的value根本不会放到那几个slab中,而只会放到和我的value最接近的chunk所在的slab中(而这些slab早就满了,郁闷了)。这就导致了我的数据被不停的覆盖,后者覆盖前者。

问题找到了,解决方案还是没有找到,因为我的数据必须要求命中率时100%,我只能通过调整slab的增长因子和page的大小来尽量来使命中率接近100%,但是并不能100%保证命中率是100%(这话怎么读起来这么别扭呢,自我检讨一下自己的语文水平),如果您说,这种方案不行啊,因为我的memcached server不能停啊,不要紧还有另外一个方法,就是memcached-tool,执行move命令,如:move 3 1,代表把3号slab中的一个内存页移动到1号slab中,有人问了,这有什么用呢,比如说我的20号slab的利用率非常低,但是page却又很多,比如200,那么就是200m,而2好slab经常发生LRU,明显page不够,我就可以move 20 2,把20号slab的一个内存页移动到2号slab上,这样就能更加有效的利用内存了(有人说了,一次只移动一个page,多麻烦啊?ahuaxuan说,还是写个脚本,循环一下吧)。

有人说不行啊,我的memcache中的数据不能丢失啊,ok,试试新浪的memcachedb吧,虽然我没有用过,但是建议大家可以试试,它也使利用memcache协议和berkeleyDB做的(写到这里,我不得不佩服danga了,我觉得它最大的贡献不是memcache server本身,而是memcache协议),据说它被用在新浪的不少应用上,包括新浪的博客。

补充,stats slab命令可以查看memcached中slab的情况,而stats命令可以查看你的memcached的一些健康情况,比如说命中率之类的,示例如下:
Java代码 复制代码
  1. STAT pid 2232  
  2. STAT uptime 1348  
  3. STAT time 1218120955  
  4. STAT version 1.2.1  
  5. STAT pointer_size 32  
  6. STAT curr_items 0  
  7. STAT total_items 0  
  8. STAT bytes 0  
  9. STAT curr_connections 1  
  10. STAT total_connections 3  
  11. STAT connection_structures 2  
  12. STAT cmd_get 0  
  13. STAT cmd_set 0  
  14. STAT get_hits 0  
  15. STAT get_misses 0  
  16. STAT bytes_read 26  
  17. STAT bytes_written 16655  
  18. STAT limit_maxbytes 104857600  

从上面的数据可以看到这个memcached进程的命中率很好,get_misses低达0个,怎么回事啊,因为这个进程使我刚启动的,我只用telnet连了一下,所以curr_connections为1,而total_items为0,因为我没有放数据进去,get_hits为0,因为我没有调用get方法,最后的结果就是misses当然为0,哇哦,换句话说命中率就是100%,又yy了。

该到总结的时候了,从这篇文章里我们可以得到以下几个结论:
结论一,memcached得LRU不是全局的,而是针对slab的,可以说是区域性的。
结论二,要提高memcached的命中率,预估我们的value大小并且适当的调整内存页大小和增长因子是必须的。
结论三,带着问题找答案理解的要比随便看看的效果好得多。
posted @ 2010-08-17 17:45 叶澍成| 编辑 收藏

  1. 关闭所有oracle的服务和程序
  2. 选择开始| 程序|oracle Installation Products命令,运行Universal Installer,弹出欢迎对话框
  3. 单机 卸载产品 按钮,弹出Inventory对话框
  4. 选中Inventroy对话框中的所有节点,点击删除,确认即可
  5. 选 择 开始|运行 输入regedit并按ENTER键,选择HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE,删除此象,然后选择 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services,滚动此列表,删除与oracle有关的所 有选项。
  6. 从桌面上、STARTUP和程序菜单中删除所有ORACLE的组和图标。
  7. 重启系统。
  8. 删除包括文件在内的安装目录。至此ORACLE的全部卸载完成。
posted @ 2010-05-19 18:35 叶澍成| 编辑 收藏
位运算应用口诀

清零取位要用与,某位置一可用或

若要取反和交换,轻轻松松用异或

移位运算

要点 1 它们都是双目运算符,两个运算分量都是整形,结果也是整形。

     2 "<<" 左移:右边空出的位上补0,左边的位将从字头挤掉,其值相当于乘2。

     3 ">>"右移:右边的位被挤掉。对于左边移出的空位,如果是正数则空位补0,若为负数,可能补0或补1,这取决于所用的计算机系统。

     4 ">>>"运算符,右边的位被挤掉,对于左边移出的空位一概补上0。

位运算符的应用 (源操作数s 掩码mask)

(1) 按位与-- &

1 清零特定位 (mask中特定位置0,其它位为1,s=s&mask)

2 取某数中指定位 (mask中特定位置1,其它位为0,s=s&mask)

(2) 按位或-- |

    常用来将源操作数某些位置1,其它位不变。 (mask中特定位置1,其它位为0 s=s|mask)

(3) 位异或-- ^

1 使特定位的值取反 (mask中特定位置1,其它位为0 s=s^mask)

2 不引入第三变量,交换两个变量的值 (设 a=a1,b=b1)

    目 标           操 作              操作后状态

a=a1^b1         a=a^b              a=a1^b1,b=b1

b=a1^b1^b1      b=a^b              a=a1^b1,b=a1

a=b1^a1^a1      a=a^b              a=b1,b=a1

二进制补码运算公式:

-x = ~x + 1 = ~(x-1)

~x = -x-1

-(~x) = x+1

~(-x) = x-1

x+y = x - ~y - 1 = (x|y)+(x&y)

x-y = x + ~y + 1 = (x|~y)-(~x&y)

x^y = (x|y)-(x&y)

x|y = (x&~y)+y

x&y = (~x|y)-~x

x==y:    ~(x-y|y-x)

x!=y:    x-y|y-x

x< y:    (x-y)^((x^y)&((x-y)^x))

x<=y:    (x|~y)&((x^y)|~(y-x))

x< y:    (~x&y)|((~x|y)&(x-y))//无符号x,y比较

x<=y:    (~x|y)&((x^y)|~(y-x))//无符号x,y比较

应用举例

(1) 判断int型变量a是奇数还是偶数           

a&1   = 0 偶数

       a&1 =   1 奇数

(2) 取int型变量a的第k位 (k=0,1,2……sizeof(int)),即a>>k&1

(3) 将int型变量a的第k位清0,即a=a&~(1<<k)

(4) 将int型变量a的第k位置1, 即a=a|(1<<k)

(5) int型变量循环左移k次,即a=a<<k|a>>16-k   (设sizeof(int)=16)

(6) int型变量a循环右移k次,即a=a>>k|a<<16-k   (设sizeof(int)=16)

(7)整数的平均值

对于两个整数x,y,如果用 (x+y)/2 求平均值,会产生溢出,因为 x+y 可能会大于INT_MAX,但是我们知道它们的平均值是肯定不会溢出的,我们用如下算法:

int average(int x, int y)   //返回X,Y 的平均值

{   

     return (x&y)+((x^y)>>1);

}

(8)判断一个整数是不是2的幂,对于一个数 x >= 0,判断他是不是2的幂

boolean power2(int x)

{

    return ((x&(x-1))==0)&&(x!=0);

}

(9)不用temp交换两个整数

void swap(int x , int y)

{

    x ^= y;

    y ^= x;

    x ^= y;

}

(10)计算绝对值

int abs( int x )

{

int y ;

y = x >> 31 ;

return (x^y)-y ;        //or: (x+y)^y

}

(11)取模运算转化成位运算 (在不产生溢出的情况下)

         a % (2^n) 等价于 a & (2^n - 1)

(12)乘法运算转化成位运算 (在不产生溢出的情况下)

         a * (2^n) 等价于 a<< n

(13)除法运算转化成位运算 (在不产生溢出的情况下)

         a / (2^n) 等价于 a>> n

        例: 12/8 == 12>>3

(14) a % 2 等价于 a & 1       

(15) if (x == a) x= b;

            else x= a;

        等价于 x= a ^ b ^ x;

(16) x 的 相反数 表示为 (~x+1)

posted @ 2010-03-30 13:59 叶澍成 阅读(380) | 评论 (0)编辑 收藏
 

线程,是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始。运行run方法体中的那一段相对独立的过程。

线程的并发与并行

在过去的电脑都已单CPU作为主要的处理方式,无论是PC或者是服务器都是如此。系统调用某一个时刻只能有一个线程运行。当然这当中采用了比较多的策略来做时间片轮询。通过不断的调度切换来运行线程运行,而这种方式就叫做并发(concurrent)。

随着工艺水平的逐渐提升,CPU的技术也在不断增进。因此在如今多个CPU已经不是什么特别的,而大家常常以SMP的方式来形容多个CPU来处理两个或者两个以上的线程运行方式就称为并行(parallel)。

JAVA线程对象

                                          继承Thread,实现start()方法

要实现线程运行,JAVA中有两种方式:

                                      实现Runnable,然后再传递给Thread实例

注意:线程对象和线程是两个截然不同的概念。

线程对象JVM产生的一个普通的Object子类

线程是CPU分配给这个对象的一个运行过程

public class Test {

 public static void main(String[] args) throws Exception{

    MyThread mt = new MyThread();

    mt.start();

    mt.join();

    Thread.sleep(3000);

    mt.start();

 }

}

当线程对象mt运行完成后,我们让主线程休息一下,然后我们再次在这个线程对象上启动线程.结果我们看到:

Exception in thread "main" java.lang.IllegalThreadStateException

根本原因是在以下源代码中找出:

public synchronized void start() {

        if (started)
            throw new IllegalThreadStateException();

        started = true;

       group.add(this);

        start0();

 }

一个Thread的实例一旦调用start()方法,这个实例的started标记就标记为true,事实中不管这个线程后来有没有执行到底,只要调用了一次start()就再也没有机会运行了,这意味着:

【通过Thread实例的start(),一个Thread的实例只能产生一个线程】

interrupt()方法

当一个线程对象调用interrupt()方法,它对应的线程并没有被中断,只是改变了它的中断状态。使当前线程的状态变以中断状态,如果没有其它影响,线程还会自己继续执行。只有当线程执行到sleepwaitjoin等方法时,或者自己检查中断状态而抛出异常的情况下,线程才会抛出异常。

join()方法

join()方法,正如第一节所言,在一个线程对象上调用join方法,是当前线程等待这个线程对象对应的线程结束

例如:有两个工作,工作A要耗时10秒钟,工作B要耗时10秒或更多。我们在程序中先生成一个线程去做工作B,然后做工作A

        new B().start();//做工作B

A();//做工作A

工作A完成后,下面要等待工作B的结果来进行处理。如果工作B还没有完成我就不能进行下面的工作C,所以:

B b = new B();

b.start();//做工作B

A();//做工作A

b.join();//等工作B完成.

C();//继续工作C

原则:【join是测试其它工作状态的唯一正确方法】

yield()方法

yield()方法也是类方法,只在当前线程上调用,理由同上,它主是让当前线程放弃本次分配到的时间片,调用这个方法不会提高任何效率,只是降低了CPU的总周期上面介绍的线程一些方法,基于(基础篇)而言只能简单提及。以后具体应用中我会结合实例详细论述。

原则:【不是非常必要的情况下,没有理由调用它】

wait()notify()/notityAll()方法

首先明确一点他们的属于普通对象方法,并非是线程对象方法;其次它们只能在同步方法中调用。线程要想调用一个对象的wait()方法就要先获得该对象的监视锁,而一旦调用wait()后又立即释放该锁。

线程的互斥控制

多个线程同时操作某一对象时,一个线程对该对象的操作可能会改变其状态,而该状态会影响另一线程对该对象的真正结果。

synchornized关键字

把一个单元声明为synchornized,就可以让在同一时间只有一个线程操作该方法。作为记忆可以把synchronized看作是一个锁。但是我们要理解锁是被动的,还是主动的呢?换而言之它到底锁什么了?锁谁了?

例如:

synchronized(obj){

                 //todo…

}

如果代码运行到此处,synchronized首先获取obj参数对象的锁,若没有获取线程只能等待,如果多个线程运行到这只能有一个线程获取obj的锁,然后再执行{}中的代码。因此obj作用范围不同,控制程序也不同。

如果一个方法声明为synchornized的,则等同于把在为个方法上调用synchornized(this)

如果一个静态方法被声明为synchornized,则等同于把在为个方法上调用synchornized(.class)

 

真正的停止线程

要让一个线程得到真正意义的停止,需要了解当前的线程在干什么,如果线程当前没有做什么,那立刻让对方退出,当然是没有任何问题,但是如果对方正在手头赶工,那就必须让他停止,然后收拾残局。因此,首先需要了解步骤:

1.     正常运行;

2.       处理结束前的工作,也就是准备结束;

3.       结束退出。

注:以上部分概括出自某位牛人大哥的笔记,经常拜读他的博客
posted @ 2009-07-20 10:00 叶澍成 阅读(356) | 评论 (0)编辑 收藏
 

对于这本书的阅读,说来也很惭愧。过去黎敏基本对于他翻译过的书,都有邮寄送给我,书拿到手后,都是内心的高兴——哇,不用花钱的书,爽!(自己YY下)唯一要求就是能够读后能写个读后感,但是很多次都抱歉的忽悠了他。尽管如此他这次翻译的书还是一如既往的邮寄给我(当然也是在我厚脸皮的去索要的前提下,哈哈),同样答应写一篇读后感,可是迟到的读后感一直到现在才肯出炉,确实有点对不住他。这本书是在我每天早早挤车一个星期多读出来的,那个汽车真叫热啊,嘿嘿。切入正题,谈谈对于本书的一个看法和意见。

       这本书整体风格基本还是沿袭了第一版本的套路,把每个重点都写成一个条目来针对性的阐述,本书总共条目为七十八条(第一版书共有五十七条)。当中很多是在JDK5基础上作为第一版的更新(与第一版比较明显特征是把原有第一版的第五章,第六章的结构化特征和方法换成JDK5的新特性:泛型,枚举,方法)。

       这本书我到现在都怀疑出版社没有花很多时间在排版上,为什么这么说?在黎敏在翻译阶段也就有拿书的样稿给我看过,我第一看到就是封面问题——居然是黄色的,当时就跟他提出来,这个需要他和出版社去很好的斟酌一番。当时黎敏也说已经跟出版社商量过,哪知道最后拿到手上的居然还是“黄色”。可见出版社不知道是出于什么来考虑,让我来猜想下:难道是怕大伙都是色盲非要用黄色来提醒大家吗?更为失望的居然标题使用红色,晕啊!其次就要说书纸张也未免太扯淡了吧?我第一感觉纸张就是草稿纸一般,实在无语。在代码处理方面,显得不如第一版的那种爽朗,是不是出版社考虑节省纸张啊?非要把很多代码的间隔弄的特小,这样对于可读性来说确实很有疲劳感。所以这里向提醒以后的出版社——你忽悠是可以,但是别把读者当傻瓜。

       上面是谈到在书的编排和效果的问题。现在谈谈书中内容的一些感受。整体上说书翻译还是可以,不过当中也不乏一些乏味用词过当的问题,这里要说到最明显的就是书中出现很多在每一个条目后的总结词汇都或多或少带有“本条目”一词,个人觉得偶尔写写是没很大问题,但是过多重复显得机械化的审美疲劳,甚至有时候过多这样的词汇对于阅读流畅性稍微欠佳。像这样类似的词汇还有——“不严格地讲”,“简而言之”,这些词汇确实稍微影响阅读感。这里小纠下不爽或者错误的位置:P240处第二段第三行和第四行中出现两个“现在”,这个可能在校正时没有很好去润色。P216倒数第二段第三行有一个估计是印刷错误:【原】仅仅一个异常就会导致该方法不得不如果没有错的话,这个字应该是:处。

还有类似第二章谈到的:静态工厂方法与构造器不同的第三的优势在于,它们可以返回原返回类型的任何子类型的对象。就这句话,老实讲我真看了很久才明白啥意思。

       以上是谈到一些不足的细微之处,不过阅读此书后,确实对于以前一些不起眼的所谓了解语法也很好的得到一次重新的认识。比如以前在使用非检测警告上,以前很习惯的直接在整个类上直接使用标记表示;对于了解for-each的循环上得到进一步的认识;对于枚举类型的使用上更加灵活。这些都是个人对于此书泛读之后的一些浅薄的看法。如果对于译者有不敬之处还望原谅!

posted @ 2009-07-17 18:09 叶澍成 阅读(271) | 评论 (0)编辑 收藏
     摘要: Xml Schema的用途 1. 定义一个Xml文档中都有什么元素 2. 定义一个Xml文档中都会有什么属性 3. 定义某个节点的都有什么样的子节点,可以有多少个子节点,子节点出现的顺序 4. 定义元素或者属性的数据类型 5. 定义元素或者属性的默认值或者固定值 Xml Schema的根元素: <?xml version="1....  阅读全文
posted @ 2009-02-24 11:18 叶澍成| 编辑 收藏
引言                                       

HTTP是一个属于应用层的面向对象的协议,由于其简捷、快速的方式,适用于分布式超媒体信息系统。它于1990年提出,经过几年的
使用与发展,得到不断地完善和扩展。目前在WWW中使用的是HTTP/1.0的第六版,HTTP/1.1的规范化工作正在进行之中,而且HTTP-
NG(Next Generation of HTTP)的建议已经提出。
HTTP协议的主要特点可概括如下:
1.支持客户/服务器模式。
2.简单快速:客户向服务器请求服务时,只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服
务器联系的类型不同。由于HTTP协议简单,使得HTTP服务器的程序规模小,因而通信速度很快。
3.灵活:HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无连接:无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求,并收到客户的应答后,即断开连接。采用这种方
式可以节省传输时间。
5.无状态:HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息,则
它必须重传,这样可能导致每次连接传送的数据量增大。另一方面,在服务器不需要先前信息时它的应答就较快。

一、HTTP协议详解之URL篇

    http(超文本传输协议)是一个基于请求与响应模式的、无状态的、应用层的协议,常基于TCP的连接方
式,HTTP1.1版本中给出一种持续连接的机制,绝大多数的Web开发,都是构建在HTTP协议之上的Web应用。

HTTP URL (URL是一种特殊类型的URI,包含了用于查找某个资源的足够的信息)的格式如下:
http://host[":"port][abs_path]
http表示要通过HTTP协议来定位网络资源;host表示合法的Internet主机域名或者IP地址;port指定一个端口号,
为空则使用缺省端口80;abs_path指定请求资源的URI;如果URL中没有给出abs_path,那么当它作为请求URI
时,必须以“/”的形式给出,通常这个工作浏览器自动帮我们完成。
eg:
1、输入:
www.guet.edu.cn
浏览器自动转换成:http://www.guet.edu.cn/
2、http:192.168.0.116:8080/index.jsp 

二、HTTP协议详解之请求篇

    http请求由三部分组成,分别是:请求行、消息报头、请求正文

1、请求行以一个方法符号开头,以空格分开,后面跟着请求的URI和协议的版本,格式如下:Method Request-
URI HTTP-Version CRLF 
其中 Method表示请求方法;Request-URI是一个统一资源标识符;HTTP-Version表示请求的HTTP协议版本;
CRLF表示回车和换行(除了作为结尾的CRLF外,不允许出现单独的CR或LF字符)。

请求方法(所有方法全为大写)有多种,各个方法的解释如下:
GET     请求获取Request-URI所标识的资源
POST    在Request-URI所标识的资源后附加新的数据
HEAD    请求获取由Request-URI所标识的资源的响应消息报头
PUT     请求服务器存储一个资源,并用Request-URI作为其标识
DELETE  请求服务器删除Request-URI所标识的资源
TRACE   请求服务器回送收到的请求信息,主要用于测试或诊断
CONNECT 保留将来使用
OPTIONS 请求查询服务器的性能,或者查询与资源相关的选项和需求
应用举例:
GET方法:在浏览器的地址栏中输入网址的方式访问网页时,浏览器采用GET方法向服务器获取资源,
eg:GET /form.html HTTP/1.1 (CRLF)

POST方法要求被请求服务器接受附在请求后面的数据,常用于提交表单。
eg:POST /reg.jsp HTTP/ (CRLF)
Accept:image/gif,image/x-xbit,... (CRLF)
...
HOST:www.guet.edu.cn (CRLF)
Content-Length:22 (CRLF)
Connection:Keep-Alive (CRLF)
Cache-Control:no-cache (CRLF)
(CRLF)         //该CRLF表示消息报头已经结束,在此之前为消息报头
user=jeffrey&pwd=1234  //此行以下为提交的数据

HEAD方法与GET方法几乎是一样的,对于HEAD请求的回应部分来说,它的HTTP头部中包含的信息与通过
GET请求所得到的信息是相同的。利用这个方法,不必传输整个资源内容,就可以得到Request-URI所标识的资
源的信息。该方法常用于测试超链接的有效性,是否可以访问,以及最近是否更新。
2、请求报头后述
3、请求正文(略) 

三、HTTP协议详解之响应篇

    在接收和解释请求消息后,服务器返回一个HTTP响应消息。

HTTP响应也是由三个部分组成,分别是:状态行、消息报头、响应正文
1、状态行格式如下:
HTTP-Version Status-Code Reason-Phrase CRLF
其中,HTTP-Version表示服务器HTTP协议的版本;Status-Code表示服务器发回的响应状态代码;Reason-Phrase
表示状态代码的文本描述。
状态代码有三位数字组成,第一个数字定义了响应的类别,且有五种可能取值:
1xx:指示信息--表示请求已接收,继续处理
2xx:成功--表示请求已被成功接收、理解、接受
3xx:重定向--要完成请求必须进行更进一步的操作
4xx:客户端错误--请求有语法错误或请求无法实现
5xx:服务器端错误--服务器未能实现合法的请求
常见状态代码、状态描述、说明:
200 OK      //客户端请求成功
400 Bad Request  //客户端请求有语法错误,不能被服务器所理解
401 Unauthorized //请求未经授权,这个状态代码必须和WWW-Authenticate报                 //头域一起使用
403 Forbidden  //服务器收到请求,但是拒绝提供服务
404 Not Found  //请求资源不存在,eg:输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable  //服务器当前不能处理客户端的请求,一段时间后,                         //可能恢复正常
eg:HTTP/1.1 200 OK (CRLF)

2、响应报头后述

3、响应正文就是服务器返回的资源的内容 

四、HTTP协议详解之消息报头篇

    HTTP消息由客户端到服务器的请求和服务器到客户端的响应组成。请求消息和响应消息都是由开始行(对
于请求消息,开始行就是请求行,对于响应消息,开始行就是状态行),消息报头(可选),空行(只有
CRLF的行),消息正文(可选)组成。

HTTP消息报头包括普通报头、请求报头、响应报头、实体报头。
每一个报头域都是由名字+“:”+空格+值 组成,消息报头域的名字是大小写无关的。

1、普通报头
在普通报头中,有少数报头域用于所有的请求和响应消息,但并不用于被传输的实体,只用于传输的消息。
eg:
Cache-Control   用于指定缓存指令,缓存指令是单向的(响应中出现的缓存指令在请求中未必会出现),且是
独立的(一个消息的缓存指令不会影响另一个消息处理的缓存机制),HTTP1.0使用的类似的报头域为Pragma。
请求时的缓存指令包括:no-cache(用于指示请求或响应消息不能缓存)、no-store、max-age、max-stale、min-
fresh、only-if-cached;
响应时的缓存指令包括:public、private、no-cache、no-store、no-transform、must-revalidate、proxy-revalidate、
max-age、s-maxage.
eg:为了指示IE浏览器(客户端)不要缓存页面,服务器端的JSP程序可以编写如下:response.sehHeader
("Cache-Control","no-cache");
//response.setHeader("Pragma","no-cache");作用相当于上述代码,通常两者//合用
这句代码将在发送的响应消息中设置普通报头域:Cache-Control:no-cache


Date普通报头域表示消息产生的日期和时间

Connection普通报头域允许发送指定连接的选项。例如指定连接是连续,或者指定“close”选项,通知服务
器,在响应完成后,关闭连接

2、请求报头
请求报头允许客户端向服务器端传递请求的附加信息以及客户端自身的信息。
常用的请求报头
Accept
Accept请求报头域用于指定客户端接受哪些类型的信息。eg:Accept:image/gif,表明客户端希望接受GIF图象
格式的资源;Accept:text/html,表明客户端希望接受html文本。
Accept-Charset
Accept-Charset请求报头域用于指定客户端接受的字符集。eg:Accept-Charset:iso-8859-1,gb2312.如果在请求消
息中没有设置这个域,缺省是任何字符集都可以接受。
Accept-Encoding
Accept-Encoding请求报头域类似于Accept,但是它是用于指定可接受的内容编码。eg:Accept-Encoding:gzip.deflate.如果请求消息中没有设置这个域服务器假定客户端对各种内容编码都可以接受。
Accept-Language
Accept-Language请求报头域类似于Accept,但是它是用于指定一种自然语言。eg:Accept-Language:zh-cn.如果请
求消息中没有设置这个报头域,服务器假定客户端对各种语言都可以接受。
Authorization
Authorization请求报头域主要用于证明客户端有权查看某个资源。当浏览器访问一个页面时,如果收到服务器
的响应代码为401(未授权),可以发送一个包含Authorization请求报头域的请求,要求服务器对其进行验证。
Host(发送请求时,该报头域是必需的)
Host请求报头域主要用于指定被请求资源的Internet主机和端口号,它通常从HTTP URL中提取出来的,eg:
我们在浏览器中输入:
http://www.guet.edu.cn/index.html
浏览器发送的请求消息中,就会包含Host请求报头域,如下:
Host:
www.guet.edu.cn
此处使用缺省端口号80,若指定了端口号,则变成:Host:www.guet.edu.cn:指定端口号
User-Agent
我们上网登陆论坛的时候,往往会看到一些欢迎信息,其中列出了你的操作系统的名称和版本,你所使用的
浏览器的名称和版本,这往往让很多人感到很神奇,实际上,服务器应用程序就是从User-Agent这个请求报头
域中获取到这些信息。User-Agent请求报头域允许客户端将它的操作系统、浏览器和其它属性告诉服务器。不
过,这个报头域不是必需的,如果我们自己编写一个浏览器,不使用User-Agent请求报头域,那么服务器端就
无法得知我们的信息了。
请求报头举例:
GET /form.html HTTP/1.1 (CRLF)
Accept:image/gif,image/x-xbitmap,image/jpeg,application/x-shockwave-flash,application/vnd.ms-excel,application/vnd.ms-
powerpoint,application/msword,*/* (CRLF)
Accept-Language:zh-cn (CRLF)
Accept-Encoding:gzip,deflate (CRLF)
If-Modified-Since:Wed,05 Jan 2007 11:21:25 GMT (CRLF)
If-None-Match:W/"80b1a4c018f3c41:8317" (CRLF)
User-Agent:Mozilla/4.0(compatible;MSIE6.0;Windows NT 5.0) (CRLF)
Host:www.guet.edu.cn (CRLF)
Connection:Keep-Alive (CRLF)
(CRLF)

3、响应报头
响应报头允许服务器传递不能放在状态行中的附加响应信息,以及关于服务器的信息和对Request-URI所标识
的资源进行下一步访问的信息。
常用的响应报头
Location
Location响应报头域用于重定向接受者到一个新的位置。Location响应报头域常用在更换域名的时候。
Server
Server响应报头域包含了服务器用来处理请求的软件信息。与User-Agent请求报头域是相对应的。下面是
Server响应报头域的一个例子:
Server:Apache-Coyote/1.1
WWW-Authenticate
WWW-Authenticate响应报头域必须被包含在401(未授权的)响应消息中,客户端收到401响应消息时候,并发
送Authorization报头域请求服务器对其进行验证时,服务端响应报头就包含该报头域。
eg:WWW-Authenticate:Basic realm="Basic Auth Test!"  //可以看出服务器对请求资源采用的是基本验证机制。


4、实体报头
请求和响应消息都可以传送一个实体。一个实体由实体报头域和实体正文组成,但并不是说实体报头域和实体正文要在一起发送,可以只发送实体报头域。实体报头定义了关于实体正文(eg:有无实体正文)和请求所标识的资源的元信息。
常用的实体报头
Content-Encoding
Content-Encoding实体报头域被用作媒体类型的修饰符,它的值指示了已经被应用到实体正文的附加内容的编
码,因而要获得Content-Type报头域中所引用的媒体类型,必须采用相应的解码机制。Content-Encoding这样用
于记录文档的压缩方法,eg:Content-Encoding:gzip
Content-Language
Content-Language实体报头域描述了资源所用的自然语言。没有设置该域则认为实体内容将提供给所有的语言
阅读
者。eg:Content-Language:da
Content-Length
Content-Length实体报头域用于指明实体正文的长度,以字节方式存储的十进制数字来表示。
Content-Type
Content-Type实体报头域用语指明发送给接收者的实体正文的媒体类型。eg:
Content-Type:text/html;charset=ISO-8859-1
Content-Type:text/html;charset=GB2312
Last-Modified
Last-Modified实体报头域用于指示资源的最后修改日期和时间。
Expires
Expires实体报头域给出响应过期的日期和时间。为了让代理服务器或浏览器在一段时间以后更新缓存中(再次
访问曾访问过的页面时,直接从缓存中加载,缩短响应时间和降低服务器负载)的页面,我们可以使用Expires
实体报头域指定页面过期的时间。eg:Expires:Thu,15 Sep 2006 16:23:12 GMT
HTTP1.1的客户端和缓存必须将其他非法的日期格式(包括0)看作已经过期。eg:为了让浏览器不要缓存页
面,我们也可以利用Expires实体报头域,设置为0,jsp中程序如下:response.setDateHeader("Expires","0");

五、利用telnet观察http协议的通讯过程

    实验目的及原理:
    利用MS的telnet工具,通过手动输入http请求信息的方式,向服务器发出请求,服务器接收、解释和接受请求
后,会返回一个响应,该响应会在telnet窗口上显示出来,从而从感性上加深对http协议的通讯过程的认识。

    实验步骤:

1、打开telnet
1.1 打开telnet
运行-->cmd-->telnet

1.2 打开telnet回显功能
set localecho

2、连接服务器并发送请求
2.1 open
www.guet.edu.cn 80  //注意端口号不能省略

    HEAD /index.asp HTTP/1.0
    Host:www.guet.edu.cn
   
   /*我们可以变换请求方法,请求桂林电子主页内容,输入消息如下*/
    open
www.guet.edu.cn 80
  
    GET /index.asp HTTP/1.0  //请求资源的内容
    Host:www.guet.edu.cn  

2.2 open www.sina.com.cn 80  //在命令提示符号下直接输入telnet www.sina.com.cn 80
    HEAD /index.asp HTTP/1.0
    Host:www.sina.com.cn
 

3 实验结果:

3.1 请求信息2.1得到的响应是:

HTTP/1.1 200 OK                                              //请求成功
Server: Microsoft-IIS/5.0                                    //web服务器
Date: Thu,08 Mar 200707:17:51 GMT
Connection: Keep-Alive                                
Content-Length: 23330
Content-Type: text/html
Expries: Thu,08 Mar 2007 07:16:51 GMT
Set-Cookie: ASPSESSIONIDQAQBQQQB=BEJCDGKADEDJKLKKAJEOIMMH; path=/
Cache-control: private

//资源内容省略

3.2 请求信息2.2得到的响应是:

HTTP/1.0 404 Not Found       //请求失败
Date: Thu, 08 Mar 2007 07:50:50 GMT
Server: Apache/2.0.54 <Unix>
Last-Modified: Thu, 30 Nov 2006 11:35:41 GMT
ETag: "6277a-415-e7c76980"
Accept-Ranges: bytes
X-Powered-By: mod_xlayout_jh/0.0.1vhs.markII.remix
Vary: Accept-Encoding
Content-Type: text/html
X-Cache: MISS from zjm152-78.sina.com.cn
Via: 1.0 zjm152-78.sina.com.cn:80<squid/2.6.STABLES-20061207>
X-Cache: MISS from th-143.sina.com.cn
Connection: close


失去了跟主机的连接

按任意键继续...


4 .注意事项:1、出现输入错误,则请求不会成功。
          2、报头域不分大小写。
          3、更深一步了解HTTP协议,可以查看RFC2616,在
http://www.letf.org/rfc上找到该文件。
          4、开发后台程序必须掌握http协议

 

六、HTTP协议相关技术补充

    1、基础:
    高层协议有:文件传输协议FTP、电子邮件传输协议SMTP、域名系统服务DNS、网络新闻传输协议NNTP和
HTTP协议等
中介由三种:代理(Proxy)、网关(Gateway)和通道(Tunnel),一个代理根据URI的绝对格式来接受请求,重写全部
或部分消息,通过 URI的标识把已格式化过的请求发送到服务器。网关是一个接收代理,作为一些其它服务
器的上层,并且如果必须的话,可以把请求翻译给下层的服务器协议。一 个通道作为不改变消息的两个连接
之间的中继点。当通讯需要通过一个中介(例如:防火墙等)或者是中介不能识别消息的内容时,通道经常被使
用。
     代理(Proxy):一个中间程序,它可以充当一个服务器,也可以充当一个客户机,为其它客户机建立请求。
请求是通过可能的翻译在内部或经过传递到其它的 服务器中。一个代理在发送请求信息之前,必须解释并且
如果可能重写它。代理经常作为通过防火墙的客户机端的门户,代理还可以作为一个帮助应用来通过协议处
理没有被用户代理完成的请求。
网关(Gateway):一个作为其它服务器中间媒介的服务器。与代理不同的是,网关接受请求就好象对被请求的
资源来说它就是源服务器;发出请求的客户机并没有意识到它在同网关打交道。
  网关经常作为通过防火墙的服务器端的门户,网关还可以作为一个协议翻译器以便存取那些存储在非
HTTP系统中的资源。
    通道(Tunnel):是作为两个连接中继的中介程序。一旦激活,通道便被认为不属于HTTP通讯,尽管通道可能
是被一个HTTP请求初始化的。当被中继 的连接两端关闭时,通道便消失。当一个门户(Portal)必须存在或中介
(Intermediary)不能解释中继的通讯时通道被经常使用。


2、协议分析的优势—HTTP分析器检测网络攻击
以模块化的方式对高层协议进行分析处理,将是未来入侵检测的方向。
HTTP及其代理的常用端口80、3128和8080在network部分用port标签进行了规定

3、HTTP协议Content Lenth限制漏洞导致拒绝服务攻击
使用POST方法时,可以设置ContentLenth来定义需要传送的数据长度,例如ContentLenth:999999999,在传送完
成前,内 存不会释放,攻击者可以利用这个缺陷,连续向WEB服务器发送垃圾数据直至WEB服务器内存耗
尽。这种攻击方法基本不会留下痕迹。
http://www.cnpaf.net/Class/HTTP/0532918532667330.html


4、利用HTTP协议的特性进行拒绝服务攻击的一些构思
服务器端忙于处理攻击者伪造的TCP连接请求而无暇理睬客户的正常请求(毕竟客户端的正常请求比率非常之
小),此时从正常客户的角度看来,服务器失去响应,这种情况我们称作:服务器端受到了SYNFlood攻击(SYN洪水攻击)。
而Smurf、TearDrop等是利用ICMP报文来Flood和IP碎片攻击的。本文用“正常连接”的方法来产生拒绝服务攻击。
19端口在早期已经有人用来做Chargen攻击了,即Chargen_Denial_of_Service,但是!他们用的方法是在两台
Chargen 服务器之间产生UDP连接,让服务器处理过多信息而DOWN掉,那么,干掉一台WEB服务器的条件就
必须有2个:1.有Chargen服务2.有HTTP 服务
方法:攻击者伪造源IP给N台Chargen发送连接请求(Connect),Chargen接收到连接后就会返回每秒72字节的
字符流(实际上根据网络实际情况,这个速度更快)给服务器。


5、Http指纹识别技术
   Http指纹识别的原理大致上也是相同的:记录不同服务器对Http协议执行中的微小差别进行识别.Http指纹识
别比TCP/IP堆栈指纹识别复杂许 多,理由是定制Http服务器的配置文件、增加插件或组件使得更改Http的响应
信息变的很容易,这样使得识别变的困难;然而定制TCP/IP堆栈的行为 需要对核心层进行修改,所以就容易识
别.
      要让服务器返回不同的Banner信息的设置是很简单的,象Apache这样的开放源代码的Http服务器,用户可以在
源代码里修改Banner信息,然 后重起Http服务就生效了;对于没有公开源代码的Http服务器比如微软的IIS或者
是Netscape,可以在存放Banner信息的Dll文件中修 改,相关的文章有讨论的,这里不再赘述,当然这样的修改的效果
还是不错的.另外一种模糊Banner信息的方法是使用插件。
常用测试请求:
1:HEAD/Http/1.0发送基本的Http请求
2:DELETE/Http/1.0发送那些不被允许的请求,比如Delete请求
3:GET/Http/3.0发送一个非法版本的Http协议请求
4:GET/JUNK/1.0发送一个不正确规格的Http协议请求
Http指纹识别工具Httprint,它通过运用统计学原理,组合模糊的逻辑学技术,能很有效的确定Http服务器的类型.它
可以被用来收集和分析不同Http服务器产生的签名。


6、其他:为了提高用户使用浏览器时的性能,现代浏览器还支持并发的访问方式,浏览一个网页时同时建立
多个连接,以迅速获得一个网页上的多个图标,这样能更快速完成整个网页的传输。
HTTP1.1中提供了这种持续连接的方式,而下一代HTTP协议:HTTP-NG更增加了有关会话控制、丰富的内容
协商等方式的支持,来提供
更高效率的连接。

posted @ 2009-02-17 17:26 叶澍成 阅读(207) | 评论 (0)编辑 收藏