BlogJava-BlueSpace-文章分类-java

判断是否存在中文

crazy — Sun, 16 Dec 2007 13:07:00 GMT

方法一
String temp = "";
temp.getBytes().length == temp.length()
判断不太准确..当数字等为全角的时候也为双字节

方法二
正则表达式
Pattern   p   =   Pattern.compile("[\\u4E00-\\u9FA5]+");
Matcher   m   =   p.matcher(temp);
boolean   result   =   m.find();

crazy 2007-12-16 21:07 发表评论

java正则表达式

crazy — Sat, 15 Dec 2007 04:19:00 GMT

最近要在项目中做HTML解析,本想使用NekoHTML来解析,但看了下NekoHTML有点复杂,故采用了一种便捷,笨的方式来完成项目的要求. 正则表达式此时发挥了她巨大的威力,为我排忧解难,很快便完成了HTML解析工作.

在解析期间,研究了很多java正则表达式使用方法,颇得一些经验,不敢独享,愿与大家共享.

java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳).

Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式,

Java代码示例:

Pattern p=Pattern.compile("\\w+");

p.pattern();//返回 \w+

pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

1.Pattern.split(CharSequence input)

Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com");

结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com"

2.Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

Java代码示例:

Pattern.matches("\\d+","2223");//返回true

Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到

Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到

3.Pattern.matcher(CharSequence input)

说了这么多,终于轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象.

Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.

Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("22bb23");

m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的

4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()

Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false

matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("22bb23");

m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功.

Matcher m2=p.matcher("2223");

m2.matches();//返回true,因为\d+匹配到了整个字符串

我们现在回头看一下Pattern.matcher(String regex,CharSequence input),它与下面这段代码等价

Pattern.compile(regex).matcher(input).matches()

lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("22bb23");

m.lookingAt();//返回true,因为\d+匹配到了前面的22

Matcher m2=p.matcher("aa2223");

m2.lookingAt();//返回false,因为\d+不能匹配前面的aa

find()对字符串进行匹配,匹配到的字符串可以在任何位置.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("22bb23");

m.find();//返回true

Matcher m2=p.matcher("aa2223");

m2.find();//返回true

Matcher m3=p.matcher("aa2223bb");

m3.find();//返回true

Matcher m4=p.matcher("aabb");

m4.find();//返回false

5.Mathcer.start()/ Matcher.end()/ Matcher.group()

当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息.

start()返回匹配到的子字符串在字符串中的索引位置.

end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.

group()返回匹配到的子字符串

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("aaa2223bb");

m.find();//匹配2223

m.start();//返回3

m.end();//返回7,返回的是2223后的索引号

m.group();//返回2223

Mathcer m2=m.matcher("2223bb");

m.lookingAt(); //匹配2223

m.start(); //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0

m.end(); //返回4

m.group(); //返回2223

Matcher m3=m.matcher("2223bb");

m.matches(); //匹配整个字符串

m.start(); //返回0,原因相信大家也清楚了

m.end(); //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串

m.group(); //返回2223bb

说了这么多,相信大家都明白了以上几个方法的使用,该说说正则表达式的分组在java中是怎么使用的.

start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组.

Java代码示例:

Pattern p=Pattern.compile("([a-z]+)(\\d+)");

Matcher m=p.matcher("aaa2223bb");

m.find(); //匹配aaa2223

m.groupCount(); //返回2,因为有2组

m.start(1); //返回0 返回第一组匹配到的子字符串在字符串中的索引号

m.start(2); //返回3

m.end(1); //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置.

m.end(2); //返回7

m.group(1); //返回aaa,返回第一组匹配到的子字符串

m.group(2); //返回2223,返回第二组匹配到的子字符串

现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");

while(m.find()) {

System.out.println(m.group());

}

输出:

456456

0532214

123

如将以上while()循环替换成

while(m.find()) {

System.out.println(m.group());

System.out.print("start:"+m.start());

System.out.println(" end:"+m.end());

}

则输出:

456456

start:6 end:12

0532214

start:19 end:26

123

start:36 end:39

现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息.

注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用.

6.Matcher. replaceAll ( String replacement) / Matcher.replaceFirst(String replacement)

大家应该知道String.replaceAll()和String.replaceFirst()两个方法的功能,其实它与Matcher.replaceAll()和Matcher.replaceFirst()的功能是一样的,只不过是使用方式不一样.例如我要将某文本中的所有数字变成*

使用String完成该要求

Java代码示例:

String str="我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com";

System.out.println(str.replaceAll("\\d","*"));

输出: 我的QQ是:****** 我的电话是:******* 我的邮箱是:aaa***@aaa.com

现在我们用Matcher完成该要求

Java代码示例:

Pattern p=Pattern.compile("\\d");

Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");

System.out.println(m.replaceAll("*"));

输出: 我的QQ是:****** 我的电话是:******* 我的邮箱是:aaa***@aaa.com

String.replaceAll()应该是调用了Matcher.replaceAll(),String.replaceAll()与下面这段代码等价

Pattern . compile ( regex ).matcher( str ).replaceAll( replacement )

至于Matcher.replaceFirst()也很简单,它与String.replaceFirst()功能一样,我就不多说了.

str .replaceFirst( regex , replacement )与下面这段代码等价

Pattern.compile(regex).matcher(str).replaceFirst(replacement)

7.Matcher. appendReplacement ( StringBuffer sb, String replacement) / Matcher.appendTail(StringBuffer sb)

将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里，而appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里．看例子：

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");

StringBuffer sb=new StringBuffer();

m.find(); //匹配到456456

m.appendReplacement(sb,"*"); //将456456之前的字符串追加到sb,再将456456替换为*,并追加到sb

System.out.println(sb.toString());

m.appendTail(sb); //将前面替换过的内容连接后面未替换过的内容,并放入sb

System.out.println(sb.toString());

输出：

我的QQ是:*
我的QQ是:* 我的电话是:0532214 我的邮箱是:aaa123@aaa.com

再看一个例子

Java代码示例:

Pattern p=Pattern.compile("\\d+");

Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");

StringBuffer sb=new StringBuffer();

while(m.find()) {

m.appendReplacement(sb,"*");

System.out.println(sb.toString());

}

