语源科技BlogJava-funhttp://www.blogjava.net/wangfun/zh-cnTue, 28 Apr 2026 19:02:51 GMTTue, 28 Apr 2026 19:02:51 GMT60大规模网站架构ppthttp://www.blogjava.net/wangfun/archive/2009/11/06/301484.htmlfunfunFri, 06 Nov 2009 11:44:00 GMThttp://www.blogjava.net/wangfun/archive/2009/11/06/301484.htmlhttp://www.blogjava.net/wangfun/comments/301484.htmlhttp://www.blogjava.net/wangfun/archive/2009/11/06/301484.html#Feedback3http://www.blogjava.net/wangfun/comments/commentRss/301484.htmlhttp://www.blogjava.net/wangfun/services/trackbacks/301484.html

为公司讲解的一个PPT，相关内容如下:

 

 http://www.bt285.cn BT下载 有300W部BT种子.
http://www.5a520.cn 小说520网 有300W部小说

CAP原则
BASE策略
异步(MessageQueue)
数据库
   数据的水平切分及垂直切分
    数据库读写分离
    避免分布式事务
    反范式的数据库设计
负载均衡
    DNS负载均衡
    反向代理负载均衡
     LVS
缓存
    数据库缓存
     服务器缓存/页面缓存/数据缓存/静态化
    反向代理缓存

HA
Session

Share Nothing Architecture架构
浏览器优化
    浏览器缓存/CDN/小图片合并
分布式文件系统(MogileFS)

下载地址为：http://www.bt285.cn/soft/res.ppt

 

fun 2009-11-06 19:44 发表评论
]]>Tomcat配置成https方式访问（用单向认证）http://www.blogjava.net/wangfun/archive/2009/05/12/270169.htmlfunfunTue, 12 May 2009 03:35:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/12/270169.html keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit -keystore server.keystore -validity 3600
通过以上步骤生成server.keystore证书文件、

将servlet.xml一下的的注释打开（最好拷贝此段）
<!-- Define a SSL HTTP/1.1 Connector on port 8443 -->  
<Connector protocol="org.apache.coyote.http11.Http11Protocol"    
                     port="8443" maxHttpHeaderSize="8192"  
           maxThreads="150" minSpareThreads="25" maxSpareThreads="75"  
           enableLookups="false" disableUploadTimeout="true"  
           acceptCount="100" scheme="https" secure="true"  
           clientAuth="false" sslProtocol="TLS"                   
           keystoreFile="server.keystore"    
           keystorePass="changeit"/> 
到这一步访问https;//ip:8443/item

一般Tomcat默认的SSL端口号是8443，但是对于SSL标准端口号是443，这样在访问网页的时候，直接使用https而不需要输入端口号就可以访问，如http://www.bt285.cn
想要修改端口号，需要修改Tomcat的server.xml文件：
1.non-SSL HTTP/1.1 Connector定义的地方，一般如下：
     <Connector port="80" maxHttpHeaderSize="8192"
                maxThreads="500" minSpareThreads="25" maxSpareThreads="75"
                enableLookups="false" redirectPort="443" acceptCount="100"
                connectionTimeout="20000" disableUploadTimeout="true" />
将其中的redirectPort端口号改为：443
2.SSL HTTP/1.1 Connector定义的地方，修改端口号为：443，如下：
<Connector    
   port="443" maxHttpHeaderSize="8192"
   maxThreads="150" minSpareThreads="25"
   maxSpareThreads="75"
   enableLookups="false"
   disableUploadTimeout="true"
   acceptCount="100" scheme="https"
   secure="true"
   clientAuth="false" sslProtocol="TLS"
   keystoreFile="conf/tomcat.keystore"
   keystorePass="123456" />
3.AJP 1.3 Connector定义的地方，修改redirectPort为443，如下：
     <Connector port="8009"
                enableLookups="false" redirectPort="443" protocol="AJP/1.3" />

重新启动Tomcat就可以了。到这一步可以形成访问方式 http://www.5a520.cn /item

到tomcat下面的webapps下面的ROOT下面的index.jsp文件的内容
<?xml version="1.0" encoding="ISO-8859-1"?>
  <%response.sendRedirect("/item");%>

修改web.xml文件的内容
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

  <display-name>Welcome to Tomcat</display-name>
  <description> 
     http://www.feng123.com 蜂蜜交易网
  </description>

  <welcome-file-list>
   <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>
</web-app>
删除lib目录下的lib文件
重启Tomcat服务器，在这一步可以直接通过https:ip来访问项目


fun 2009-05-12 11:35 发表评论
]]>10分钟学懂Struts 2.0 拦截器http://www.blogjava.net/wangfun/archive/2009/05/08/269677.htmlfunfunFri, 08 May 2009 12:31:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/08/269677.htmlStruts 2.0拦截器

简介

 

在Struts 2.0 中的拦截器，要实现com.opensymphony.xwork2.interceptor.Interceptor接口，在struts.xml中配置。可以用拦截器来完成调用Action业务逻辑之前的预处理或是之后的善后处理。还可以通过配置多个拦截器来满足action需求。

 

Interceptor stack是由多个拦截器组成的拦截器组，在拦截器组中可以对每一个拦截器映射。所有进行配置拦截器时，不必对每一个拦截器进行配置，而只需对interceptor stack进行配置即可。在struts 2中默认配置了一个全局interceptor stack，包括Exception Interceptor、Validation Interceptor等。

 

实例

 

在这个实例当中，我将配置一个时间拦截器，用来统计每个action的请求时间。

package interceptor;      
     
import com.opensymphony.xwork2.ActionInvocation;      
import com.opensymphony.xwork2.interceptor.Interceptor;      
/**
*author by http://www.bt285.cn http://www.5a520.cn
*/     
public class ActionTimer implements Interceptor{      
    public String intercept(ActionInvocation next) throws Exception {      
        long t1 = System.currentTimeMillis();      
        String s= next.invoke();      
        long t2 = System.currentTimeMillis();      
        System.out.println("Action "+next.getAction().getClass().getName()+" took "+(t2-t1)+" millisecs");      
        return s;      
    }      
          
    public void init() {      
    }      
    public void destroy() {      
    }      
}  
struts.xml：
<?xml version="1.0" encoding="UTF-8" ?>     
<!DOCTYPE struts PUBLIC      
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"      
    "http://struts.apache.org/dtds/struts-2.0.dtd">     
