lijie250 http://lijie250.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Apache集群功能 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/161339  发表时间: 2008年02月03日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！


下面以在apachemod_proxy下做的反向代理负载均衡为配置实例：在站点www.test.com，我们按提供的内容进行分类，不同的服务器用于提供不同的内容服务，将对http://www.test.com/news的访问转到IP地址为192.168.1.1的内部服务器上处理，对http://www.test.com/it的访问转到服务器192.168.1.2上，对http://www.test.com/life的访问转到服务器192.168.1.3上，对http://www.test.com/love的访问转到合作站点http://www.love.com上，从而减轻本apache服务器的负担，达到负载均衡的目的。
　　首先要确定域名www.test.com在DNS上的记录对应apache服务器接口上具有internet合法注册的IP地址，这样才能使internet上对www.test.com的所有连接请求发送给本台apache服务器。
　　在本台服务器的apache配置文件httpd.conf中添加如下设置：
　　proxypass     /news      http://192.168.1.1
　　proxypass     /it      http://192.168.1.2
　　proxypass     /life     http://192.168.1.3
　　proxypass     /live     http://www.live.com
　　注意，此项设置最好添加在httpd.conf文件“Section 2”以后的位置，服务器192.168.1.1-3也应是具有相应功能的www服务器，在重启服务时，最好用apachectl configtest命令检查一下配置是否有误。

接下来也是我真正想要介绍的2.2版本后在mod_proxy中新添加的mod_proxy_balancer模块给我们带来的新功能。

首先将在主配置文件http.conf以下Module的注释去掉
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_balancer_module modules/mod_proxy_balancer.so
LoadModule proxy_http_module modules/mod_proxy_http.so

再并增加以下元素
ProxyRequests Off
ProxyPass /test  balancer://xuanfei stickysession=jsessionid nofailover=On
<proxy balancer://xuanfei/>
    BalancerMember http://192.168.28.131  loadfactor=1
    BalancerMember http://192.168.28.130  loadfactor=1
</proxy>
ProxyPass为代理转发的Url,即将所有访问/test的请求转发到群集balancer://xuanfei
loadfactor为各主机间的负载比例参数，可是设置不同指数
BalancerMember为群集的成员，即群集服务器A或B，负载均衡服务器会根据均衡规则来将请求转发给BalancerMember。


配置好后，启动Apahce服务<Location /server-status>
SetHandler server-status
Order Deny,Allow
Deny from all
Allow from all
</Location>
访问xuanfei/test就会看到群集服务器中应用返回的结果。恭喜你，负载均衡和群集已经配置成功了!

而且还可以同样在http.conf主配置文件主添如下元素：
<Location /balancer-manager>
SetHandler balancer-manager
Order Deny,Allow
Deny from all
Allow from all
</Location>
如果配置成功后你可以可以在地址栏输入 xuanfei/balancer-manager,将可以清楚的看到各节点的工作运行状态：）

同样还可以同样在http.conf主配置文件主添如下元素：
<Location /server-status>
SetHandler server-status
Order Deny,Allow
Deny from all
Allow from all
</Location>
便可以方便的观测到主服务器的当前运行状态，只要在地址栏输入 xuanfei/server-status

用ab对apache负载均衡集群的性能测试对比报告

　　小结：apache自带mod_proxy功能模块中目前可以实现两种不同的负载均衡集群实现方式，第一种是分工合作的的形式，通过各台主机负责不同的任务而实现任务分工。第二种是不同的机器在担任同样的任务，某台机器出现故障主机可以自动检测到将不会影响到客户端，而第一种却不能实现但第一种实现方式的优点在于他是主服务器负担相应没第二种大因为台只是提供跳转指路功能，形象的说他不给你带路只是告诉你有条路可以到，但到了那是否可以看到你见的人他已经不会去管你了：）。相比之下第二种性能要比第一种会好很多；但他们都有个共同点都是一托N形式来完成任务的所以你的主机性能一定要好。

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 03 Feb 2008 20:03:00 +0800 http://lijie250.javaeye.com/blog/161339 http://lijie250.javaeye.com/blog/161339 使用jsvc编写tomcat5自启动安全脚本 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/146286  发表时间: 2007年12月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1．安装jsvc
#cd /usr/local/xiaobai/apache-tomcat-5.5.20/bin
#tar xvfz jsvc.tar.gz
#cd jsvc-src
#sh support/buildconf.sh
#chmod 755 configure
#./configure --with-java=/usr/local/xiaobai/jdk1.5.0_09 (改成你的JDK的位置)
#make

2、添加脚本让tomcat自动启动
#useradd tomcat5 添加用户
#groupadd tomcat　　添加组
#usermod -G tomcat tomcat5　　把tomcat5加入tomcat组

#chown -R tomcat5 /usr/local/xiaobai/apache-tomcat-5.5.20
设置用户tomcat5对tomcat的权限

#cp /usr/local/xiaobai/apache-tomcat-5.5.20/bin/jsvc-src/native/Tomcat5.sh /etc/init.d/tomcat
移动文件tomcat5.sh到/etc/init.d/里面并改名为tomcat

#chmod 755 /etc/init.d/tomcat
#vi /etc/init.d/tomcat

删除原有内容添加如下内容

#!/bin/sh
#
# Startup Script for Tomcat5
#
# chkconfig: 345 88 14
# description: Tomcat Daemon
# processname: jsvc
# pidfile: /var/run/jsvc.pid
# config:
#
# Source function library.
. /etc/rc.d/init.d/functions
#
prog=tomcat
#
JAVA_HOME=/usr/local/xiaobai/jdk1.5.0_09
CATALINA_HOME=/usr/local/xiaobai/apache-tomcat-5.5.20
DAEMON_HOME=/usr/local/xiaobai/apache-tomcat-5.5.20/bin
#TOMCAT_USER=tomcat5
TOMCAT_USER=tomcat5