m.appendTail(sb);

System.out.println("使用appendTail()的最终内容是："+sb.toString());

输出：

我的QQ是:*
我的QQ是:* 我的电话是:*
我的QQ是:* 我的电话是:* 我的邮箱是:aaa*
使用appendTail()的最终内容是：我的QQ是:* 我的电话是:* 我的邮箱是:aaa*@aaa.com

关于这两个方法就介绍到这,如果不明白的话,还需要自己动下手,认真体会一下其内涵.

8.Matcher.region (int start, int end) / Matcher.regionEnd() / Matcher.regionStart()

我们在做匹配操作时,默认去匹配的是整个字符串,例如有一字符串"aabbcc",使用"\\d+"去find()时,是从第一个a开始匹配,也就是索引号为0的位置,开始去匹配,当索引号为0的位置没有匹配到时,就去下一个位置去匹配...直到匹配到子字符串或匹配完最后一个字符索引号才结束,很显然"\\d+"不能匹配"aabbcc",当它匹配完最后一个c时,结束本次匹配,宣告匹配失败,也就是说它会去匹配完整个字符串,能不能不去匹配完整个字符串呢,答案是可以的.

region(int start,int end)就是用来设置此匹配器的区域限制。

先来看一个例子.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

String content="aaabb2233cc";
Matcher m=p.matcher(content);
System.out.println(m);

输出: java.util.regex.Matcher[pattern=\d+ region=0,11 lastmatch=]

可以看到region=0,11 表示start=0,end=11,更通俗的说就是当去匹配字符串,先从索引号为0的位置去匹配,如果匹配到了子字符串就返回,如果没有匹配到则到下一个位置去匹配,一直匹配到索引号为11-1的字符就结束匹配.

为什么是11呢,因为content.length()==11

现在你应该明白了它的作用,来看一个例子.

Java代码示例:

Pattern p=Pattern.compile("\\d+");

String content="aaabb2233cc";
Matcher m=p.matcher(content);
m.find(); //匹配到2223,返回true

Matcher m2=p.matcher(content);

m2.region(0,5);

m2.find(); //返回false,只去匹配索引号0至5-1的字符,没有匹配到

Matcher m3=p.matcher(content);

m2.region(3,8);

m2.find(); //返回true

m2.group(); //返回223,为什么,请数一下索引号就知道了.

Matcher.regionStart()返回region(int start,int end)中的start值,默认为0

Matcher.regionEnd()返回region(int start,int end)中的end值,默认为去匹配字符串的length()值

9.Matcher. reset () / Matcher.reset(CharSequence input)

用于重置匹配器。看示例

Java代码示例:

Pattern p=Pattern.compile("[a-z]+");

String content="aaabb2233cc";
Matcher m=p.matcher(content); //此时m刚创建出来,为最初状态

m.find();

m.group(); //返回aaabb

m.find();

m.group(); //返回cc

Matcher m2=p.matcher(content); //此时m2刚创建出来,为最初状态

m.find();

m.group(); //返回aaabb

m.reset(); //恢复到了最初状态,此时相当于m2刚创建出来

m.find();

m.group(); //返回aaabb,相信大家应该知道了吧

Matcher.reset(CharSequence input) 恢复到最初状态,并将匹配字符串换成input,以后执行匹配操作时,就来匹配input,而不匹配原来的字符串了.

10.Matcher.toMatchResult ()

大家查看一下java API 对Matcher类的说明,会发现它实现了MatchResult 接口,这个接口只有以下几个方法

groupCount()

group() / group(int i)

start() / start(int i)

end() / end(int i)

至于这几个方法的功能前面已经介绍过,现在我们来看一下toMatchResult() 是如何使用的

Java代码示例:

Pattern p=Pattern.compile("\\d+");
Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");
List list=new ArrayList();
while(m.find()) {
    list.add(m.toMatchResult());
}
MatchResult matchResult=null;
Iterator it=list.iterator();
int i=1;
while(it.hasNext()) {
    matchResult=(MatchResult)it.next();
    System.out.print("第"+(i++)+"次匹配到的信息: ");
    System.out.println(matchResult.group()+"\t\t"+matchResult.start()+"\t"+matchResult.end());
}

输出:

第1次匹配到的信息: 456456          6      12
第2次匹配到的信息: 0532214        19      26
第3次匹配到的信息: 123                36      39

现在你应该知道,toMatchResult()用于保存某次匹配后的信息,待以后再使用.

方法使用就说到这里,现在再介绍一个实例

有这样一个需求,有一个HTML文件,需要将其中的内容抽取出来,并不带HTML标签,如果使用正则表达式,这是一件很容易的事情. 前提是这个HTML文件只保留了标签以内的内容.

Java代码示例:

String html="

example1

"; //可以是任何html文件源代码,但格式一定要正确

Pattern p=Pattern.compile("<[^>]*>");

Matcher m=p.matcher(html);

String result=m.replaceAll("");

System.out.println(result);

输出:example1

参考资料：
java.util.regex的API文档
陈广佳的JAVA正则表达式--Pattern和Matcher

crazy 2007-12-15 12:19 发表评论

linux文件权限查看及修改

crazy — Fri, 14 Dec 2007 06:53:00 GMT

查看linux文件的权限：ls -l 文件名称

查看linux文件夹的权限：ls -ld 文件夹名称（所在目录）

修改文件及文件夹权限：

sudo chmod -（代表类型）×××（所有者）×××（组用户）×××（其他用户）

常用修改权限的命令：

sudo chmod 600 ××× （只有所有者有读和写的权限）

sudo chmod 644 ××× （所有者有读和写的权限，组用户只有读的权限）

sudo chmod 700 ××× （只有所有者有读和写以及执行的权限）

sudo chmod 666 ××× （每个人都有读和写的权限）

sudo chmod 777 ××× （每个人都有读和写以及执行的权限）

crazy 2007-12-14 14:53 发表评论

正则表达式,不区分大小写的替换

crazy — Fri, 14 Dec 2007 02:37:00 GMT