<struts>     
    <package name="interceptor" extends="struts-default">     
        <interceptors>     
            <interceptor name="actiontimer"     
                class="interceptor.ActionTimer" />     
     
            <interceptor-stack name="demostack">     
                <interceptor-ref name="defaultStack" />     
                <interceptor-ref name="actiontimer" />     
            </interceptor-stack>     
        </interceptors>     
        <default-interceptor-ref name="demostack" />     
        <action name="InterceptorDemo"     
            class="interceptor.action.InterceptorDemo">     
            <result>http://www.bt285.cn /interceptor/interceptordemo.jsp</result>     
        </action>     
    </package>     
     
</struts>   

interceptordemo.jsp：

<html>     
<head>     
     
</head>     
<body>     
</body>     
</html>   

 

 



fun 2009-05-08 20:31 发表评论
]]>Spring中的定时任务介绍http://www.blogjava.net/wangfun/archive/2009/05/07/269468.htmlfunfunThu, 07 May 2009 10:59:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/07/269468.html下面我们来看一下Spring中提供的定时任务开发：
在Spring中开发定时任务，分为3个步骤。
1 创建定时任务
2 注册定时任务
3 启动定时任务
分别来看一下
1 创建定时任务：

package org.jnotnull;
import java.util.TimerTask;
public class MyTesk extends TimerTask{
....
public void run(){
//添加任务
}
....
}

2 注册定时任务，并设置参数
我们来配置TimerConfig.xml防御WEB-INF下

<bean id="myTesk" class="edu.cumt.jnotnull.action.TaskAction">  
        <property name="newsManageService">  
            <ref bean="newsManageService" />  
        </property>  
    </bean>  
    <bean id="stTask"  
        class="org.springframework.scheduling.timer.ScheduledTimerTask">  
        <property name="delay">  
            <value>20000</value>  
        </property>  
        <property name="period">  
            <value>30000</value>  
        </property>  
        <property name="timerTask">  
            <ref bean="myTesk" />  
        </property>  
    </bean>  
    <bean id="timerFactory"  
        class="org.springframework.scheduling.timer.TimerFactoryBean">  
        <property name="scheduledTimerTasks">  
            <list>  
                <ref bean="stTask" />  
            </list>  
        </property>  
    </bean>  
3 启动定时任务   
<PRE class=xml name="code"><?xml version="1.0" encoding="UTF-8"?>  
<web-app>  
<context-param>  
<param-name>contextConfigLocation</param-name>  
<param-value>http://www.bt285.cn /WEB-INF/TimerConfig.xml</param-value>  
</context-param>  
<listener>  
<listener-class>  
 org.springframework.web.context.ContextLoaderListener   
</listener-class>  
</listener>  
</web-app>  
</PRE>  
<BR>  
<BR>下面我们再来看看在Spring中如何使用Quartz实现定时功能   
<BR>1 创建定时任务：   
<BR><PRE class=java name="code">package org.jnotnull;   
import java.util.TimerTask;   
/**
*http://www.5a520.cn
*/
public class MyTesk extends TimerTask{   
 
public void excute(){   
//添加任务   
}   
.   
}   
</PRE>  
<BR>2 注册定时任务，并设置参数   
<BR>我们来配置TimerConfig.xml防御WEB-INF下   
<BR><PRE class=xml name="code"><?xml version="1.0" encoding="UTF-8">  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd">  
<beans>  
<bean id ="myTesk" class="org.jnotnull.MyTesk"/>  
<bean id ="myJob"    
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
<property name="targetObject">  
<ref bean="myTask">  
</property>  
<propertyproperty ="targetMethod">  
<value>execute</value>  
</property>  
</bean>  
<bean id ="timeTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
<property name="jobDetail">  
 <ref bean="myJob">  
</property>  
<property name="cronExpression">  
<value>12,23****?</value>  
</property>  
</bean>  
<bean id ="timerFactory"    
class="org.springframework.scheduling.quartz.ScheduleFactoryBean">  
<property name="triggers">  
<list>  
<refref="timeTrigger">  
</list>  
</property>  
</bean>  
</beans>  
</PRE>  
<BR>3 启动定时任务   
<BR><PRE class=xml name="code"><?xml version="1.0" encoding="UTF-8"?>  
<web-app>  
<context-param>  
<param-name>contextConfigLocation</param-name>  
<param-value> http://www.bt285.cn /WEB-INF/TimerConfig.xml</param-value>  
</context-param>  
<listener>  
<listener-class>  
 org.springframework.web.context.ContextLoaderListener   
</listener-class>  
</listener>  
</web-app>  
</PRE>    


fun 2009-05-07 18:59 发表评论
]]>图文介绍log4jhttp://www.blogjava.net/wangfun/archive/2009/05/06/269218.htmlfunfunWed, 06 May 2009 04:42:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/06/269218.htmllog4j是一个非常强大的log记录软件，下面我们就来看看在项目中如何使log4j。

 

首先当然是得到log4j的jar档，推荐使用1.2.X版，下载地址：

http://logging.apache.org/log4j/1.2/download.html

 

我们先看一个最简单的示例：

【示例1】

项目结构：



【注：由于这里的多个项目公用一个jar档，我们可以创建一个专门放置jar档的Java工程，然后将jar档放到lib目录下。在要使用的工程中按图所示进行引用 】



 

package com.coderdream.log4j;   
  
import org.apache.log4j.Logger;   
   /**  
     * author by  http://www.bt285.cn 
     * http://www.5a520.cn     
*/  
public class HelloLog4j {   
  
    private static Logger logger = Logger.getLogger(HelloLog4j.class);   
  
   
    public static void main(String[] args) {   
        // System.out.println("This is println message.");   
           
        // 记录debug级别的信息   
        logger.debug("This is debug message.");   
        // 记录info级别的信息   
        logger.info("This is info message.");   
        // 记录error级别的信息   
        logger.error("This is error message.");   
    }   
}  

配置文件log4j.properties:

Properties代码 复制代码
  1. #可以设置级别：debug>info>error   
  2. #debug：显示debug、info、error   
  3. #info：显示info、error   
  4. #error：只error   
  5. log4j.rootLogger=debug,appender1   
  6. #log4j.rootLogger=info,appender1   
  7. #log4j.rootLogger=error,appender1   
  8.   
  9. #输出到控制台   
  10. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  11. #样式为TTCCLayout   
  12. log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout  