# for multi instances adapt those lines.
TMP_DIR=/var/tmp
PID_FILE=/var/run/jsvc.pid
CATALINA_BASE=/usr/local/xiaobai/apache-tomcat-5.5.20

CATALINA_OPTS=
CLASSPATH=\
$JAVA_HOME/lib/tools.jar:\
$CATALINA_HOME/bin/commons-daemon.jar:\
$CATALINA_HOME/bin/bootstrap.jar

case "$1" in
start)
#
# Start Tomcat
#
$DAEMON_HOME/jsvc-src/jsvc \
-user $TOMCAT_USER \
-home $JAVA_HOME \
-Dcatalina.home=$CATALINA_HOME \
-Dcatalina.base=$CATALINA_BASE \
-Djava.io.tmpdir=$TMP_DIR \
-wait 10 \
-pidfile $PID_FILE \
-outfile $CATALINA_HOME/logs/catalina.out \
-errfile '&1' \
$CATALINA_OPTS \
-cp $CLASSPATH \
org.apache.catalina.startup.Bootstrap
#
# To get a verbose JVM
#-verbose \
# To get a debug of jsvc.
#-debug \
exit $?
;;

stop)
#
# Stop Tomcat
#
$DAEMON_HOME/jsvc-src/jsvc \
-stop \
-pidfile $PID_FILE \
org.apache.catalina.startup.Bootstrap
exit $?
;;

*)
echo "Usage tomcat.sh start/stop"
exit 1;;
esac

#service tomcat start 测试tomcat能不能启动
#chkconfig tomcat on 　
#chkconfig --list tomcat
完成自启动脚本

注意：
在tomcat文件的头两行的注释语句中，需要包含chkconfig和description两部分内容(确认不要拼写错误，)，否则在执行“chkconfig --add tomcat”时，会出现“tomcat服务不支持chkconfig”的错误提示。
chkconfig这行表示缺省启动的运行级别以及启动和停止的优先级，如该服务缺省不再任何运行级启动，则以 - 代替运行级别。在tomcat中表示脚本在运行级2、3、4、5启动，启动优先权为10，停止优先权为90。
description行对服务进行描述，可以用 “\” 跨行注释。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 05 Dec 2007 20:37:27 +0800 http://lijie250.javaeye.com/blog/146286 http://lijie250.javaeye.com/blog/146286 JAVA中对象创建和初始化过程 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/145149  发表时间: 2007年11月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

分析一下JAVA中对象创建和初始化过程中涉及的相关概念问题，java中栈(stack)与堆(heap)，对象、引用、句柄的概念。

　　@Author:ZJ 06-11-25

　　Blog: http://zhangjunhd.blog.51cto.com/

　　1.Java中的数据类型

　　Java中有3个数据类型：基本数据类型(在Java中，boolean、byte、short、int、long、char、float、double这八种是基本数据类型)、引用类型和null类型。其中，引用类型包括类类型(含数组)、接口类型。

　　下列语句声明了一些变量：

以下是引用片段：
　　int k ;
　　A a; //a是A数据类型的对象变量名。
　　B b1,b2,…,b10000;// 假定B是抽象类或接口。
　　String s;


　　注意：从数据类型与变量的角度看，基本数据类型变量k、类类型变量a和s、抽象类或接口类型变量b(1万个)，它们都是变量(标识符)。

　　2.关于句柄(handle)

　　为了区别引用类型的变量标识符和基本数据类型变量标识符，我们特别的使用Handle来称呼引用类型的变量标识符。上面例子中b1至b10000、a、s都是Handle。Handle直观的看就是手柄、把手，我们采用计算机界常用的中文翻译“句柄”。

　　2.1【Windows编程中的】句柄的含义

　　句柄是WONDOWS用来标识被应用程序所建立或使用的对象的唯一整数，WINDOWS使用各种各样的句柄标识诸如应用程序实例，窗口，控制，位图，GDI对象等等。WINDOWS句柄有点象C语言中的文件句柄。

　　从上面的定义中的我们可以看到，句柄是一个标识符，是拿来标识对象或者项目的，它就象我们的姓名一样，每个人都会有一个，不同的人的姓名不一样，但是，也可能有一个名字和你一样的人。从数据类型上来看它只是一个16位的无符号整数。应用程序几乎总是通过调用一个WINDOWS函数来获得一个句柄，之后其他的WINDOWS函数就可以使用该句柄，以引用相应的对象。

　　如果想更透彻一点地认识句柄，我可以告诉大家，句柄是一种指向指针的指针。我们知道，所谓指针是一种内存地址。应用程序启动后，组成这个程序的各对象是驻留在内存的。如果简单地理解，似乎我们只要获知这个内存的首地址，那么就可以随时用这个地址访问对象。但是，如果您真的这样认为，那么您就大错特错了。我们知道，Windows是一个以虚拟内存为基础的操作系统。在这种系统环境下，Windows内存管理器经常在内存中来回移动对象，依此来满足各种应用程序的内存需要。对象被移动意味着它的地址变化了。如果地址总是如此变化，我们该到哪里去找该对象呢?

　　为了解决这个问题，Windows操作系统为各应用程序腾出一些内存储地址，用来专门登记各应用对象在内存中的地址变化，而这个地址(存储单元的位置)本身是不变的。Windows内存管理器在移动对象在内存中的位置后，把对象新的地址告知这个句柄地址来保存。这样我们只需记住这个句柄地址就可以间接地知道对象具体在内存中的哪个位置。这个地址是在对象装载(Load)时由系统分配给的，当系统卸载时(Unload)又释放给系统。