/**不区分大小写的替换**/
    public String IgnoreCaseReplace(String source, String oldstring,String newstring)
   {
      Pattern p = Pattern.compile(oldstring, Pattern.CASE_INSENSITIVE);
      Matcher m = p.matcher(source);
      String ret=m.replaceAll(newstring);
      return ret;
   }

crazy 2007-12-14 10:37 发表评论

二种include

crazy — Thu, 13 Dec 2007 15:36:00 GMT

以下是对include 两种用法的区别
主要有两个方面的不同;
一:执行时间上:
<%@ include file=”relativeURI”%> 是在翻译阶段执行
在请求处理阶段执行.
二:引入内容的不同:
<%@ include file=”relativeURI”%>
引入静态文本(html,jsp),在JSP页面被转化成servlet之前和它融和到一起.
引入执行页面或servlet所生成的应答文本.

file是先把内容组合.再一起编译成一个文件. page 是先编译,产生二个class文件.file文件的值可以向下传.而page就不能.file文件找不到会报错,page不会.

crazy 2007-12-13 23:36 发表评论

log4j详解 (摘抄过来的)

crazy — Sat, 08 Dec 2007 05:36:00 GMT

根据网络资料整理
>>>>1. 概述<<<<
　　1.1. 背景
　　
　　在应用程序中添加日志记录总的来说基于三个目的：监视代码中变量的变化情况，周期性的记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的依据；担当集成开发环境中的调试器的作用，向文件或控制台打印代码的调试信息。
　　
　　最普通的做法就是在代码中嵌入许多的打印语句，这些打印语句可以输出到控制台或文件中，比较好的做法就是构造一个日志操作类来封装此类操作，而不是让一系列的打印语句充斥了代码的主体。
　　
　　1.2. Log4j简介
　　
　　在强调可重用组件开发的今天，除了自己从头到尾开发一个可重用的日志操作类外，Apache为我们提供了一个强有力的日志操作包-Log4j。
　　
　　Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
　　
　　此外，通过Log4j其他语言接口，您可以在C、C+ +、.Net、PL/SQL程序中使用Log4j，其语法和用法与在Java程序中一样，使得多语言分布式系统得到一个统一一致的日志组件模块。而且，通过使用各种第三方扩展，您可以很方便地将Log4j集成到J2EE、JINI甚至是SNMP应用中。
　　
　　本文介绍的Log4j版本是 1.2.3。作者试图通过一个简单的客户/服务器Java程序例子对比使用与不使用Log4j 1.2.3的差别，并详细讲解了在实践中最常使用Log4j的方法和步骤。在强调可重用组件开发的今天，相信Log4j将会给广大的设计开发人员带来方便。加入到Log4j的队伍来吧！
　　
>>>> 2. 一个简单的例子 <<<<