输出结果：

Console代码 复制代码
  1. [main] DEBUG com.coderdream.log4j.HelloLog4j - This is debug message.   
  2. [main] INFO com.coderdream.log4j.HelloLog4j - This is info message.   
  3. [main] ERROR com.coderdream.log4j.HelloLog4j - This is error message.  

  通过配置文件可知，我们需要配置3个方面的内容：

1、根目录（级别和目的地）；

2、目的地（控制台、文件等等）；

3、输出样式。


下面我们来看看Log4J的类图：


 

Logger - 日志写出器，供程序员输出日志信息
Appender - 日志目的地，把格式化好的日志信息输出到指定的地方去
ConsoleAppender - 目的地为控制台的Appender
FileAppender - 目的地为文件的Appender
RollingFileAppender - 目的地为大小受限的文件的Appender
Layout - 日志格式化器，用来把程序员的logging request格式化成字符串
PatternLayout - 用指定的pattern格式化logging request的Layout


Log4j基本使用方法

　　Log4j由三个重要的组件构成：日志信息的优先级，日志信息的输出目的地，日志信息的输出格式。日志信息的优先级从高到低有ERROR、WARN、 INFO、DEBUG，分别用来指定这条日志信息的重要程度；日志信息的输出目的地指定了日志将打印到控制台还是文件中；而输出格式则控制了日志信息的显示内容。

　　一、定义配置文件

　　其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

　　1.配置根Logger，其语法为：

　　log4j.rootLogger = [ level ] , appenderName, appenderName, …

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指B日志信息输出到哪个地方。您可以同时指定多个输出目的地。

　　2.配置日志信息输出目的地Appender，其语法为：

　　log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.option = valueN

　　其中，Log4j提供的appender有以下几种：
　　org.apache.log4j.ConsoleAppender（控制台），
　　org.apache.log4j.FileAppender（文件），
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　　3.配置日志信息的格式（布局），其语法为：

　　log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

　　其中，Log4j提供的layout有以e几种：
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　二、在代码中使用Log4j

　　1.得到记录器

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

　　static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

　　2.读取配置文件

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

　　BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　3.插入记录信息（格式化日志信息）

　　当上两个必要步骤执行完毕，您就可以轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

　　Logger.debug ( Object message ) ;
　　Logger.info ( Object message ) ;
　　Logger.warn ( Object message ) ;
　　Logger.error ( Object message ) ;

 

示例2～示例8

 

【示例2】 输出为文本文件或HTML文件

Porperties代码 复制代码
  1. #设置级别：   
  2. log4j.rootLogger=debug,appender1   
  3.   
  4. #输出到文件(这里默认为追加方式)   
  5. log4j.appender.appender1=org.apache.log4j.FileAppender   
  6. #设置文件输出路径   
  7. #【1】文本文件   
  8. #log4j.appender.appender1.File=c:/Log4JDemo02.log   
  9. #【2】HTML文件   
  10. log4j.appender.appender1.File=c:/Log4JDemo02.html   
  11. #设置文件输出样式   
  12. #log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout   
  13. log4j.appender.appender1.layout=org.apache.log4j.HTMLLayout  

 

【 示例3】 输出为文本文件或HTML文件

Properties代码 复制代码
  1. #设置级别和多个目的地   
  2. log4j.rootLogger=debug,appender1,appender2   
  3.   
  4. #输出到控制台   
  5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  6. #设置输出样式   
  7. log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout   
  8.   
  9. #输出到文件(这里默认为追加方式)   
  10. log4j.appender.appender2=org.apache.log4j.FileAppender   
  11. #设置文件输出路径   
  12. #【1】文本文件   
  13. #log4j.appender.appender2.File=c:/Log4JDemo02.log   
  14. #【2】HTML文件   
  15. log4j.appender.appender2.File=c:/Log4JDemo02.html   
  16. #设置文件输出样式   
  17. #log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout   
  18. log4j.appender.appender2.layout=org.apache.log4j.HTMLLayout  

 

【示例4】 SimpleLayout样式

Properties代码 复制代码
  1. #设置级别和目的地   
  2. log4j.rootLogger=debug,appender1   
  3.   
  4. #输出到控制台   
  5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  6. #设置输出样式   
  7. log4j.appender.appender1.layout=org.apache.log4j.SimpleLayout  

  输出结果：

控制台代码 复制代码
  1. DEBUG - This is debug message.   
  2. INFO - This is info message.   
  3. ERROR - This is error message.  

 

【示例5】 自定义样式

Java代码 复制代码
  1. #设置级别和目的地   
  2. log4j.rootLogger=debug,appender1   
  3.   
  4. #输出到控制台   
  5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  6. #设置输出样式   
  7. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout   
  8. #自定义样式   
  9. # %r 时间 0  
  10. # %t 方法名 main   
  11. # %p 优先级 DEBUG/INFO/ERROR   
  12. # %c 所属类的全名(包括包名)   
  13. # %l 发生的位置，在某个类的某行   
  14. # %m 输出代码中指定的讯息，如log(message)中的message   
  15. # %n 输出一个换行   
  16.   
  17. log4j.appender.appender1.layout.ConversionPattern=%r [%t] [%p] - %c -%l -%m%n  

输出结果：

控制台代码 复制代码
  1. 0 [main] [DEBUG] - com.coderdream.log4j.HelloLog4j    
  2. -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:16) -This is debug message.   
  3. 31 [main] [INFO] - com.coderdream.log4j.HelloLog4j    
  4. -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:18) -This is info message.   
  5. 31 [main] [ERROR] - com.coderdream.log4j.HelloLog4j    
  6. -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:20) -This is error message.  

 

【示例6】 多目的地、自定义样式

Properties代码 复制代码
  1. #设置级别和目的地   
  2. log4j.rootLogger=debug,appender1,appender2   
  3.   
  4. #输出到控制台   
  5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  6. #设置输出样式   
  7. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout   
  8. #自定义样式   
  9. # %r 时间 0  
  10. # %t 方法名 main   
  11. # %p 优先级 DEBUG/INFO/ERROR   
  12. # %c 所属类的全名(包括包名)   
  13. # %l 发生的位置，在某个类的某行   
  14. # %m 输出代码中指定的讯息，如log(message)中的message   
  15. # %n 输出一个换行符号   
  16. log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n   
  17.   
  18. #输出到文件(这里默认为追加方式)   
  19. log4j.appender.appender2=org.apache.log4j.FileAppender   
  20. #设置文件输出路径   
  21. #【1】文本文件   
  22. log4j.appender.appender2.File=c:/Log4JDemo06.log   
  23. #设置文件输出样式   
  24. log4j.appender.appender2.layout=org.apache.log4j.PatternLayout   
  25. log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n  

 