　　句柄地址(稳定)→记载着对象在内存中的地址────→对象在内存中的地址(不稳定)→实际对象

　　2.2Java中句柄的意义

　　对句柄以前的【Windows编程中的】含义有了深刻的认识，我们可以说Handle是一个我们学习Java时非常需要的术语。它的意义在于区别“对象本身”和对象变量(或者严格点：对象所属的数据类型的变量标识符)。

　　2.3回到1中的变量声明：

　　现在，你应该对下面的注释一目了然。

　　int k, j ;//k里面存放的是一个整型数。

　　A a; //a里面存放地址。

　　B b1,b2,…,b10000;// b1，…，b10000里面存放地址。

　　String s; //s里面存放地址。

　　3.关于引用(reference)

　　什么是“引用”? “the identifier you manipulate is actually a ‘reference’ to an object”。(Thinking in Java 2e )

　　翻译是：你操纵的标识符实际上是一个对象的“引用”。或者精确些，翻译成：你操作的标识符实际上是指向一个对象的“引用”。显然，原文中reference是一个有方向感的东西。

　　回到Java中来，引用可以想象成对象的身份证号码、对象的ID或者对象的手机号码。当然，更多的说法是，引用是对象在内存中住的房间号码。直观的说，对象的引用是创建对象时的返回值!引用是new表达式的返回值。

　　new A(); 这里真正创建了一个对象，但我们没有用句柄去持有(hold、拿着、保存)该引用。从微观上看，new表达式完成了对象初始化的任务(三步曲，下文详细分析)，整体上看则返回一个引用。

　　再次回到1中的变量声明，再看看下面的注释。

　　A a; //声明句柄a，但未初始化，所以里面的值为null。

　　B b1,b2,…,b10000;// 声明句柄b1，…，b10000，但未初始化，所以里面的值为null。

　　String s; //声明句柄s，但未初始化，所以里面的值为null。

　　4.句柄与引用的关系

　　A a;//声明句柄a，值为null

　　a=new A();//句柄的初始化(句柄 = 引用;即把引用赋值给句柄)

　　引用：new A()的值。引用可以简单的看作对象占据内存空间的地址;通过对象的引用，就可以方便的与其他对象区别开来，引用就是对象独特的身份标识。

　　完成句柄的初始化后，就可以用句柄遥控对象了。

　　当然，这只是从一方面解释对象的创建和初始化，理解了句柄和引用的关系后，下面分析对象初始化的整个过程。先做以下准备工作，说说栈与堆。

　　5.java中栈(stack)与堆(heap)

　　在java中内存分为“栈”和“堆”这两种(Stack and Heap).基本数据类型存储在“栈”中，对象引用类型实际存储在“堆”中，在栈中只是保留了引用内存的地址值。

　　顺便说说“==”与“equals()方法”，以帮助理解两者(Stack and Heap)的概念。

　　在Java中利用"=="比较变量时候，系统使用变量在stack(栈)中所存的值来作为对比的依据，基本数据类型在stack中所存的值就是其內容值，而引用类型在stack中所存放的值是本身所指向Heap中对象的地址值。 Java.lang包中的Object类有public boolean equals (Object obj)方法。它比较两个对象是否相等。仅当被比较的两个引用指向同一对象时(句柄相等)，对象的equals()方法返回true。(至于String类的equals()方法，它重写(override)equals()方法，不在本文讨论之列。)

　　6.对象的创建和初始化过程

　　在java中对象就是类的实例。在一般情况下，当把一个类实例化时，此类的所有成员，包括变量和方法，都被复制到属于此数据类型的一个新的实例中去。分析以下两段代码。

　　6.1 Vehicle veh1 = new Vehicle();

　　上面的语句做了如下的事情：

　　①右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象(也简称为Vehicle对象)。

　　②末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果没创建，Java会补上一个默认的构造函数。

　　③左边的“Vehicle veh1”创建了一个Vehicle类引用变量。

　　④“=”操作符使对象引用指向刚创建的那个Vehicle对象。(回想一下句柄与引用)

　　将上面的语句分为两个步骤：

　　Vehicle veh1;

　　veh1 = new Vehicle();

　　这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。在堆空间里创建的实体，与在栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是似乎很难准确的“抓”住它。我们仔细研究一下第二句，找找刚创建的对象叫什么名字?有人说，它叫“Vehicle”。不对，“Vehicle”是类(对象的创建模板)的名字。一个Vehicle类可以据此创建出无数个对象，这些对象不可能全叫“Vehicle”。对象连名都没有，没法直接访问它。我们只能通过对象引用来间接访问对象。

　　6.2 Vehicle veh2;

　　veh2 = veh1;

　　由于veh1和veh2只是对对象的引用，第二行所做的不过是把veh1的引用(地址)赋值给veh2，使得veh1和veh2同时指向唯一的一个Vehicle对象。

　　6.3 veh2 = new Vehicle();

　　则引用变量veh2改指向第二个对象。

　　从以上叙述再推演下去，我们可以获得以下结论：①一个对象引用可以指向0个或1个对象;②一个对象可以有N个引用指向它。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 30 Nov 2007 16:43:09 +0800 http://lijie250.javaeye.com/blog/145149 http://lijie250.javaeye.com/blog/145149 请求重定向与请求转发的比较 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/145137  发表时间: 2007年11月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