　　我们先来看一个简单的例子，它是一个用Java实现的客户/服务器网络程序。刚开始我们不使用Log4j，而是使用了一系列的打印语句，然后我们将使用Log4j来实现它的日志功能。这样，大家就可以清楚地比较出前后两个代码的差别。
　　
　　2.1. 不使用Log4j
　　
　　2.1.1. 客户程序
　　package log4j ;
　　
　　import java.io.* ;
　　import java.net.* ;
　　
　　/**
　　 *
　　 *

Client Without Log4j

Description: a sample with log4j

　　 * @version 1.0
　　 */
　　public class ClientWithoutLog4j {
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args [] ) {
　　
　　　　　　String welcome = null;
　　　　　　String response = null;
　　　　　　BufferedReader reader = null;
　　　　　　PrintWriter writer = null;
　　　　　　InputStream in = null;
　　　　　　OutputStream out = null;
　　　　　　Socket client = null;
　　
　　　　　　try {
　　　　　　　　client = new Socket ( "localhost", 8001 ) ;
　　　　　　　　System.out.println ( "info: Client socket: " + client ) ;
　　　　　　　　in = client.getInputStream () ;
　　　　　　　　out = client.getOutputStream () ;
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println ( "error: IOException : " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　
　　　　　　try{
　　　　　　　　reader = new BufferedReader( new InputStreamReader ( in ) ) ;
　　　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　　　welcome = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server says: '" + welcome + "'" ) ;
　　
　　　　　　　　System.out.println ( "debug: HELLO" ) ;
　　　　　　　　writer.println ( "HELLO" ) ;
　　　　　　　　response = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server responds: '" + response + "'") ;
　　
　　　　　　　　System.out.println ( "debug: HELP" ) ;
　　　　　　　　writer.println ( "HELP" ) ;
　　　　　　　　response = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server responds: '" + response + "'" ) ;
　　
　　　　　　　　System.out.println ( "debug: QUIT" ) ;
　　　　　　　　writer.println ( "QUIT" ) ;
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println ( "warn: IOException in client.in.readln()" ) ;
　　　　　　　　System.out.println ( e ) ;
　　　　　　}
　　　　　　try{
　　　　　　　　Thread.sleep ( 2000 ) ;
　　　　　　} catch ( Exception ignored ) {}
　　　　}
　　}
　　
　　2.1.2. 服务器程序
　　package log4j ;
　　
　　import java.util.* ;
　　import java.io.* ;
　　import java.net.* ;
　　
　　/**
　　 *
　　 *

Server Without Log4j

Description: a sample with log4j

　　 * @version 1.0
　　 */
　　public class ServerWithoutLog4j {
　　
　　　　final static int SERVER_PORT = 8001 ; // this server's port
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args [] ) {
　　　　　　String clientRequest = null;
　　　　　　BufferedReader reader = null;
　　　　　　PrintWriter writer = null;
　　　　　　ServerSocket server = null;
　　　　　　Socket socket = null;
　　　　　　InputStream in = null;
　　　　　　OutputStream out = null;
　　
　　　　　　try {
　　　　　　　　server = new ServerSocket ( SERVER_PORT ) ;
　　　　　　　　System.out.println ( "info: ServerSocket before accept: " + server ) ;
　　　　　　　　System.out.println ( "info: Java server without log4j, on-line!" ) ;
　　
　　　　　　　　// wait for client's connection
　　　　　　　　socket = server.accept () ;
　　　　　　　　System.out.println ( "info: ServerSocket after accept: " + server )　;
　　
　　　　　　　　in = socket.getInputStream () ;
　　　　　　　　out = socket.getOutputStream () ;
　　
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println( "error: Server constructor IOException: " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ) , true ) ;
　　
　　　　　　// send welcome string to client
　　　　　　writer.println ( "Java server without log4j, " + new Date () ) ;
　　
　　　　　　while ( true ) {
　　　　　　　　try {
　　　　　　　　　　// read from client
　　　　　　　　　　clientRequest = reader.readLine () ;
　　　　　　　　　　System.out.println ( "debug: Client says: " + clientRequest ) ;
　　　　　　　　　　if ( clientRequest.startsWith ( "HELP" ) ) {
　　　　　　　　　　　　System.out.println ( "debug: OK!" ) ;
　　　　　　　　　　　　writer.println ( "Vocabulary: HELP QUIT" ) ;
　　　　　　　　　　}
　　　　　　　　　　else {
　　　　　　　　　　　　if ( clientRequest.startsWith ( "QUIT" ) ) {
　　　　　　　　　　　　　　System.out.println ( "debug: OK!" ) ;
　　　　　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　　　　　}
　　　　　　　　　　　　else{
　　　　　　　　　　　　　　System.out.println ( "warn: Command '" +
　　 clientRequest + "' not understood." ) ;
　　　　　　　　　　　　　　writer.println ( "Command '" + clientRequest
　　 + "' not understood." ) ;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　} catch ( IOException e ) {
　　　　　　　　　　System.out.println ( "error: IOException in Server " + e ) ;
　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
　　
　　2.2. 迁移到Log4j
　　
　　2.2.1. 客户程序
　　
　　package log4j ;
　　
　　import java.io.* ;
　　import java.net.* ;
　　
　　// add for log4j: import some package
　　import org.apache.log4j.PropertyConfigurator ;
　　import org.apache.log4j.Logger ;
　　import org.apache.log4j.Level ;
　　
　　/**
　　 *
　　 *

Client With Log4j

Description: a sample with log4j

　　 * @version 1.0
　　 */
　　public class ClientWithLog4j {
　　
　　　　/*
　　　　add for log4j: class Logger is the central class in the log4j package.
　　　　we can do most logging operations by Logger except configuration.
　　　　getLogger(...): retrieve a logger by name, if not then create for it.
　　　　*/
　　　　static Logger logger = Logger.getLogger
　　 ( ClientWithLog4j.class.getName () ) ;
　　
　　　　/**
　　　　 *
　　　　 * @param args : configuration file name
　　　　 */
　　　　public static void main ( String args [] ) {
　　
　　　　　　String welcome = null ;
　　　　　　String response = null ;
　　　　　　BufferedReader reader = null ;
　　　　　　PrintWriter writer = null ;
　　　　　　InputStream in = null ;
　　　　　　OutputStream out = null ;
　　　　　　Socket client = null ;
　　
　　　　　　/*
　　　　　　add for log4j: class BasicConfigurator can quickly configure the package.
　　　　　　print the information to console.
　　　　　　*/
　　　　　　PropertyConfigurator.configure ( "ClientWithLog4j.properties" ) ;
　　
　　　　　　// add for log4j: set the level
　　//　　　　logger.setLevel ( ( Level ) Level.DEBUG ) ;
　　
　　　　　　try{
　　　　　　　　client = new Socket( "localhost" , 8001 ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "Client socket: " + client ) ;
　　
　　　　　　　　in = client.getInputStream () ;
　　　　　　　　out = client.getOutputStream () ;
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　logger.error ( "IOException : " + e ) ;
　　
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　
　　　　　　try{
　　　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　　　welcome = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server says: '" + welcome + "'" ) ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "HELLO" ) ;
　　
　　　　　　　　writer.println ( "HELLO" ) ;
　　　　　　　　response = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server responds: '" + response + "'" ) ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "HELP" ) ;
　　
　　　　　　　　writer.println ( "HELP" ) ;
　　　　　　　　response = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server responds: '" + response + "'") ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "QUIT" ) ;
　　
　　　　　　　　writer.println ( "QUIT" ) ;
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the warn level
　　　　　　　　logger.warn ( "IOException in client.in.readln()" ) ;
　　
　　　　　　　　System.out.println ( e ) ;
　　　　　　}
　　　　　　try {
　　　　　　　　Thread.sleep ( 2000 ) ;
　　　　　　} catch ( Exception ignored ) {}
　　　　}
　　}
　　
　　2.2.2. 服务器程序
　　
　　package log4j;
　　
　　import java.util.* ;
　　import java.io.* ;
　　import java.net.* ;
　　
　　// add for log4j: import some package
　　import org.apache.log4j.PropertyConfigurator ;
　　import org.apache.log4j.Logger ;
　　import org.apache.log4j.Level ;
　　
　　/**
　　 *
　　 *

Server With Log4j

Description: a sample with log4j

　　 * @version 1.0
　　 */
　　public class ServerWithLog4j {
　　
　　　　final static int SERVER_PORT = 8001 ; // this server's port
　　
　　　　/*
　　　　add for log4j: class Logger is the central class in the log4j package.
　　　　we can do most logging operations by Logger except configuration.
　　　　getLogger(...): retrieve a logger by name, if not then create for it.
　　　　*/
　　　　static Logger logger = Logger.getLogger
　　 ( ServerWithLog4j.class.getName () ) ;
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args[]) {
　　　　　　String clientRequest = null ;
　　　　　　BufferedReader reader = null ;
　　　　　　PrintWriter writer = null ;
　　　　　　ServerSocket server = null ;
　　　　　　Socket socket = null ;
　　
　　　　　　InputStream in = null ;
　　　　　　OutputStream out = null ;
　　
　　　　　　/*
　　　　　　add for log4j: class BasicConfigurator can quickly configure the package.
　　　　　　print the information to console.
　　　　　　*/
　　　　　　PropertyConfigurator.configure ( "ServerWithLog4j.properties" ) ;
　　
　　　　　　// add for log4j: set the level
　　//　　　　logger.setLevel ( ( Level ) Level.DEBUG ) ;
　　
　　　　　　try{
　　　　　　　　server = new ServerSocket ( SERVER_PORT ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "ServerSocket before accept: " + server ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "Java server with log4j, on-line!" ) ;
　　
　　　　　　　　// wait for client's connection
　　　　　　　　socket = server.accept() ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "ServerSocket after accept: " + server ) ;
　　
　　　　　　　　in = socket.getInputStream() ;
　　　　　　　　out = socket.getOutputStream() ;
　　
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　logger.error ( "Server constructor IOException: " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　// send welcome string to client
　　　　　　writer.println ( "Java server with log4j, " + new Date () ) ;
　　
　　　　　　while ( true ) {
　　　　　　　　try {
　　　　　　　　　　// read from client
　　　　　　　　　　clientRequest = reader.readLine () ;
　　
　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　logger.debug ( "Client says: " + clientRequest ) ;
　　
　　　　　　　　　　if ( clientRequest.startsWith ( "HELP" ) ) {
　　
　　　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　　　logger.debug ( "OK!" ) ;
　　
　　　　　　　　　　　　writer.println ( "Vocabulary: HELP QUIT" ) ;
　　　　　　　　　　}
　　　　　　　　　　else {
　　　　　　　　　　　　if ( clientRequest.startsWith ( "QUIT" ) ) {
　　
　　　　　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　　　　　logger.debug ( "OK!" ) ;
　　
　　　　　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　
　　　　　　　　　　　　　　// add for log4j: log a message with the warn level
　　　　　　　　　　　　　　logger.warn ( "Command '"
　　 + clientRequest + "' not understood." ) ;
　　
　　　　　　　　　　　　　　writer.println ( "Command '"
　　 + clientRequest + "' not understood." ) ;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　　　logger.error( "IOException in Server " + e ) ;
　　
　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
　　
　　2.2.3. 配置文件
　　
　　2.2.3.1. 客户程序配置文件
　　
　　log4j.rootLogger=INFO, A1
　　
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
　　
　　2.2.3.2. 服务器程序配置文件
　　
　　log4j.rootLogger=INFO, A1
　　
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
　　
　　2.3. 比较
　　
　　比较这两个应用可以看出，采用Log4j进行日志操作的整个过程相当简单明了，与直接使用System.out.println语句进行日志信息输出的方式相比，基本上没有增加代码量，同时能够清楚地理解每一条日志信息的重要程度。通过控制配置文件，我们还可以灵活地修改日志信息的格式，输出目的地等等方面，而单纯依靠System.out.println语句，显然需要做更多的工作。

>>>> 3 . Log4j日志管理系统简单使用说明 <<<<

    通常，我们都提供一个名为 log4j.properties的文件，在第一次调用到Log4J时，Log4J会在类路径（../web-inf/class/当然也可以放到其它任何目录，只要该目录被包含到类路径中即可）中定位这个文件，并读入这个文件完成的配置。这个配置文件告诉Log4J以什么样的格式、把什么样的信息、输出到什么地方。
　　Log4j有三个主要的组件：Loggers(记录器)，Appenders(输出源)和Layouts(布局)，这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松的记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。下面对三个组件分别进行说明：
　　
　　1、 Loggers
　　Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < WARN < ERROR < FATAL，分别用来指定这条日志信息的重要程度,明白这一点很重要，这里Log4j有一个规则：假设Loggers级别为P，如果在Loggers中发生了一个级别Q比P高，则可以启动，否则屏蔽掉。
假设你定义的级别是info，那么error和warn的日志可以显示而比他低的debug信息就不显示了。
　
　　Java程序举例来说：
　　
　　//建立Logger的一个实例，命名为“com.foo”
　　　Logger　logger = Logger.getLogger("com.foo"); //"com.foo"是实例进行命名，也可以任意
　　//设置logger的级别。通常不在程序中设置logger的级别。一般在配置文件中设置。
　　logger.setLevel(Level.INFO);
　　Logger barlogger = Logger.getLogger("com.foo.Bar");
　　//下面这个请求可用，因为WARN >= INFO
　　logger.warn("Low fuel level.");
　　//下面这个请求不可用，因为DEBUG < INFO
　　logger.debug("Starting search for nearest gas station.");
　　//命名为“com.foo.bar”的实例barlogger会继承实例“com.foo”的级别。因此，下面这个请求可用，因为INFO >= INFO
　　barlogger.info("Located nearest gas station.");
　　//下面这个请求不可用，因为DEBUG < INFO
　　barlogger.debug("Exiting gas station search");
　　这里“是否可用”的意思是能否输出Logger信息。
　　　　在对Logger实例进行命名时，没有限制，可以取任意自己感兴趣的名字。一般情况下建议以类的所在位置来命名Logger实例，这是目前来讲比较有效的Logger命名方式。这样可以使得每个类建立自己的日志信息，便于管理。比如：
　　
　　static Logger logger = Logger.getLogger(ClientWithLog4j.class.getName());
　　
　　2、Appenders
　　禁用与使用日志请求只是Log4j其中的一个小小的地方，Log4j日志系统允许把日志输出到不同的地方，如控制台（Console）、文件（Files）、根据天数或者文件大小产生新的文件、以流的形式发送到其它地方等等。
　　
　　其语法表示为：
　　
　　org.apache.log4j.ConsoleAppender（控制台）
　　org.apache.log4j.FileAppender（文件）
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
    org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
　　
　　配置时使用方式为：
　　log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
    log4j.appender.appenderName.option = valueN
　　这样就为日志的输出提供了相当大的便利。
　　
　　3、Layouts
　　有时用户希望根据自己的喜好格式化自己的日志输出。Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供了四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式等等。
　　
　　其语法表示为：
　　
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
　　
　　配置时使用方式为：
　　
　　log4j.appender.appenderName.layout =fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

>>>> 4 . Log4j的配置 <<<<　　
　　
　　以上是从原理方面说明Log4j的使用方法，在具体Java编程使用Log4j可以参照以下示例：
　　
　　1、建立Logger实例：
　　语法表示：public static Logger getLogger( String name)
　　实际使用：static Logger logger = Logger.getLogger(ServerWithLog4j.class.getName ()) ;
　　
　　2、读取配置文件：
　　获得了Logger的实例之后，接下来将配置Log4j使用环境：
　　语法表示：
　　BasicConfigurator.configure()：自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure(String configFilename)：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure(String filename)：读取XML形式的配置文件。
　　实际使用：
PropertyConfigurator.configure("ServerWithLog4j.properties");
　　
　　3、插入日志信息
　　完成了以上连个步骤以后，下面就可以按日志的不同级别插入到你要记录日志的任何地方了。
　　语法表示：
　　Logger.debug(Object message);//调试信息
　　Logger.info(Object message);//一般信息
　　Logger.warn(Object message);//警告信息
　　Logger.error(Object message);//错误信息
　　Logger.fatal(Object message);//致命错误信息

　　实际使用：logger.info("ServerSocket before accept: " + server);
　　
　>>>> 5. 配置过程 <<<<

　在实际编程时，要使Log4j真正在系统中运行事先还要对配置文件进行定义。定义步骤就是对Logger、Appender及Layout的分别使用。
    Log4j支持两种配置文件格式，一种是XML格式的文件，一种是java properties（key=value）【Java特性文件（键=值）】。下面我们介绍使用Java特性文件做为配置文件的方法
   具体如下：
　　
　　1、配置根Logger，其语法为：
　　log4j.rootLogger = [ level ] , appenderName1, appenderName2, …
         level : 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。
　　     appenderName:就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。
   例如：log4j.rootLogger＝info,A1,B2,C3
　　
　　2、配置日志信息输出目的地，其语法为：
　　log4j.appender.appenderName = fully.qualified.name.of.appender.class //
　　 "fully.qualified.name.of.appender.class" 可以指定下面五个目的地中的一个：
          1.org.apache.log4j.ConsoleAppender（控制台）
          2.org.apache.log4j.FileAppender（文件）
          3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
          4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
          5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
             1.ConsoleAppender选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    Target=System.err：默认情况下是：System.out,指定输出控制台
              2.FileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
            3.DailyRollingFileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
                    DatePattern='.'yyyy-ww:每周滚动一次文件，即每周产生一个新的文件。当然也可以指定按月、周、天、时和分。即对应的格式如下：
                    1)'.'yyyy-MM: 每月
                    2)'.'yyyy-ww: 每周
                    3)'.'yyyy-MM-dd: 每天
                    4)'.'yyyy-MM-dd-a: 每天两次
                    5)'.'yyyy-MM-dd-HH: 每小时
                    6)'.'yyyy-MM-dd-HH-mm: 每分钟
            4.RollingFileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
                    MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。
                    MaxBackupIndex=2:指定可以产生的滚动文件的最大数。

实际应用：
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender //这里指定了日志输出的第一个位置A1是控制台ConsoleAppender
　　
　　3、配置日志信息的格式，其语法为：
　　A.log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
             "fully.qualified.name.of.layout.class" 可以指定下面4个格式中的一个：
               1.org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　       2.org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　       3.org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　       4.org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
                   1.HTMLLayout 选项
                      LocationInfo=true:默认值是false,输出java文件名称和行号
                      Title=my app file: 默认值是 Log4J Log Messages.
                   2.PatternLayout 选项
                      ConversionPattern=%m%n :指定怎样格式化指定的消息。
                   3.XMLLayout 选项
                      LocationInfo=true:默认值是false,输出java文件和行号
   实际应用：
   　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout

       B. log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
           这里需要说明的就是日志信息格式中几个符号所代表的含义：
　　         －X号: X信息输出时左对齐；
                   %p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
                   %d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
                   %r: 输出自应用启动到输出该log信息耗费的毫秒数
                   %c: 输出日志信息所属的类目，通常就是所在类的全名
                   %t: 输出产生该日志事件的线程名
                   %l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)
                   %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
                   %%: 输出一个"%"字符
                   %F: 输出日志消息产生时所在的文件名称
                   %L: 输出代码中的行号
                   %m: 输出代码中指定的消息,产生的日志具体信息
                   %n: 输出一个回车换行符，Windows平台为"\r\n"，Unix平台为"\n"输出日志信息换行
            可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
                     1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
                     2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
                     3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
                     4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边交远销出的字符截掉。

　　这里上面三个步骤是对前面Log4j组件说明的一个简化；下面给出一个具体配置例子，在程序中可以参照执行：
　　log4j.rootLogger=INFO,A1，B2
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
　　根据上面的日志格式，某一个程序的输出结果如下：
　　0　　INFO　2003-06-13 13:23:46968 ClientWithLog4j Client socket: Socket[addr=localhost/127.0.0.1,port=8002,localport=2014]
16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server says: 'Java server with log4j, Fri Jun 13 13:23:46 CST 2003'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j GOOD
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server responds: 'Command 'HELLO' not understood.'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j HELP
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server responds: 'Vocabulary: HELP QUIT'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j QUIT

4. # 当输出信息于回滚文件时

          log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender   //指定以文件的方式输出日志
           log4j.appender.ROLLING_FILE.Threshold=ERROR
           log4j.appender.ROLLING_FILE.File=rolling.log //文件位置,也可以用变量${java.home}、rolling.log
           log4j.appender.ROLLING_FILE.Append=true
           log4j.appender.ROLLING_FILE.MaxFileSize=10KB //文件最大尺寸
           log4j.appender.ROLLING_FILE.MaxBackupIndex=1 //备份数
           log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
           log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n 　　

××××××××××××××××××××××××××××××××××××××××××××××××

>>>> 6. Log4j比较全面的配置 <<<<

LOG4J的配置之简单使它遍及于越来越多的应用中了：Log4J配置文件实现了输出到控制台、文件、回滚文件、发送日志邮件、输出到数据库日志表、自定义标签等全套功能。择其一二使用就够用了，

log4j.rootLogger=DEBUG,CONSOLE,A1,im
log4j.addivity.org.apache=true

# 应用于控制台

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

#应用于文件

log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis

# 应用于文件回滚

log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log //文件位置,也可以用变量${java.home}、rolling.log
log4j.appender.ROLLING_FILE.Append=true //true:添加 false:覆盖
log4j.appender.ROLLING_FILE.MaxFileSize=10KB //文件最大尺寸
log4j.appender.ROLLING_FILE.MaxBackupIndex=1 //备份数
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件

log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=web@www.wuset.com
log4j.appender.MAIL.SMTPHost=www.wusetu.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=web@www.wusetu.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

#自定义Appender

log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net

log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] %r %c{4}:%L - %m%n

### direct messages to file hibernate.log ###
log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=log.html
log4j.appender.file.File=log.txt
log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout=org.apache.log4j.HTMLLayout
#log4j.appender.file.LocationInfo=true
#log4j.appender..file.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] %r %c{4}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info,stdout,file

crazy 2007-12-08 13:36 发表评论

数据统计,栈操作(2)

crazy — Wed, 26 Sep 2007 01:14:00 GMT

if (CountConstants.cArrayStackA == null )
                CountConstants.cArrayStackA = new CountViewArrayStack(CountConstants.CSTACKLENGH);
             if (CountConstants.cArrayStackB == null )
                CountConstants.cArrayStackB = new CountViewArrayStack(CountConstants.CSTACKLENGH);
AcceptEntity aEntity = new AcceptEntity();
CountManager cManager = new CountManager();
             if (CountConstants.CSTACKA)
                cManager.countViewNum(CountConstants.cArrayStackA,aEntity);
             else if (CountConstants.CSTACKB)
                cManager.countViewNum(CountConstants.cArrayStackB,aEntity);

public class CountManager {

     public void countViewNum(CountViewStack cArrayStack,AcceptEntity acceptEntity)
     {
         try
         {
            cArrayStack.push(acceptEntity);

             // System.out.println("Stack ["+type+"] working …… ");
        }
         catch (FullViewStackException e)
         {
             // System.out.println ("Stack [A] is Full!");
             int i = 0 ;
            Session session = null ;
            Object[] saveObj = new Object[CountConstants.CSTACKLENGH];
            AcceptEntity outEntity = null ;

             if (CountConstants.CSTACKA)
             {
                CountConstants.CSTACKA = false ;
                CountConstants.CSTACKB = true ;
            }
             else
             {
                CountConstants.CSTACKB = false ;
                CountConstants.CSTACKA = true ;
            }

             try
             {
                 while ( ! cArrayStack.isEmpty())
                 {
                    outEntity = (AcceptEntity)cArrayStack.pop();

                    saveObj[i] = outEntity;
                    i ++ ;
                    outEntity = null ;
                }
                session = MailSessionManager.getMailSession();
                EmailEntityManager.batchSave(saveObj,session);
                 if (session != null ) session.close();
                 // Hibernate.batchSave(saveObj);
                saveObj = null ;
                 // System.out.println("Stack [A] pop end!!pop[A]:"+iTempList.length);
                cArrayStack.push(acceptEntity);
            }
             catch (java.util.EmptyStackException ex)
             {
                System.out.println( " Error-->countViewNum() " + ex.getMessage());
            } finally {
                 if (session != null ) session.close();
            }

        } catch (Exception ex)
         {
            ex.printStackTrace();
        }
    }

}

crazy 2007-09-26 09:14 发表评论

数据统计,栈操作

crazy — Wed, 26 Sep 2007 01:04:00 GMT

1 // 栈四个方法分别是:
2      // --判断栈是否为空
3      // --获得栈顶数据项而没有删除
4      // --任意数据项入栈
5      // --获得并删除栈顶元素
6
7      public interface CountStack
8      {
9
10          boolean isEmpty ();
11
12         Object peek ();
13
14          void push (Object o);
15
16         Object pop ();
17     }
18
19 // 实现接口
20
21 public class CountViewArrayStack implements CountViewStack {
22
23          private int top = - 1 ;
24
25          private Object[] stack;
26
27          public CountViewArrayStack( int maxElements)
28
29          {
30             stack = new Object[maxElements];
31         }
32
33          public boolean isEmpty ()
34          {
35              return top == - 1 ;
36         }
37
38          public Object peek()
39
40          {
41              if (top < 0 )
42              throw new java.util.EmptyStackException();
43              return stack[top];
44         }
45
46          public void push(Object o)
47
48          {
49              if (top == stack.length - 1 )
50              throw new FullViewStackException();
51             stack[ ++ top] = o;
52         }
53
54          public Object pop()
55
56          {
57              if (top < 0 )
58              throw new java.util.EmptyStackException();
59              return stack[top -- ];
60         }
61
62 }

crazy 2007-09-26 09:04 发表评论

java 得到IP地址方法

crazy — Fri, 07 Sep 2007 03:15:00 GMT

1 public static String getIp(HttpServletRequest req) {
2         String ip_for = req.getHeader( " x-forwarded-for " );
3         String ip_client = req.getHeader( " http_client_ip " );
4         String un = " unknown " ;
5
6          if (ip_for != null && ! ip_for.equalsIgnoreCase(un)
7                  && ip_for.trim().length() > 0 ) {
8              return ip_for;
9         } else if (ip_client != null && ! ip_client.equalsIgnoreCase(un)
10                  && ip_client.trim().length() > 0 ) {
11              return ip_client;
12         } else {
13              return req.getRemoteAddr();
14         }
15     }

crazy 2007-09-07 11:15 发表评论

记取excel中的邮件地址并发送邮件

crazy — Mon, 03 Sep 2007 06:06:00 GMT

摘要: 1 /** */ /** 2 * @author wufalong 3 * Create on 2007-8-7 4 ... 阅读全文

crazy 2007-09-03 14:06 发表评论

java写入excel文件

crazy — Mon, 03 Sep 2007 05:56:00 GMT

要用到poi-2.5.1-final-20040804.jar包

1 import java.io.FileOutputStream;
2 import java.sql.Connection;
3 import java.sql.ResultSet;
4 import java.sql.ResultSetMetaData;
5
6 import org.apache.poi.hssf.usermodel.HSSFCell;
7 import org.apache.poi.hssf.usermodel.HSSFRow;
8 import org.apache.poi.hssf.usermodel.HSSFSheet;
9 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
10 import org.dom4j.Document;
11 import org.dom4j.Element;
12
13 import wufalong.exportServer.ConnectBean;
14 import wufalong.exportServer.CreateConnection;
15 import wufalong.exportServer.GetResultSet;
16 import wufalong.exportServer.LoadRootElementByConfigFile;
17 import exportxls.JsUserBasicData;
18
19 public class Person20070517
20 {
21    public static void main(String args[])
22    {
23       Person20070517 c = new Person20070517();
24        int allcount = 0 ;
25       allcount = allcount + c.createPersonMobile( " c:/人才.xls " );
26   }
27
28    public int createPersonMobile(String filename)
29    {
30       Connection con = null ;
31       ResultSet rs = null ;
32       Document doc = LoadRootElementByConfigFile.getRootElement();
33       Element e = doc.getRootElement().element( " import " );
34        try
35        {
36             con = CreateConnection.getConnect(e);
37             rs = GetResultSet.getResule(con,ConnectBean.getSql(e));
38           FileOutputStream fOut = null ;
39           HSSFWorkbook workbook = new HSSFWorkbook();
40           HSSFSheet sheet = workbook.createSheet();
41           HSSFRow row = null ;
42           HSSFCell cell = null ;
43            int i = 1 ;
44            int writeadd = 0 ;
45           String  cellvalue = "" ;
46           JsUserBasicData jub = new JsUserBasicData();
47           row = sheet.createRow( 0 );
48           cell = row.createCell(( short ) 0 );
49           cell.setCellType(HSSFCell.CELL_TYPE_STRING);
50           cell.setEncoding(HSSFCell.ENCODING_UTF_16);
51           cell.setCellValue( " 姓名 " );
52           cell = row.createCell(( short ) 1 );
53           cell.setCellType(HSSFCell.CELL_TYPE_STRING);
54           cell.setEncoding(HSSFCell.ENCODING_UTF_16);
55           cell.setCellValue( " 手机 " );
56
57            while (rs.next()) {
58
59               System.out.println( " 正在生成第 " + i + " 条记录 " );
60               ResultSetMetaData rsmd = rs.getMetaData();
61               row = sheet.createRow(( short ) i);
62                int colcount = rsmd.getColumnCount();
63                for ( int icc = 0 ; icc < colcount; icc ++ ) {
64                   cellvalue = rs.getString(icc + 1 );
65                   cell = row.createCell(( short ) icc);
66                   System.out.println( " md: " + cellvalue);
67                   cell.setCellType(HSSFCell.CELL_TYPE_STRING);
68                   cell.setEncoding(HSSFCell.ENCODING_UTF_16);
69                   cell.setCellValue(cellvalue);
70               }
71               i ++ ;
72           }
73
74           fOut = new FileOutputStream(filename);
75           workbook.write(fOut);
76           fOut.flush();
77           fOut.close();
78           System.out.println(filename + " 文件生成共 " + i + " 条 " );
79           rs.close();
80           rs = null ;
81           con.close();
82           con = null ;
83            return i;
84       } catch (Exception ee)
85        {
86               System.out.println( " 發生了 " + ee.getMessage() + " 例外 " );
87       }
88        finally
89        {
90               GetResultSet.closeResultSet(rs);
91               CreateConnection.closeConnect(con);
92       }
93       return 0 ;
94   }
95 }
96

crazy 2007-09-03 13:56 发表评论

java读取excel文件

crazy — Mon, 03 Sep 2007 03:23:00 GMT

1 import java.io.FileInputStream;
2 import java.io.InputStream;
3
4 import jxl.Cell;
5 import jxl.Sheet;
6 import jxl.Workbook;
7
8 /**
9 * @author wufalong
10 * 2007-9-3
11 */
12 public class Excel
13 {
14     public static void main(String[] args)
15     {
16         try
17         {
18             String sourcefile = "c://test.xls";
19             InputStream is = new FileInputStream(sourcefile);
20             jxl.Workbook rwb = Workbook.getWorkbook(is);
21             //获得总的Sheets，得到sheet的层数
22             Sheet[] sheets = rwb.getSheets();
23             int sheetLen = sheets.length;
24             //获得第一个Sheets 的结果
25             jxl.Sheet rs = rwb.getSheet(0);
26             int num = rs.getRows();//得到行数
27             for(int j=0;j < num ;j++)
28             {
29                 Cell[] cell = rs.getRow(j);//得到第一行的所有值
30                  String value = cell[0].getContents();//得到第一行，第一列的值
31                  System.out.println("Values:"+rs.getRow(j)[0].getContents());
32             }
33         }
34         catch(Exception ex)
35         {
36                 ex.printStackTrace();
37         }
38     }
39 }

crazy 2007-09-03 11:23 发表评论

java记取xml配置文件

crazy — Mon, 03 Sep 2007 02:59:00 GMT

需要用到commons-logging-1.0.4.jar，dom4j-1.4.jar包

1 import java.io.File;
2 import java.io.IOException;
3
4 import org.apache.commons.logging.Log;
5 import org.apache.commons.logging.LogFactory;
6 import org.dom4j.Document;
7 import org.dom4j.io.SAXReader;
8
9 /**
10 * @author wufalong
11 *
12 * TODO To change the template for this generated type comment go to
13 * Window - Preferences - Java - Code Style - Code Templates
14 */
15 public class LoadRootElementByConfigFile {
16     private static Log log = LogFactory.getLog(LoadRootElementByConfigFile.class);
17     public static Document getRootElement(){
18         String path="";
19         File file = new File(".");
20         try
21         {
22             path = file.getCanonicalPath();
23         }
24         catch (IOException e)
25         {
26             e.printStackTrace();
27         }
28
29         Document document = null;
30         String filePath = "";
31         try{
32             filePath = path+"/config.xml";
33             File f = new File(filePath);  //服务器运行目录
34             SAXReader reader = new SAXReader();
35             document = reader.read(f);
36         }catch(Exception e){
37             filePath = path+"/src/config.xml";
38             File f = new File(filePath); //eclipse调试目录
39             SAXReader reader = new SAXReader();
40             try{
41                 document = reader.read(f);
42             }catch(Exception ex){
43
44             }
45         }
46         log.info("配置文件路径:"+filePath);
47         return document;
48     }
49 }

crazy 2007-09-03 10:59 发表评论