【示例7】 【企业应用】设置 特定包的级别和目的地

先增加一个包，新建一个类：

Java代码 复制代码
  1. package com.coderdream.log4jDao;   
  2.   
  3. import org.apache.log4j.Logger;   
  4.   
  5. public class HelloDao {   
  6.     private static Logger logger = Logger.getLogger(HelloDao.class);   
  7.   
  8.     /**  
  9.      * @param args  
  10.      */  
  11.     public static void main(String[] args) {   
  12.         // 记录debug级别的信息   
  13.         logger.debug("This is debug message from Dao.");   
  14.         // 记录info级别的信息   
  15.         logger.info("This is info message from Dao.");   
  16.         // 记录error级别的信息   
  17.         logger.error("This is error message from Dao.");   
  18.     }   
  19. }  

      如果这个类作为基类，如J2EE中的BaseDao、BaseAction、BaseService等等，则我们可以将各层的日志信息分类输出到各个文件。

 

Properties代码 复制代码
  1. #省略根，只设置特定包的级别和目的地   
  2. log4j.logger.com.coderdream.log4j=debug,appender1   
  3. log4j.logger.com.coderdream.log4jDao=info,appender1,appender2   
  4.   
  5. #输出到控制台   
  6. log4j.appender.appender1=org.apache.log4j.ConsoleAppender   
  7. #设置输出样式   
  8. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout   
  9. #自定义样式   
  10. # %r 时间 0  
  11. # %t 方法名 main   
  12. # %p 优先级 DEBUG/INFO/ERROR   
  13. # %c 所属类的全名(包括包名)   
  14. # %l 发生的位置，在某个类的某行   
  15. # %m 输出代码中指定的讯息，如log(message)中的message   
  16. # %n 输出一个换行符号   
  17. log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n   
  18.   
  19. #输出到文件(这里默认为追加方式)   
  20. log4j.appender.appender2=org.apache.log4j.FileAppender   
  21. #设置文件输出路径   
  22. #【1】文本文件   
  23. log4j.appender.appender2.File=c:/Log4JDemo07_Dao.log   
  24. #设置文件输出样式   
  25. log4j.appender.appender2.layout=org.apache.log4j.PatternLayout   
  26. log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n  

 

【示例8】 log4j.xml的配置方式

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">  
  3.   
  4. <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">  
  5.   
  6.     <appender name="appender1"  
  7.         class="org.apache.log4j.RollingFileAppender">  
  8.         <param name="File" value="logfile08.html" />  
  9.         <param name="MaxFileSize" value="1MB" />  
  10.         <param name="MaxBackupIndex" value="5" />  
  11.         <layout class="org.apache.log4j.HTMLLayout">  
  12.         </layout>  
  13.     </appender>  
  14.   
  15.     <root>  
  16.         <level value="debug" />  
  17.         <appender-ref ref="appender1" />  
  18.     </root>  
  19. </log4j:configuration>  

 

为了提高效率，我们可以在写日志前增加判断：

Java代码 复制代码
  1. // 记录debug级别的信息   
  2. if (logger.isDebugEnabled()) {   
  3.     logger.debug("This is debug message from Dao.");   
  4. }   
  5.   
  6. // 记录info级别的信息   
  7. if (logger.isInfoEnabled()) {   
  8.     logger.info("This is info message from Dao.");   
  9. }   
  10.   
  11. // 记录error级别的信息   
  12. logger.error("This is error message from Dao.");  


fun 2009-05-06 12:42 发表评论
]]>svn笔记之一http://www.blogjava.net/wangfun/archive/2009/05/05/268945.htmlfunfunTue, 05 May 2009 04:00:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/05/268945.html今天读了subversion 的open book. http://www.subversion.org.cn/svnbook/nightly/svn.tour.cycle.html
 
创建自己的版本库
 
svnadmin create –fs-type fsfs /home/lmzhang/ www.bt285.cn .
svn import myproj file:///home/lmzhang/ www.bt285.cn . -m “”
svn ci -m “”
 
 
关于内置版本号.
HEAD - 最新版本号.
BASE - 当前工作版本的未修改版本.
COMMITTED - BASE - 1
PREV - COMMITTED - 1
 
svn merge 的作用可以用语在任何两个版本之间的差异合并到某个工作版本的功能.
语法如下
 
 
举例来说我有一个工作copy，内有一个1.txt 当前版本号是1.
内容是  h动漫下载 http://www.bt285.cn/content.php?id=274912
甜性涩爱下载 http://www.bt285.cn/content.php?id=1196863 (14260)
色即是空2下载  http://www.bt285.cn/sejishikong/
爱的色放下载 http://www.bt285.cn/aidesefang/
http://www.bt285.cn/yazhou/ 亚洲BT  
然后我添加为 first second. svn ci -m “”.
 
然后我执行 svn merge -r HEAD:PREV 1.txt , svn将比较 HEAD版本和PREV版本的内容差异，然后将这个差异合并到 当前路径下的1.txt , 由于差异是减少了 second , 因此相当于回到了 版本1.
 

svn merge的语法允许非常灵活的指定参数，如下是一些例子：

$ svn merge http://svn.example.com/repos/branch1@150 \
http://svn.example.com/repos/branch2@212 \
my-working-copy
$ svn merge -r 100:200 http://svn.example.com/repos/trunk my-working-copy
$ svn merge -r 100:200 http://svn.example.com/repos/trunk

第一种语法使用URL@REV的形式直接列出了所有参数，第二种语法可以用来作为比较同一个URL的不同版本的简略写法，最后一种语法表示工作拷贝是可选的，如果省略，默认是当前目录。

 
svn 的分支创建倒是很容易.
 
svn copy from to , 那么to就成为了from的一个copy，在svn的概念中就是分支或者tag.
 
问题在于合并.
 
svn 的概念中，分之合并实际上是将某个分之某个版本到另外一个版本之间的变化合并到某个目录的概念.
 
比如 分支 b-1 从开始分支的版本 4 ,  到做了修改后的版本 9 .  想合并到主干上.
 