尽管HttpServletResponse.sendRedirect方法和RequestDispatcher.forward方法都可以让浏览器获得另外一个URL所指向的资源，但两者的内部运行机制有着很大的区别。下面是HttpServletResponse.sendRedirect方法实现的请求重定向与RequestDispatcher.forward方法实现的请求转发的总结比较：

（1）RequestDispatcher.forward方法只能将请求转发给同一个WEB应用中的组件；而HttpServletResponse.sendRedirect 方法不仅可以重定向到当前应用程序中的其他资源，还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。如果传递给HttpServletResponse.sendRedirect 方法的相对URL以“/”开头，它是相对于整个WEB站点的根目录；如果创建RequestDispatcher对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。

（2）调用HttpServletResponse.sendRedirect方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；而调用RequestDispatcher.forward 方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。

（3）HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的 访问请求，这个过程好比有个绰号叫“浏览器”的人写信找张三借钱，张三回信说没有钱，让“浏览器”去找李四借，并将李四现在的通信地址告诉给了“浏览器”。于是，“浏览器”又按张三提供通信地址给李四写信借钱，李四收到信后就把钱汇给了“浏览器”。可见，“浏览器”一共发出了两封信和收到了两次回复， “浏览器”也知道他借到的钱出自李四之手。RequestDispatcher.forward方 法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。这个过程好比绰号叫“浏览器”的人写信找张三借钱，张三没有钱，于是张三找李四借了一些钱，甚至还可以加上自己的一些钱，然后再将这些钱汇给了“浏览器”。可见，“浏览器”只发 出了一封信和收到了一次回复，他只知道从张三那里借到了钱，并不知道有一部分钱出自李四之手。

（4）RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；而HttpServletResponse.sendRedirect方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。对于同一个WEB应用程序的内部资源之间的跳转，特别是跳转之前要对请求进行一些前期预处理，并要使用HttpServletRequest.setAttribute方法传递预处理结果，那就应该使用RequestDispatcher.forward方法。不同WEB应用程序之间的重定向，特别是要重定向到另外一个WEB站点上的资源的情况，都应该使用HttpServletResponse.sendRedirect方法。

（5）无论是RequestDispatcher.forward方法，还是HttpServletResponse.sendRedirect方法，在调用它们之前，都不能有内容已经被实际输出到了客户端。如果缓冲区中已经有了一些内容，这些内容将被从缓冲区中清除。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 30 Nov 2007 16:14:40 +0800 http://lijie250.javaeye.com/blog/145137 http://lijie250.javaeye.com/blog/145137 Ajax+servlet无刷新验证用户名 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/142990  发表时间: 2007年11月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

页面端(login.jsp):

  1. <%@ page language="java" import="java.util.*" pageEncoding="gb2312"%>   
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">   
  3. <html>   
  4.  <head>   
  5.  <TITLE>Ajax验证用户名是否存在例子</TITLE>   
  6.  <script>   
  7.     
  8.  //设一个变量   
  9.     
  10.  var XMLHttpReq=false;   
  11.   //创建一个XMLHttpRequest对象   
  12.   function createXMLHttpRequest(){   
  13.     if(window.XMLHttpRequest){ //Mozilla    
  14.      XMLHttpReq=new XMLHttpRequest();   
  15.      }   
  16.      else if(window.ActiveXObject){   
  17.       try{   
  18.        XMLHttpReq=new ActiveXObject("Msxml2.XMLHTTP");   
  19.        }catch(e){   
  20.         try{   
  21.          XMLHttpReq=new ActiveXObject("Microsoft.XMLHTTP");   
  22.          }catch(e){}   
  23.          }   
  24.         }   
  25.        }   
  26.   //发送请求函数   
  27.   function send(url){   
  28.    createXMLHttpRequest();   
  29.    XMLHttpReq.open("get",url,true);   
  30.    XMLHttpReq.onreadystatechange=proce;   //指定响应的函数   
  31.    XMLHttpReq.send(null);  //发送请求   
  32.    }   
  33.   function proce(){   
  34.    if(XMLHttpReq.readyState==4){ //对象状态   
  35.     if(XMLHttpReq.status==200){//信息已成功返回，开始处理信息       
  36.                 <!--测试读取xml开始-->   
  37.     var root=XMLHttpReq.responseXML;   
  38.     var res=root.getElementsByTagName("content")[0].firstChild.data;   
  39.     window.alert(res);    
  40.      <!--测试读取xml结束-->      
  41.     //var xmlReturn = XMLHttpReq.responseText;   
  42.     //window.alert(xmlReturn);   
  43.     }else{   
  44.      window.alert("所请求的页面有异常");   
  45.      }   
  46.      }   
  47.      }   
  48.   //身份验证    
  49.   function check(){   
  50.    var name=document.getElementById("name").value;   
  51.        
  52.     if(name==""){   
  53.      alert("请输入姓名!");   
  54.      return false;   
  55.      }   
  56.      else{   
  57.       //send('login?name='+name);     
  58.       document.getElementById("load").style.display='';       
  59.       send('login.do?name='+name);    
  60.       document.getElementById("load").style.display='none';             
  61.       }   
  62.      }   
  63.         
  64.   </script>   
  65.  </head>   
  66.     
  67.  <body>   
  68.  <form action="login" method="post">   
  69.   <table>   
  70.       <tr><td>姓名:&nbsp;<input id="name" type="text" name="name"/><p>   
  71.        <div id=load style="display:none; position:absolute;right:0px;top:0px;background:#FF5B5B;border:1px solid">正在验证用户名,请稍后……</div><p>   
  72.          <input type="button" value="检测!" onClick="check()"/>   
  73.       </td>   
  74.      </tr>   
  75.      </table>   
  76.      </form>   
  77.  </body>   
  78. </html>   
js 代码

AjaxServlet.java

java 代码
  1. import java.io.IOException;   
  2. import java.io.PrintWriter;   
  3. import javax.servlet.ServletException;   
  4. import javax.servlet.http.HttpServlet;   
  5. import javax.servlet.http.HttpServletRequest;   
  6. import javax.servlet.http.HttpServletResponse;   
  7.   
  8.   
  9. public class AjaxServlet extends HttpServlet {   
  10. Logger log = Logger.getLogger(this.getClass());   
  11. public void doGet(HttpServletRequest request, HttpServletResponse response)   
  12.     throws ServletException,IOException {   
  13.    response.setContentType("text/xml; charset=GBK");   
  14.    PrintWriter out = response.getWriter();   
  15.      out.print(2);   
  16.     }   
  17. }   
  18. //Process the HTTP Post request   
  19. public void doPost(HttpServletRequest request, HttpServletResponse response)   
  20.     throws ServletException, IOException {   
  21.    doGet(request, response);   
  22. }   
  23.   
  24. //Process the HTTP Put request   
  25. public void doPut(HttpServletRequest request, HttpServletResponse response)   
  26.     throws ServletException, IOException {   
  27. }   
  28.   
  29. //Process the HTTP Delete request   
  30. public void doDelete(HttpServletRequest request,   
  31.     HttpServletResponse response) throws ServletException, IOException {   
  32. }   
  33.   
  34. //Clean up resources   
  35. public void destroy() {   
  36. }   
  37. }   
  38.   

这只是个基本样子和原理

大致大家可以参照这三个就可以了！

http://hi.baidu.com/k_boy/blog/item/04430d08b66349d362d986b6.html
http://blog.lough.com.cn/post/189.htm
http://www.openforge.cn/html/ajax/20071017/26271.html
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 23 Nov 2007 11:14:26 +0800 http://lijie250.javaeye.com/blog/142990 http://lijie250.javaeye.com/blog/142990 随机数字验证码的生成 lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/126152  发表时间: 2007年09月22日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

有时候在我们的网络应用中，防止程序自动登录搞破坏，我们一般都会加上验证码，这些验证码一般来说都是由人来识别的，当然，如果验证码很有规律，或者说很清楚，漂亮，那么也是可能被程序识别的，我以前就识别过某网站的验证码，因为比较有规律，所以被识别了，并且识别率达到99%左右，其实我们可以制作很复杂一点的验证码，添加一些干扰的线条或者字体变形，使程序识别的难度加大，这样，我们的目的也就达到了.

下面是生成的图片：


代码如下，JSP代码

java 代码
  1. <%@page contentType="image/jpeg"%>   
  2. <%@page pageEncoding="UTF-8"%>   
  3. <%@ page import="java.awt.*,javax.imageio.*,java.io.*,java.util.*,java.awt.image.*" %>   
  4. <%--   
  5. The taglib directive below imports the JSTL library. If you uncomment it,   
  6. you must also add the JSTL library to the project. The Add Library action   
  7. on Libraries node in Projects view can be used to add the JSTL 1.1 library.   
  8. --%>   
  9. <%--   
  10. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>    
  11. --%>   
  12.   
  13. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  
  14. "http://www.w3.org/TR/html4/loose.dtd">   
  15. <%!String s="";%>   
  16. <%   
  17. java.util.List<String> fonts=new ArrayList<String>();   
  18. GraphicsEnvironment.getLocalGraphicsEnvironment().preferLocaleFonts();   
  19. String[] names=GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames(Locale.CHINA);   
  20. for(String s:names){   
  21.     char c=s.charAt(0);   
  22.     if(Character.isLowerCase(c)||Character.isUpperCase(c)){   
  23.            
  24.     }else{   
  25.         fonts.add(s);   
  26.     }   
  27. }   
  28. BufferedImage bi=new BufferedImage(200,50,BufferedImage.TYPE_INT_RGB);   
  29. Graphics2D g=bi.createGraphics();   
  30. char[] cs={'0','1','2','3','4','5','6','7','8','9'};   
  31. char[] use=new char[4];   
  32. g.setColor(new Color(240,240,240));   
  33. g.fillRect(0,0,200,50);   
  34. for(int i=0;i<4;i++){   
  35.     Point p=new Point(5+(i*((int)(Math.random()*10)+40)),40);   
  36.     int size=0;   
  37.     int[] sizes=new int[20];   
  38.     for(int j=0;j<20;j++){   
  39.         sizes[j]=30+j;   
  40.     }   
  41.     size=sizes[(int)(Math.random()*sizes.length)];   
  42.     int face=0;   
  43.     if(Math.random()*10>5){   
  44.         face=Font.BOLD;   
  45.     }else{   
  46.         face=Font.ITALIC;   
  47.     }   
  48.     use[i]=cs[(int)(Math.random()*cs.length)];   
  49.     g.setPaint(new GradientPaint(p.x,p.y,new Color((int)(Math.random()*256),0,(int)(Math.random()*256)),   
  50.             p.x,p.y-size,new Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256))));   
  51.     g.setFont(new Font(fonts.get((int)(Math.random()*fonts.size())),face,size));   
  52.     g.drawString(""+use[i],p.x,p.y);   
  53. }   
  54. s=new String(use);   
  55. session.setAttribute("code", s);   
  56. g.setPaint(null);   
  57. for(int i=0;i<4;i++){   
  58.     g.setColor(new Color((int)(Math.random()*0x00FFFFFFF)));   
  59.     g.drawLine((int)(Math.random()*200),(int)(Math.random()*50),(int)(Math.random()*200),(int)(Math.random()*50));   
  60. }   
  61. Random random = new Random();   
  62. for (int i=0;i<88;i++) {   
  63.     int x = random.nextInt(200);   
  64.     int y = random.nextInt(50);   
  65.     g.setColor(new Color((int)(Math.random()*0x00FFFFFFF)));   
  66.     g.setStroke(new BasicStroke((float)(Math.random()*3)));   
  67.     g.drawLine(x,y,x,y);   
  68. }   
  69. OutputStream ot=response.getOutputStream();   
  70. ImageIO.write(bi,"JPEG",ot);   
  71. g.dispose();   
  72. ot.close();   
  73. %>   

 