那么进入主干的工作目录执行 svn merge -r 4:9 file:///…./b-1 trunk 就ok.
 
// 下面说明了，为什么要用上面这种做法，仅仅比较带合并的分支的信息.
(

但是要哪两个树进行比较呢？乍一看，回答很明确，只要比较最新的主干与分支。但是你要意识到—这个想法是错误的，伤害了许多新用户！因为svn merge的操作很像svn diff，比较最新的主干和分支树不仅仅会描述你在分支上所作的修改，这样的比较会展示太多的不同，不仅包括分支上的增加，也包括了主干上的删除操作，而这些删除根本就没有在分支上发生过。

)

另外通过同一分支上的版本间merge可以执行反向操作，比如版本5对于版本4的修改是完全错误的，那么可以通过 svn merge -r 5:4 file.cpp working-copy 来达到在working-copy 中取消这个修改.

反向操作另外一个作用，加入你删除了head版本中的test.cpp , 但是又想找回来，那么你可以 svn log -v 察看test.cpp 是什么时候被删除的., -r 10 , 上一个版本 8 . 那么可以执行如下

svn merger -r 10:8 file:///…/  working-copy 就还原了.

当然svn copy -r 也可以.

 

还有一种方式就是两个分支间直接进行合并.
svn merge trunk@10 b-1@9 trunk  表示将主干 -r 10 , 分支 -r 9 的差别合并到主干
 
另外merge 有一个有用的参数，–dry-run 表示仅仅模拟本次合并的效果，实际上并不生效.
 
举例来说
 
就表示将主干 v1 到分支b_1 v4 之间的差别进行列举合并到当前工作目录.
 
 
tag 本身和branch在svn 中的操方式是一样的，不过tag还有一个增强点，就是能够将当前工作目录直接进行tag.
 
update 状态
U foo
文件foo更新了（从服务器收到修改）。

 

A foo
文件或目录foo被添加到工作拷贝。

 

D foo
文件或目录foo在工作拷贝被删除了。

 

R foo
文件或目录foo在工作拷贝已经被替换了，这是说，foo被删除，而一个新的同样名字的项目添加进来，它们具有同样的名字，但是版本库会把它们看作具备不同历史的不同对象。

 

G foo
文件foo接收到版本库的更改，你的本地版本也已经修改，但改变没有互相影响，Subversion成功的将版本库和本地文件合并，没有发生任何问题。

 

C foo
文件foo的修改与服务器冲突，服务器的修改与你的修改交迭在一起，不要恐慌，这种冲突需要人（你）来解决，我们在后面的章节讨论这种情况。

 

svn status
  L     some_dir            # svn已经在.svn目录锁定了some_dir
M       bar.c               # bar.c的内容已经在本地修改过了
M      baz.c               # baz.c属性有修改，但没有内容修改
X       3rd_party           # 这个目录是外部定义的一部分
?       foo.o               # svn并没有管理foo.o
!       some_dir            # svn管理这个，但它可能丢失或者不完
~       qux                 # 作为file/dir/link进行了版本控制，但类型已经改变
I       .screenrc           # svn不管理这个，配置确定要忽略它
A  +    moved_dir           # 包含历史的添加，历史记录了它的来历
M  +    moved_dir/README    # 包含历史的添加，并有了本地修改
D       stuff/fish.c        # 这个文件预定要删除
A       stuff/loot/bloo.h   # 这个文件预定要添加
C       stuff/loot/lump.c   # 这个文件在更新时发生冲突
C      stuff/loot/glub.c   # 文件在更新时发生属性冲突
R       xyz.c               # 这个文件预定要被替换
S   stuff/squawk        # 这个文件已经跳转到了分支
K  dog.jpg             # 文件在本地锁定；有锁定令牌
O  cat.jpg             # 文件在版本库被其他用户锁定
B  bird.jpg            # 文件本地锁定，但锁定发生错误
T  fish.jpg            # 文件本地锁定，但锁定丢失
第一列
A item


文件、目录或是符号链item预定加入到版本库。

C item


文件item发生冲突，在从服务器更新时与本地版本发生交迭，在你提交到版本库前，必须手工的解决冲突。

D item


文件、目录或是符号链item预定从版本库中删除。

M item


文件item的内容被修改了。

R item


文件、目录或是符号链item预定将要替换版本库中的item，这意味着这个对象首先要被删除，另外一个同名的对象将要被添加，所有的操作发生在一个修订版本。

X item


目录没有版本化，但是与Subversion的外部定义关联，关于外部定义，可以看“外部定义”一节。

? item


文件、目录或是符号链item不在版本控制之下，你可以通过使用svn status的--quiet（-q）参数或父目录的svn:ignore属性忽略这个问题，关于忽略文件的使用，见“svn:ignore”一节。

! item


文件、目录或是符号链item在版本控制之下，但是已经丢失或者不完整，这可能因为使用非Subversion命令删除造成的，如果是一个目录，有可能是检出或是更新时的中断造成的，使用svn update可以重新从版本库获得文件或者目录，也可以使用svn revert file恢复原来的文件。

~ item


文件、目录或是符号链item在版本库已经存在，但你的工作拷贝中的是另一个。举一个例子，你删除了一个版本库的文件，新建了一个在原来的位置，而且整个过程中没有使用svn delete或是svn add。

I item


文件、目录或是符号链item不在版本控制下，Subversion已经配置好了会在svn add、svn import和svn status命令忽略这个文件，关于忽略文件，见“svn:ignore”一节。注意，这个符号只会在使用svn status的参数--no-ignore时才会出现—否则这个文件会被忽略且不会显示！

第二列说明文件或目录的属性的状态（更多细节可以看“属性”一节），如果一个M出现在第二列，说明属性被修改了，否则显示空白。

第三列只显示空白或者L，L表示Subversion已经锁定了这个目录的工作区域.svn，当你的svn commit正在运行的时候—也许正在输入log信息，运行svn status你可以看到L标记，如果这时候Subversion并没有运行，可以推测Subversion发生中断并且已经锁定，你必须运行svn cleanup来清除锁定（本节后面将有更多论述）。

第四列只会显示空白或+，+的意思是一个有附加历史信息的文件或目录预定添加或者修改到版本库，通常出现在svn move或是svn copy时，如果是看到A  +就是说要包含历史的增加，它可以是一个文件或是拷贝的根目录。+表示它是即将包含历史增加到版本库的目录的一部分，也就是说他的父目录要拷贝，它只是跟着一起的。 M  +表示将要包含历史的增加，并且已经更改了。当你提交时，首先会随父目录进行包含历史的增加，然后本地的修改提交到更改后的版本
 