以下是Servlet代码

java 代码
  1. *   
  2.  * Code.java   
  3.  *   
  4.  * Created on 2007年9月21日, 下午12:08  
  5.  */   
  6.   
  7. package com.hadeslee;   
  8.   
  9. import java.awt.BasicStroke;   
  10. import java.awt.Color;   
  11. import java.awt.Font;   
  12. import java.awt.GradientPaint;   
  13. import java.awt.Graphics2D;   
  14. import java.awt.GraphicsEnvironment;   
  15. import java.awt.Paint;   
  16. import java.awt.Point;   
  17. import java.awt.Stroke;   
  18. import java.awt.image.BufferedImage;   
  19. import java.io.*;   
  20. import java.util.ArrayList;   
  21. import java.util.List;   
  22. import java.util.Locale;   
  23. import java.util.Random;   
  24. import javax.imageio.ImageIO;   
  25.   
  26. import javax.servlet.*;   
  27. import javax.servlet.http.*;   
  28.   
  29. /**  
  30.  *  
  31.  * @author lbf  
  32.  * @version  
  33.  */  
  34. public class Code extends HttpServlet {   
  35.        
  36.     /** Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.  
  37.      * @param request servlet request  
  38.      * @param response servlet response  
  39.      */  
  40.     private List<String> fonts=new ArrayList<String>();   
  41.     public Code(){   
  42.         initFonts();   
  43.     }   
  44.     private void initFonts(){   
  45.         GraphicsEnvironment.getLocalGraphicsEnvironment().preferLocaleFonts();   
  46.         String[] names=GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames(Locale.CHINA);   
  47.         for(String s:names){   
  48.             char c=s.charAt(0);   
  49.             if(Character.isLowerCase(c)||Character.isUpperCase(c)){   
  50.                    
  51.             }else{   
  52.                 fonts.add(s);   
  53.             }   
  54.         }   
  55.     }   
  56.     protected void processRequest(HttpServletRequest request, HttpServletResponse response)   
  57.     throws ServletException, IOException {   
  58.         response.setContentType("image/jpeg;charset=UTF-8");   
  59.         OutputStream out=response.getOutputStream();   
  60.         BufferedImage bi=new BufferedImage(200,50,BufferedImage.TYPE_INT_RGB);   
  61.         Graphics2D g=bi.createGraphics();   
  62.         char[] cs={'0','1','2','3','4','5','6','7','8','9'};   
  63.         char[] use=new char[4];   
  64.         g.setColor(new Color(240,240,240));   
  65.         g.fillRect(0,0,200,50);   
  66.         for(int i=0;i<4;i++){   
  67.             Point p=getPoint(i);   
  68.             int size=getSize();   
  69.             use[i]=cs[(int)(Math.random()*cs.length)];   
  70.            // g.setColor(new Color((int)(Math.random()*256),0,(int)(Math.random()*256)));   
  71.             g.setPaint(getPaint(p,size));   
  72.             g.setFont(new Font(fonts.get((int)(Math.random()*fonts.size())),getFace(),size));   
  73.             g.drawString(""+use[i],p.x,p.y);   
  74.         }   
  75.         g.setStroke(new BasicStroke(1.0f));   
  76.         g.setPaint(null);   
  77.         for(int i=0;i<4;i++){   
  78.             g.setColor(new Color((int)(Math.random()*0x00FFFFFFF)));   
  79.             g.drawLine((int)(Math.random()*200),(int)(Math.random()*50),(int)(Math.random()*200),(int)(Math.random()*50));   
  80.         }   
  81.         Random random = new Random();   
  82.         for (int i=0;i<88;i++) {   
  83.             int x = random.nextInt(200);   
  84.             int y = random.nextInt(50);   
  85.             g.setColor(new Color((int)(Math.random()*0x00FFFFFFF)));   
  86.             g.setStroke(getStroke());   
  87.             g.drawLine(x,y,x,y);   
  88.         }   
  89.         ImageIO.write(bi,"JPEG",out);   
  90.         out.close();   
  91.         g.dispose();   
  92.     }   
  93.     private Stroke getStroke(){   
  94.       BasicStroke bs=new BasicStroke((float)(Math.random()*3));   
  95.       return bs;   
  96.     }   
  97.     private Point getPoint(int index){   
  98.         return new Point(5+(index*((int)(Math.random()*10)+40)),40);   
  99.     }   
  100.     private Paint getPaint(Point p,int size){   
  101.         GradientPaint gp=new GradientPaint(p.x,p.y,new Color((int)(Math.random()*256),0,(int)(Math.random()*256)),   
  102.                 p.x,p.y-size,new Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256)));   
  103.         return gp;   
  104.     }   
  105.     private int getFace(){   
  106.         if(Math.random()*10>5){   
  107.             return Font.BOLD;   
  108.         }else{   
  109.             return Font.ITALIC;   
  110.         }   
  111.     }   
  112.     private int getSize(){   
  113.         int[] sizes=new int[20];   
  114.         for(int i=0;i<20;i++){   
  115.             sizes[i]=30+i;   
  116.         }   
  117.         return sizes[(int)(Math.random()*sizes.length)];   
  118.     }   
  119.        
  120.     // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">   
  121.     /** Handles the HTTP <code>GET</code> method.  
  122.      * @param request servlet request  
  123.      * @param response servlet response  
  124.      */  
  125.     protected void doGet(HttpServletRequest request, HttpServletResponse response)   
  126.     throws ServletException, IOException {   
  127.         processRequest(request, response);   
  128.     }   
  129.        
  130.     /** Handles the HTTP <code>POST</code> method.  
  131.      * @param request servlet request  
  132.      * @param response servlet response  
  133.      */  
  134.     protected void doPost(HttpServletRequest request, HttpServletResponse response)   
  135.     throws ServletException, IOException {   
  136.         processRequest(request, response);   
  137.     }   
  138.        
  139.     /** Returns a short description of the servlet.  
  140.      */  
  141.     public String getServletInfo() {   
  142.         return "Short description";   
  143.     }   
  144.     // </editor-fold>   
  145. }   

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 22 Sep 2007 14:17:43 +0800 http://lijie250.javaeye.com/blog/126152 http://lijie250.javaeye.com/blog/126152 常用方法！ lijie250 作者: lijie250  链接：http://lijie250.javaeye.com/blog/100849  发表时间: 2007年07月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
  1. package com.util;   
  2.   
  3. import java.io.BufferedInputStream;   
  4. import java.io.BufferedWriter;   
  5. import java.io.File;   
  6. import java.io.FileInputStream;   
  7. import java.io.FileOutputStream;   
  8. import java.io.FileWriter;   
  9. import java.io.FilterInputStream;   
  10. import java.io.IOException;   
  11. import java.io.InputStream;   
  12. import java.io.OutputStream;   
  13. import java.io.PrintWriter;   
  14. import java.net.URL;   
  15. import java.text.SimpleDateFormat;   
  16. import java.util.Calendar;   
  17. import java.util.Date;   
  18. import java.util.Enumeration;   
  19. import java.util.HashMap;   
  20. import java.util.Map;   
  21. import java.util.Properties;   
  22. import java.util.regex.Matcher;   
  23. import java.util.regex.Pattern;   
  24.   
  25. public class SuperUitl {   
  26.     
  27.  public static void main(String[] args) {   
  28.   System.out.println();   
  29.  }   
  30.     
  31.  /**  
  32.   * 全角转半角  
  33.   * trr 要转换成半角的字符串  
  34.   */  
  35.  public static String change(String str) {   
  36.   String outStr="";   
  37.   String test="";   
  38.   byte[] code = null;   
  39.      
  40.   for(int i=0;i<str.length();i++) {        
  41.    try {   
  42.     test = str.substring(i,i+1);   
  43.     code = test.getBytes("unicode");   
  44.    } catch(java.io.UnsupportedEncodingException e) {   
  45.    }        
  46.    if (code[3] == -1) {   
  47.     code[2] = (byte)(code[2]+32);   
  48.     code[3] = 0;         
  49.   
  50.     try {          
  51.      outStr = outStr + new String(code,"unicode");   
  52.     } catch(java.io.UnsupportedEncodingException e) {   
  53.     }         
  54.    } else {   
  55.     outStr = outStr + test;   
  56.    }   
  57.   }   
  58.   return outStr;    
  59.  }   
  60.     
  61.  /**  
  62.   * 根据key读取value  
  63.   * filePath 要操作的properties文件路径  
  64.   * key 要获得数据的key  
  65.   */  
  66.  public static String readValue(String filePath,String key) {   
  67.   Properties props = new Properties();   
  68.         try {   
  69.          InputStream in = new BufferedInputStream (new FileInputStream(filePath));   
  70.          props.load(in);   
  71.          String value = props.getProperty (key);   
  72.             return value;   
  73.         } catch (Exception e) {   
  74.          return null;   
  75.         }   
  76.  }   
  77.     
  78.  /**  
  79.   * 读取properties的全部信息  
  80.   * filePath 要操作的properties文件路径  
  81.   */  
  82.     public static Map readProperties(String filePath) {   
  83.      Map map = new HashMap();   
  84.      Properties props = new Properties();   
  85.         try {   
  86.          InputStream in = new BufferedInputStream (new FileInputStream(filePath));   
  87.          props.load(in);   
  88.             Enumeration en = props.propertyNames();   
  89.              while (en.hasMoreElements()) {   
  90.               String key = (String) en.nextElement();   
  91.                     String Property = props.getProperty (key);   
  92.                     map.put(key,Property);   
  93.                 }   
  94.              return map;   
  95.         } catch (Exception e) {   
  96.          return null;   
  97.         }   
  98.     }   
  99.   
  100.     /**  
  101.   * 写入properties信息  
  102.   * filePath 要操作的properties文件路径  
  103.   * key 要写入的key  
  104.   * value 要写入的value  
  105.   */  
  106.     public static boolean writeProperties(String filePath,String key,String value) {   
  107.      Properties prop = new Properties();   
  108.      try {   
  109.       InputStream fis = new FileInputStream(filePath);   
  110.             //从输入流中读取属性列表（键和元素对）   
  111.             prop.load(fis);   
  112.             //调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。   
  113.             //强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。   
  114.             OutputStream fos = new FileOutputStream(filePath);   
  115.             prop.setProperty(key,value);   
  116.             //以适合使用 load 方法加载到 Properties 表中的格式，   
  117.             //将此 Properties 表中的属性列表（键和元素对）写入输出流   
  118.             prop.store(fos, "Update '" + key + "' value");   
  119.             return true;   
  120.         } catch (IOException e) {   
  121.          return false;   
  122.         }   
  123.     }   
  124.        
  125.     /**  
  126.   * 返回标准系统时间  
  127.   */  
  128.     public static String getDate() {   
  129.   SimpleDateFormat ft=null;   
  130.   Date date=null;   
  131.   Calendar cl= Calendar.getInstance();   
  132.   cl.setTime(new java.util.Date());   
  133.   date=cl.getTime();   
  134.   ft=new SimpleDateFormat("yyyy-MM-dd HH:mm");   
  135.   String dateTime = ft.format(date);   
  136.   return dateTime;   
  137.  }   
  138.        
  139.     /**  
  140.   * 从指定的字符串中提取Email  
  141.   * content 指定的字符串  
  142.   */  
  143.  public static String parse(String content) {   
  144.   String email = null;   
  145.   if (content==null || content.length()<1) {   
  146.    return email;   
  147.   }   
  148.   //找出含有@   
  149.   int beginPos;   
  150.   int i;   
  151.   String token = "@";   
  152.   String preHalf="";   
  153.   String sufHalf = "";   
  154.      
  155.   beginPos = content.indexOf(token);   
  156.   if (beginPos>-1) {   
  157.    //前项扫描   
  158.    String s = null;   
  159.    i= beginPos;   
  160.    while(i>0) {   
  161.     s = content.substring(i-1,i);   
  162.     if (isLetter(s))   
  163.      preHalf = s+preHalf;   
  164.     else  
  165.      break;   
  166.     i--;   
  167.    }   
  168.    //后项扫描   
  169.    i= beginPos+1;   
  170.    while( i<content.length()) {   
  171.     s = content.substring(i,i+1);   
  172.     if (isLetter(s))   
  173.      sufHalf =  sufHalf +s;   
  174.     else  
  175.      break;   
  176.     i++;     
  177.    }   
  178.    //判断合法性   
  179.    email = preHalf + "@" + sufHalf;   
  180.    if (isEmail(email)) {   
  181.     return email;   
  182.    }   
  183.   }   
  184.   return null;   
  185.  }   
  186.     
  187.  /**  
  188.   * 判断是不是合法Email  
  189.   * email Email地址  
  190.   */  
  191.  public static boolean isEmail(String email) {   
  192.   try {   
  193.    if (email==null || email.length()<1 || email.length()>256) {   
  194.     return false;   
  195.    }   
  196.       
  197.    String check = "^([0-9a-zA-Z]+[_.0-9a-zA-Z-]+)@([a-zA-Z0-9-]+[.])+([a-zA-Z]{2,3})$";   
  198.    Pattern regex = Pattern.compile(check);   
  199.    Matcher matcher = regex.matcher(email);   
  200.    boolean isMatched = matcher.matches();   
  201.    if(isMatched) {   
  202.     return true;   
  203.    } else {   
  204.     return false;   
  205.    }   
  206.   } catch (RuntimeException e) {   
  207.    return false;   
  208.   }    
  209.  }   
  210.     
  211.  /**  
  212.   * 判断是不是合法字符  
  213.   * c 要判断的字符  
  214.   */  
  215.  public static boolean isLetter(String c) {   
  216.   boolean result = false;   
  217.      
  218.   if (c==null || c.length()<0) {   
  219.    return false;   
  220.   }   
  221.   //a-z    
  222.   if (c.compareToIgnoreCase("a")>=0 && c.compareToIgnoreCase("z")<=0) {   
  223.    return true;   
  224.   }   
  225.   //0-9   
  226.   if (c.compareToIgnoreCase("0")>=0 && c.compareToIgnoreCase("9")<=0) {   
  227.    return true;   
  228.   }   
  229.   //. - _   
  230.   if (c.equals(".") || c.equals("-") || c.equals("_") ) {   
  231.    return true;   
  232.   }   
  233.   return result;    
  234.  }   
  235.     
  236.  /**  
  237.   * 删除整个目录的全部图片  
  238.   * filePath 要删除的目录路径  
  239.   */  
  240.  public static boolean deleteImage(String filePath) {   
  241.   try {   
  242.    File file = new File(filePath);   
  243.    File[] files = file.listFiles();   
  244.    for(int i=0;i<files.length;i++) {   
  245.     try {   
  246.      //系统文件不删除   
  247.      if(!(files[i].getName()).equalsIgnoreCase("Thumbs.db")) {   
  248.       if(files[i].isFile()) {   
  249.        files[i].delete();   
  250.       } else if(files[i].isDirectory()) {   
  251.        files[i].delete();   
  252.       } else {   
  253.        files[i].delete();   
  254.       }   
  255.      }   
  256.     } catch (RuntimeException e) {;   
  257.     }   
  258.    }   
  259.    return true;   
  260.   } catch (RuntimeException e) {   
  261.    return false;   
  262.   }    
  263.  }   
  264.     
  265.  /**  
  266.   * 保存网络上的图片到指定目录  
  267.   * filePath 要保存到本地服务器的目录  
  268.   * imagePath 网络图片的UIL地址  
  269.   */  
  270.  public static boolean saveImage(String filePath,String imagePath) {   
  271.   try {   
  272.    if(imagePath.length()>1024 || imagePath.equals("")) {   
  273.     return false;   
  274.    }   
  275.    String fileName = imagePath.substring(imagePath.lastIndexOf("/")+1,imagePath.length());   
  276.    filePath = filePath+fileName;   
  277.    URL url = null;   
  278.    try {   
  279.      url = new URL(imagePath);   
  280.    } catch(Exception e) {   
  281.      return