第五列只显示空白或是S，表示这个目录或文件已经转到了一个分支下了（使用svn switch）。
 

svn status也有一个–verbose（-v）选项，它可以显示工作拷贝中的所有项目，即使没有改变过：

$ svn status --verbose
M               44        23    sally     README
44        30    sally     INSTALL
M               44        20    harry     bar.c
44        18    ira       stuff
44        35    harry     stuff/trout.c
D               44        19    ira       stuff/fish.c
44        21    sally     stuff/things
A                0         ?     ?        stuff/things/bloo.h
44        36    harry     stuff/things/gloo.c
第一列保持相同，第二列显示一个工作版本号，第三和第四列显示最后一次修改的版本号和修改人。

上面所有的svn status调用并没有联系版本库，只是与.svn中的元数据进行比较的结果，最后，是–show-updates（-u）参数，它将会联系版本库为已经过时的数据添加新信息：

$ svn status --show-updates --verbose
M      *        44        23    sally     README
M               44        20    harry     bar.c
*        44        35    harry     stuff/trout.c
D               44        19    ira       stuff/fish.c
A                0         ?     ?        stuff/things/bloo.h
Status against revision:   46

注意这两个星号：如果你现在执行svn update，你的README和trout.c会被更新，这告诉你许多有用的信息—你可以在提交之前，需要使用更新操作得到文件README的更新，或者说文件已经过时，版本库会拒绝了你的提交。

 

输出的格式为统一区别格式（unified diff format），删除的行前面加一个-，添加的行前面有一个+，svn diff命令也打印文件名和打补丁需要的信息，所以你可以通过重定向一个区别文件来生成“补丁”：

$ svn diff > patchfile

举个例子，你可以把补丁文件发送邮件到其他开发者，在提交之前审核和测试。

 

看！没有网络！

这三个命令（svn status、svn diff和 svn revert）都可以在没有网络的情况下工作，这让你在没有网络连接时的管理修改过程更加简单，像在飞机上旅行，乘坐火车往返或是在海滩上奋力工作时。

Subversion通过在.svn管理区域使用原始的版本缓存来做到这一点，这使得恢复本地版本而不必访问网络，这个缓存（叫做“text-base”）也允许Subversion可以根据原始版本生成一个压缩的增量（“区别”）提交—即使你有个非常快的网络，有这样一个缓存有极大的好处，非常的快，只向服务器提交修改的部分，这一点乍一看好像并不重要，但当你要提交一个400M大小的文件的修改时，你就会明白！

 

  • 对于每一个冲突的文件，Subversion放置三个额外的未版本化文件到你的工作拷贝：
    filename.mine
    你更新前的文件，没有冲突标志，只是你最新更改的内容。（如果Subversion认为这个文件不可以合并，.mine文件不会创建，因为它和工作文件相同。）

     

    filename.rOLDREV
    这是你的做更新操作以前的BASE版本文件，就是你在上次更新之后未作更改的版本。

     

    filename.rNEWREV
    这是你的Subversion客户端从服务器刚刚收到的版本，这个文件对应版本库的HEAD版本。

     

    这里OLDREV是你的.svn目录中的修订版本号，NEWREV是版本库中HEAD的版本号。

    • svn cat

    如果你只是希望检查一个过去的版本而不希望察看它们的区别，使用svn cat：

    $ svn cat --revision 2 rules.txt
Be kind to others
Freedom = Chocolate Ice Cream
Everything in moderation
Chew with your mouth open
$

    你可以重定向输出到一个文件：

    $ svn cat --revision 2 rules.txt > rules.txt.v2
    除了以上的命令，你可以使用带参数--revision的svn update和svn checkout来使整个工作拷贝“回到过去”[7]：

    $ svn checkout --revision 1729 # Checks out a new working copy at r1729
…
$ svn update --revision 1729 # Updates an existing working copy to r1729
…
    

     
    

    # 建立库
    

    $ svnadmin create /usr/local/svn/newrepos
    

    # 建立分支
    

    建立一个备份只是传递两个目录参数到svn copy命令：

    $ cd bigwc
$ svn copy trunk branches/my-calc-branch
$ svn status
A  +   branches/my-calc-branch
    

     

    现在，我们必须告诉你建立分支最简单的方法：svn copy可以直接对两个URL操作。

    $ svn copy http://svn.example.com/repos/calc/trunk \
http://svn.example.com/repos/calc/branches/my-calc-branch \
-m "Creating a private branch of /calc/trunk."
Committed revision 341.
     
    锁定-修改-解锁问题
    我们有两个共同工作者，Harry和Sally，他们想同时编辑版本库里的同一个文件，如果首先Harry保存它的修改，过了一会，Sally可能凑巧用自己的版本覆盖了这些文件，Harry的更改不会永远消失（因为系统记录了每次修改），Harry所有的修改不会出现在Sally的文件中，所以Harry的工作还是丢失了—至少是从最新的版本中丢失了—而且是意外的，这就是我们要明确避免的情况！
     
    在这种情况下，我们应该明确对需要进行修改的目录进行锁定.
    拷贝-修改-合并模型假定文件是可以根据上下文合并的：就是版本库的文件主要是以行为基础的文本文件（例如程序源代码）。但对于二进制格式，例如艺术品或声音，在这种情况下，十分有必要让用户轮流修改文件，如果没有线性的访问，有些人的许多工作就最终要被放弃。


    fun 2009-05-05 12:00 发表评论
    ]]>    js嵌入到java程序中http://www.blogjava.net/wangfun/archive/2009/05/04/268876.htmlfunfunMon, 04 May 2009 11:30:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/04/268876.html阅读全文

    fun 2009-05-04 19:30 发表评论
    ]]>    常见开源key-value分布式存储系统http://www.blogjava.net/wangfun/archive/2009/05/02/268588.htmlfunfunSat, 02 May 2009 02:16:00 GMThttp://www.blogjava.net/wangfun/archive/2009/05/02/268588.htmlhttp://www.blogjava.net/wangfun/comments/268588.htmlhttp://www.blogjava.net/wangfun/archive/2009/05/02/268588.html#Feedback1http://www.blogjava.net/wangfun/comments/commentRss/268588.htmlhttp://www.blogjava.net/wangfun/services/trackbacks/268588.htmlkey-value分布式存储系统查询速度快、存放数据量大、支持高并发，非常适合通过主键进行查询，但不能进行复杂的条件查询。如果辅以Real- Time Search Engine（实时搜索引擎）进行复杂条件检索、全文检索，就可以替代并发性能较低的MySQL等关系型数据库，达到高并发、高性能，节省几十倍服务器数量的目的。以MemcacheDB、Tokyo Tyrant为代表的key-value分布式存储，在上万并发连接下，轻松地完成高速查询。而MySQL，在几百个并发连接下，就基本上崩溃了。

    　　虽然key-value分布式存储具有极高的性能，但是只能做类似于MySQL的SELECT * FROM table WHERE id = 123;简单主键查询。

    　　“搜索索引引擎＋key-value分布式存储”能够实现高并发的复杂条件查询、全文检索与数据显示。但是，由于索引更新需要时间，目前还不能实现完全意义上的Real-Time Search（实时搜索），只能称之为Near Real-Time Search（准实时搜索）。“搜索索引引擎＋key-value分布式存储”除了做全文检索外，还可以在允许的索引延迟范围内，取代MySQL进行复杂条件查询。

    　　我的文章《亿级数据的高并发通用搜索引擎架构设计》的程序编码已经完成，第一轮测试昨天已经结束，能够在高并发情况下实现1分钟内索引更新，属于“Near Real-Time Search Engine（准实时搜索引擎）＋key-value分布式存储”应用。其中，索引引擎采用Sphinx，存储采用key-value分布式数据库Tokyo Tyrant。

    　　以下是常见的key-value分布式存储系统：

    　　

     

    　　其中，以下几款值得关注：

    　　1、Hypertable：它是搜索引擎公司Zvents根据Google的9位研究人员在2006年发表的一篇论文《Bigtable：结构化数据的分布存储系统》开发的一款开源分布式数据储存系统。Hypertable是按照1000节点比例设计，以 C++撰写，可架在 HDFS 和 KFS 上。尽管还在初期阶段，但已有不错的效能：写入 28M 列的资料，各节点写入速率可达7MB/s，读取速率可达 1M cells/s。Hypertable目前一直没有太多高负载和大存储的应用实例，但是最近，Hypertable项目得到了百度的赞助支持，相信其会有更好的发展，地址：http://www.bt285.cn  BT下载。

    　　点击在新窗口中浏览此图片


    　　2、Tokyo Tyrant：它是日本最大的SNS社交网站mixi.jp开发的 Tokyo Cabinet key-value数据库网络接口。它拥有Memcached兼容协议，也可以通过HTTP协议进行数据交换。对任何原有Memcached客户端来讲，可以将Tokyo Tyrant看成是一个Memcached，但是，它的数据是可以持久存储的。Tokyo Tyrant 具有故障转移、日志文件体积小、大数据量下表现出色等优势，详见：http://www.bt285.cn/aidesefang/
    　　Tokyo Cabinet 2009年1月18日发布的新版本（Version 1.4.0）已经实现 Table Database，将key-value数据库又扩展了一步，有了MySQL等关系型数据库的表和字段的概念，相信不久的将来，Tokyo Tyrant 也将支持这一功能。值得期待。详见：http://www.bt285.cn/sejishikong/

    　　点击在新窗口中浏览此图片


    　　3、CouchDB：它是Apache社区基于 Erlang/OTP 构建的高性能、分布式容错非关系型数据库系统（NRDBMS）。它充分利用 Erlang 本身所提供的高并发、分布式容错基础平台，并且参考 Lotus Notes 数据库实现，采用简单的文档数据类型（document-oriented）。在其内部，文档数据均以 JSON 格式存储。对外，则通过基于 HTTP 的 REST 协议实现接口，可以用十几种语言进行自由操作。

    　　点击在新窗口中浏览此图片


    　　4、MemcacheDB：它是新浪互动社区事业部为在Memcached基础上，增加Berkeley DB存储层而开发一款支持高并发的分布式持久存储系统，对任何原有Memcached客户端来讲，它仍旧是个Memcached，但是，它的数据是可以持久存储的。

    　　点击在新窗口中浏览此图片

    • C47026e2-c744-3526-bcbd-bd4f8829bcb4-thumb
    • 大小: 76.4 KB


    fun 2009-05-02 10:16 发表评论
    ]]>    JSON学习笔记之一http://www.blogjava.net/wangfun/archive/2009/04/27/267765.htmlfunfunMon, 27 Apr 2009 11:07:00 GMThttp://www.blogjava.net/wangfun/archive/2009/04/27/267765.html首先，使用JavaScript的eval()函数实现，将JSON数据串转换成为一个JavaScript对象数组。这里，在Servlet中访问数据库取得记录，并合成JSON串，发送到客户端。

    一般，对于企业级应用，使用JavaScript的eval()函数，存在安全隐患问题。这个例子就是感受一下JSON数据串从服务器段被传送到客户端之后，将数据转换成为对象数组或者对象，从而方便地使用JavaScript来实现遍历。

    看一下我的Permission实体的Hibernate映射文件：

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

    <hibernate-mapping>
    <class name="model.xgb.vo.Permission" table="PERMISSION" lazy="false">
        <composite-id>
          <key-property name="id" column="ID" type="integer"/>
          <key-property name="term" column="TERM" type="string"/>
        </composite-id>
        <property name="endDate" column="ENDDATE" type="date"/>
        <property name="start" column="START" type="date"/>
        <many-to-one name="roles" class="model.xgb.vo.Role" lazy="false" unique="true" cascade="save-update">
          <column name="ROLE_ID"/>
        </many-to-one>
        <many-to-one name="org" class="model.xgb.vo.Org" lazy="false" unique="true" cascade="save-update">
          <column name="ORG_ID"/>
        </many-to-one>
        <many-to-one name="operator" class="model.xgb.vo.Operator" lazy="false" unique="true" cascade="save-update">
          <column name="OPERATOR_ID"/>
          <column name="OPERATOR_NAME"/>
          <column name="OPERATOR_TYPE"/>
        </many-to-one>
    </class>
    </hibernate-mapping>

    现在，就是在Servlet中读取对应的记录，然后构造JSON数据，实现的Servlet为GetPermissions，如下所示：

    package org.shirdrn.servlet;

    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;

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

    import model.xgb.bo.ManagerService;
    import model.xgb.bo.impl.ManagerServiceImpl;
    import model.xgb.vo.Permission;
    import cn.edu.cust.levin.BusinessException;
    import cn.edu.cust.levin.business.BusinessFactory;

    /** author http://www.bt285.cn http://www.5a520.cn
    */

    public class GetPermissions extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
       static final long serialVersionUID = 1L;

    public GetPermissions() {
       super();
    }  

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       doPost(request,response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       request.setCharacterEncoding("utf-8");
       response.setCharacterEncoding("utf-8");
       response.setHeader("Cache-Control", "no-cache");
       response.setContentType("text/json;charset=UTF-8");
       String semester = java.net.URLDecoder.decode(request.getParameter("semester"),"UTF-8");
       int orgId = Integer.parseInt(request.getParameter("orgId"));
       PrintWriter out = response.getWriter();
       try {
        ManagerService managerService = (ManagerService)BusinessFactory
         .getBusiness(ManagerServiceImpl.class);
        List permissionList = managerService.getPermissionByOrg(orgId, semester);
        String jsonString = "[";
        for(int i=0;i<permissionList.size();i++) {
         Permission permission = (Permission)permissionList.get(i);
         jsonString += "{";
         jsonString += "\"id\":" + permission.getId() +",";
         jsonString += "\"semester\":\"" + permission.getTerm() +"\",";
         jsonString += "\"startTime\":\"" + permission.getStart().toLocaleString() +"\",";
         jsonString += "\"endTime\":\"" + permission.getEndDate().toLocaleString() +"\",";
         jsonString += "\"orgId\":" + permission.getOrg().getId() +",";
         jsonString += "\"operatorId\":" + permission.getOperator().getId() +",";
         jsonString += "\"operatorName\":\"" + permission.getOperator().getName() +"\",";
         jsonString += "\"roleId\":" + permission.getRoles().getId();
         if(i != permissionList.size()-1) {
          jsonString += "},";
         }
         else {
          jsonString += "}]";
         }
        }
        out.print(jsonString);
        out.flush();
        out.close();
       } catch (BusinessException e) {
        e.printStackTrace();
       }
    }          
    }

    用于显示记录的JSP页面如下所示：

    <%@ page language="java" import="java.util.*,model.xgb.vo.*" contentType="text/html; charset=utf-8"
        pageEncoding="utf-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Get Permissions</title>
    <script type="text/javascript" src="js/shirdrnPermission.js"></script>
    </head>
    <body onLoad="pageLoad();">
    <div id="list"></div>
    </body>
    </html>

    我通过使用onLoad事件，加载页面的时候，调用pageLoad()函数，该函数在js/shirdrnPermission.js中实现了，其中js/shirdrnPermission.js的实现如下所示：

    var xmlHttp = null;

    function pageLoad() {
    document.body.style.color = "yellow";
    showPermissions();
    }

    function createXMLHttp() {
    if (typeof XMLHttpRequest != "undefined") {
       return new XMLHttpRequest();
    } else {
       if (window.ActiveXObject) {
        var aVersions = ["MSXML2.XMLHttp.5.0", "MSXML2.XMLHttp.4.0", "MSXML2.XMLHttp.3.0", "MSXML2.XMLHttp", "Microsoft.XMLHttp"];
        for (var i = 0; i < aVersions.length; i++) {
         try {
          return new ActiveXObject(aVersions[i]);
         }
         catch (e) {
          alert("error");
         }
        }
       }
    }
    }

    var permissionArray;
    var html = null;

    function showPermissions() {
    html = "<table bgcolor='green' border='1' width='100%'>"
       + "<tr>"
       + "<th>权限ID</th>"
       + "<th>学期</th>"
       + "<th>起始时间</th>"
       + "<th>截止时间</th>"
       + "<th>组织ID</th>"
       + "<th>操作ID</th>"
       + "<th>操作名称</th>"
       + "<th>角色ID</th>"
       + "</tr>";
    if(xmlHttp == null) {
       xmlHttp = createXMLHttp();
    }
    var url = "&semester=" + "2008-2009学年第一学期"
        + "&orgId=" + 1;
    xmlHttp.open("GET","getPermissions.servlet?" + encodeURI(encodeURI(url)),true); // GetPermissions在web.xml中配置为<url-pattern>/getPermissions.servlet</url-pattern>
    xmlHttp.onreadystatechange = function() {
       if(xmlHttp.readyState == 4 && xmlHttp.status == 200) {
        permissionArray = eval("(" + xmlHttp.responseText + ")"); // 将从服务器请求得到的JSON串转换为JavaScript的数组(这里是对象数组)
        for(var i=0;i<permissionArray.length;i++) {
         html += "<tr>";
         html += "<td>" + permissionArray[i].id +"</td>";
         html += "<td>" + permissionArray[i].semester +"</td>";
         html += "<td>" + permissionArray[i].startTime +"</td>";
         html += "<td>" + permissionArray[i].endTime +"</td>";
         html += "<td>" + permissionArray[i].orgId +"</td>";
         html += "<td>" + permissionArray[i].operatorId +"</td>";
         html += "<td>" + permissionArray[i].operatorName +"</td>";
         html += "<td>" + permissionArray[i].roleId +"</td>";
         html += "</tr>";
        }
        html += "</table>";
        var listContainer = document.getElementById("list");
        listContainer.innerHTML = html;
       }
    }
    xmlHttp.send(null);
    }

    启动WEB服务器，访问链接http://www.5a520.cn  :8080/xgb/listPermissions.jsp可以看到页面显示的结果，如下所示：

    使用JSON进行数据传送，比之于XML自然有很大的优势，至少JSON更加精简，将无关紧要的数据尽量压缩，所以速度比XML要快。

    另外，JSON上面的这种使用方式就是使用JavaScript中的eval()函数来实现数据到类型的转换，使用JavaScript的数组或者对象就能遍历数据，而XML还要在JavaScript中使用XML DOM操作。



    fun 2009-04-27 19:07 发表评论
    ]]>    activeMQ笔记之一 http://www.blogjava.net/wangfun/archive/2009/04/26/267588.htmlfunfunSun, 26 Apr 2009 09:47:00 GMThttp://www.blogjava.net/wangfun/archive/2009/04/26/267588.html阅读全文

    fun 2009-04-26 17:47 发表评论
    ]]>