1. 得到某个对象的属?br />
2 Class ownerClass = owner.getClass();
3
4 Field field = ownerClass.getField(fieldName);
5
6 Object property = field.get(owner);
7
8 return property;
9 }
Class ownerClass = owner.getClass()Q得到该对象的Class?br />
Field field = ownerClass.getField(fieldName)Q通过Class得到cd明的属性?br />
Object property = field.get(owner)Q通过对象得到该属性的实例Q如果这个属性是非公有的Q这里会报IllegalAccessException?br />
2. 得到某个cȝ静态属?br />
2 throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Field field = ownerClass.getField(fieldName);
6
7 Object property = field.get(ownerClass);
8
9 return property;
10 }
Class ownerClass = Class.forName(className) Q首先得到这个类的Class?br />
Field field = ownerClass.getField(fieldName)Q和上面一P通过Class得到cd明的属性?br />
Object property = field.get(ownerClass) Q这里和上面有些不同Q因属性是静态的Q所以直接从cȝClass里取?br />
3. 执行某对象的Ҏ
2
3 Class ownerClass = owner.getClass();
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() Q首先还是必d到这个对象的Class?br />
5?行：配置参数的Class数组Q作为寻找Method的条件?br />
Method method = ownerClass.getMethod(methodName, argsClass)Q通过Method名和参数的Class数组得到要执行的Method?br />
method.invoke(owner, args)Q执行该MethodQinvokeҎ的参数是执行q个Ҏ的对象，和参数数l。返回值是ObjectQ也既是该方法的q回倹{?br />
4. 执行某个cȝ静态方?br />
2 Object[] args) throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(null, args);
14 }
基本的原理和实例3相同Q不同点是最后一行，invoke的一个参数是nullQ因是静态方法，不需要借助实例q行?br />
5. 新徏实例
2 public Object newInstance(String className, Object[] args) throws Exception {
3 Class newoneClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Constructor cons = newoneClass.getConstructor(argsClass);
12
13 return cons.newInstance(args);
14
15 }
q里说的Ҏ是执行带参数的构造函数来新徏实例的方法。如果不需要参敎ͼ可以直接使用newoneClass.newInstance()来实现?br />
Class newoneClass = Class.forName(className)Q第一步，得到要构造的实例的Class?br />
W?～第9行：得到参数的Class数组?br />
Constructor cons = newoneClass.getConstructor(argsClass)Q得到构造子?br />
cons.newInstance(args)Q新建实例?br />
6. 判断是否为某个类的实?br />
2 return cls.isInstance(obj);
3 }
7. 得到数组中的某个元素
2 return Array.get(array,index);
3 }
附完整源码：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* Java Reflection Cookbook
*
* @author Michael Lee
* @since 2006-8-23
* @version 0.1a
*/
public class Reflection {
/**
* 得到某个对象的公共属?br /> *
* @param owner, fieldName
* @return 该属性对?br /> * @throws Exception
*
*/
public Object getProperty(Object owner, String fieldName) throws Exception {
Class ownerClass = owner.getClass();
Field field = ownerClass.getField(fieldName);
Object property = field.get(owner);
return property;
}
/**
* 得到某类的静态公共属?br /> *
* @param className cd
* @param fieldName 属性名
* @return 该属性对?br /> * @throws Exception
*/
public Object getStaticProperty(String className, String fieldName)
throws Exception {
Class ownerClass = Class.forName(className);
Field field = ownerClass.getField(fieldName);
Object property = field.get(ownerClass);
return property;
}
/**
* 执行某对象方?br /> *
* @param owner
* 对象
* @param methodName
* Ҏ?br /> * @param args
* 参数
* @return Ҏq回?br /> * @throws Exception
*/
public Object invokeMethod(Object owner, String methodName, Object[] args)
throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(owner, args);
}
/**
* 执行某类的静态方?br /> *
* @param className
* cd
* @param methodName
* Ҏ?br /> * @param args
* 参数数组
* @return 执行Ҏq回的结?br /> * @throws Exception
*/
public Object invokeStaticMethod(String className, String methodName,
Object[] args) throws Exception {
Class ownerClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(null, args);
}
/**
* 新徏实例
*
* @param className
* cd
* @param args
* 构造函数的参数
* @return 新徏的实?br /> * @throws Exception
*/
public Object newInstance(String className, Object[] args) throws Exception {
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}
/**
* 是不是某个类的实?br /> * @param obj 实例
* @param cls c?br /> * @return 如果 obj 是此cȝ实例Q则q回 true
*/
public boolean isInstance(Object obj, Class cls) {
return cls.isInstance(obj);
}
/**
* 得到数组中的某个元素
* @param array 数组
* @param index 索引
* @return q回指定数组对象中烦引组件的?br /> */
public Object getByArray(Object array, int index) {
return Array.get(array,index);
}
}
]]>
1. 一个简单的例子
考虑下面q个单的例子Q让我们看看 reflection 是如何工作的?br /> import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
} catch (Throwable e) {
System.err.println(e);
}
}
}
按如下语句执行：
java DumpMethods java.util.Stack
它的l果输出为：
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)
q样列Zjava.util.Stack cȝ各方法名以及它们的限制符和返回类型?/p>
q个E序使用 Class.forName 载入指定的类Q然后调?getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描q某个类中单个方法的一个类?/p>
2.开始?Reflection
?
?reflection 的类Q如 MethodQ可以在 java.lang.relfect
包中扑ֈ。用这些类的时候必要遵@三个步骤Q第一步是获得你想操作的类?java.lang.Class 对象。在q行中的 Java
E序中，?java.lang.Class cL描述cd接口{?/p>
下面是获得一?Class 对象的方法之一Q?br />
Class c = Class.forName("java.lang.String");
q条语句得到一?String cȝcd象。还有另一U方法，如下面的语句Q?br />
Class c = int.class; 或?nbsp; Class c = Integer.TYPE;
它们可获得基本类型的cM息。其中后一U方法中讉K的是基本cd的封装类 (?Integer) 中预先定义好?TYPE 字段?br />
W二步是调用诸如 getDeclaredMethods 的方法，以取得该cM定义的所有方法的列表?br />
一旦取得这个信息，可以进行第三步了——?reflection API 来操作这些信息，如下面这D代码：
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的W一个方法的原型?br />
在下面的例子中，q三个步骤将Z?reflection 处理Ҏ应用E序提供例证?/p>
模拟 instanceof 操作W?br />
得到cM息之后，通常下一个步骤就是解军_?Class 对象的一些基本的问题。例如，Class.isInstance Ҏ可以用于模拟 instanceof 操作W：
class A {
}
public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("A");
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new A());
System.out.println(b2);
} catch (Throwable e) {
System.err.println(e);
}
}
}
在这个例子中创徏了一?A cȝ Class 对象Q然后检查一些对象是否是 A 的实例。Integer(37) 不是Q但 new A() 是?/p>
3.扑ևcȝҎ
扑և一个类中定义了些什么方法，q是一个非常有价g非常基础?reflection 用法。下面的代码实Cq一用法Q?br />
import java.lang.reflect.*;
public class method1 {
private int f1(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method1");
Method methlist[] = cls.getDeclaredMethods();
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println("name = " + m.getName());
System.out.println("decl class = " + m.getDeclaringClass());
Class pvec[] = m.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = m.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("return type = " + m.getReturnType());
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q?
个程序首先取?method1 cȝ描述Q然后调?getDeclaredMethods 来获取一pd?Method
对象Q它们分别描qC定义在类中的每一个方法，包括 public Ҏ、protected Ҏ、package Ҏ?private
Ҏ{。如果你在程序中使用 getMethods 来代?getDeclaredMethodsQ你q能获得l承来的各个Ҏ的信息?br />
取得?Method 对象列表之后Q要昄q些Ҏ的参数类型、异常类型和q回值类型等׃难了。这些类型是基本cdq是cȝ型，都可以由描述cȝ对象按顺序给出?br />
输出的结果如下：
name = f1
decl class = class method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name = main
decl class = class method1
param #0 class [Ljava.lang.String;
return type = void
-----
4.获取构造器信息
获取cL造器的用法与上述获取Ҏ的用法类|如：
import java.lang.reflect.*;
public class constructor1 {
public constructor1() {
}
protected constructor1(int i, double d) {
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor1");
Constructor ctorlist[] = cls.getDeclaredConstructors();
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println("name = " + ct.getName());
System.out.println("decl class = " + ct.getDeclaringClass());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个例子中没能获得返回类型的相关信息Q那是因为构造器没有q回cd?br />
q个E序q行的结果是Q?br />
name = constructor1
decl class = class constructor1
-----
name = constructor1
decl class = class constructor1
param #0 int
param #1 double
-----
5.获取cȝ字段(?
扑և一个类中定义了哪些数据字段也是可能的，下面的代码就在干q个事情Q?br />
import java.lang.reflect.*;
public class field1 {
private double d;
public static final int i = 37;
String s = "testing";
public static void main(String args[]) {
try {
Class cls = Class.forName("field1");
Field fieldlist[] = cls.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println("name = " + fld.getName());
System.out.println("decl class = " + fld.getDeclaringClass());
System.out.println("type = " + fld.getType());
int mod = fld.getModifiers();
System.out.println("modifiers = " + Modifier.toString(mod));
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
q?
个例子和前面那个例子非常怼。例中用了一个新东西 ModifierQ它也是一?reflection
c，用来描述字段成员的修饰语Q如“private int”。这些修饰语自n由整数描qͼ而且使用 Modifier.toString
来返回以“官方”序排列的字W串描述 (?#8220;static”?#8220;final”之前)。这个程序的输出是：
name = d
decl class = class field1
type = double
modifiers = private
-----
name = i
decl class = class field1
type = int
modifiers = public static final
-----
name = s
decl class = class field1
type = class java.lang.String
modifiers =
-----
和获取方法的情况一下，获取字段的时候也可以只取得在当前cMx了的字段信息 (getDeclaredFields)Q或者也可以取得父类中定义的字段 (getFields) ?/p>
6.ҎҎ的名U来执行Ҏ
文本到这里，所丄例子无一例外都与如何获取cȝ信息有关。我们也可以?reflection 来做一些其它的事情Q比如执行一个指定了名称的方法。下面的CZ演示了这一操作Q?br />
import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod("add", partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = meth.invoke(methobj, arglist);
Integer retval = (Integer) retobj;
System.out.println(retval.intValue());
} catch (Throwable e) {
System.err.println(e);
}
}
}
假如一个程序在执行的某处的时候才知道需要执行某个方法，q个Ҏ的名U是在程序的q行q程中指定的 (例如QJavaBean 开发环境中׃做这L?Q那么上面的E序演示了如何做到?/p>
?
例中QgetMethod 用于查找一个具有两个整型参C名ؓ add 的方法。找到该Ҏq创Z相应?Method
对象之后Q在正确的对象实例中执行它。执行该Ҏ的时候，需要提供一个参数列表，q在上例中是分别包装了整?37 ?47 的两?Integer
对象。执行方法的q回的同h一?Integer 对象Q它装了返回?84?/p>
7.创徏新的对象
对于构造器Q则不能像执行方法那栯行，因ؓ执行一个构造器意味着创徏了一个新的对?(准确的说Q创Z个对象的q程包括分配内存和构造对?。所以，与上例最怼的例子如下：
import java.lang.reflect.*;
public class constructor2 {
public constructor2() {
}
public constructor2(int a, int b) {
System.out.println("a = " + a + " b = " + b);
}
public static void main(String args[]) {
try {
Class cls = Class.forName("constructor2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Constructor ct = cls.getConstructor(partypes);
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = ct.newInstance(arglist);
} catch (Throwable e) {
System.err.println(e);
}
}
}
Ҏ指定的参数类型找到相应的构造函数ƈ执行它，以创Z个新的对象实例。用这U方法可以在E序q行时动态地创徏对象Q而不是在~译的时候创建对象，q一炚w常有价倹{?/p>
8.改变字段(?的?br />
reflection 的还有一个用处就是改变对象数据字D늚倹{reflection 可以从正在运行的E序中根据名U找到对象的字段q改变它Q下面的例子可以说明q一点：
import java.lang.reflect.*;
public class field2 {
public double d;
public static void main(String args[]) {
try {
Class cls = Class.forName("field2");
Field fld = cls.getField("d");
field2 f2obj = new field2();
System.out.println("d = " + f2obj.d);
fld.setDouble(f2obj, 12.34);
System.out.println("d = " + f2obj.d);
} catch (Throwable e) {
System.err.println(e);
}
}
}
q个例子中，字段 d 的D变ؓ?12.34?br />
9.使用数组
本文介绍?reflection 的最后一U用法是创徏的操作数l。数l在 Java 语言中是一U特D的cȝ型，一个数l的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：
import java.lang.reflect.*;
public class array1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("java.lang.String");
Object arr = Array.newInstance(cls, 10);
Array.set(arr, 5, "this is a test");
String s = (String) Array.get(arr, 5);
System.out.println(s);
} catch (Throwable e) {
System.err.println(e);
}
}
}
例中创徏?10 个单位长度的 String 数组QؓW?5 个位|的字符串赋了|最后将q个字符串从数组中取得ƈ打印了出来?br />
下面q段代码提供了一个更复杂的例子：
import java.lang.reflect.*;
public class array2 {
public static void main(String args[]) {
int dims[] = new int[]{5, 10, 15};
Object arr = Array.newInstance(Integer.TYPE, dims);
Object arrobj = Array.get(arr, 3);
Class cls = arrobj.getClass().getComponentType();
System.out.println(cls);
arrobj = Array.get(arrobj, 5);
Array.setInt(arrobj, 10, 37);
int arrcast[][][] = (int[][][]) arr;
System.out.println(arrcast[3][5][10]);
}
}
?
中创Z一?5 x 10 x 15 的整型数l，qؓ处于 [3][5][10] 的元素赋了gؓ
37。注意，多维数组实际上就是数l的数组Q例如，W一?Array.get 之后Qarrobj 是一?10 x 15
的数l。进而取得其中的一个元素，即长度ؓ 15 的数l，q?Array.setInt 为它的第 10 个元素赋倹{?br />
注意创徏数组时的cd是动态的Q在~译时ƈ不知道其cd?/p>
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
public class ProcessFileObject {
protected String filename = "";
protected ProcessFileObject(String filename) {
this.filename = filename;
}
public ObjectOutputStream oos = null;
public ObjectInputStream ios = null;
public synchronized boolean insertAssignInfo(String assignid,
String assigncode, String assignname) {
ArrayList alist = new ArrayList();
Assign assign = new Assign();
assign.setAssigncode(assigncode);
assign.setAssignid(assignid);
assign.setAssignname(assignname);
/*try {
System.out.println(filename);
ios = new ObjectInputStream(new FileInputStream(new File(filename)));
alist = (ArrayList) ios.readObject();
ios.close();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (ClassNotFoundException cnfe) {
}*/
if (!alist.add(assign)) {
return false;
}
try {
oos = new ObjectOutputStream(new FileOutputStream(new File(filename)));
oos.writeObject(alist);
oos.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
return true;
}
public synchronized boolean existAssignInfo(String assignid,
String assigncode, String assignname) {
ArrayList alist = null;
Assign assign = null;
try {
ios = new ObjectInputStream(new FileInputStream(filename));
alist = (ArrayList) ios.readObject();
ios.close();
} catch (IOException ioe) {
} catch (ClassNotFoundException cnfe) {
}
Iterator iter = alist.iterator();
while (iter.hasNext()) {
assign = (Assign) iter.next();
if (assign.getAssigncode().equals(assigncode)
&& assign.getAssignid().equals(assignid)
&& assign.getAssignname().equals(assignname)) {
return true;
}
}
return false;
}
public synchronized boolean removebyAssigncode(String assigncode) {
ArrayList alist = null;
Assign assign = null;
try {
ios = new ObjectInputStream(new FileInputStream(filename));
alist = (ArrayList) ios.readObject();
ios.close();
} catch (IOException ioe) {
} catch (ClassNotFoundException cnfe) {
}
for (int i = 0, j = alist.size(); i < j; i++) {
assign = (Assign) alist.get(i);
if (assign.getAssigncode().equals(assigncode)) {
alist.remove(i);
}
}
try {
oos = new ObjectOutputStream(new FileOutputStream(filename));
oos.writeObject(alist);
oos.close();
} catch (IOException ioe) {
}
return true;
}
public synchronized boolean removeAll() {
ArrayList alist = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(filename));
oos.writeObject(alist);
oos.close();
} catch (IOException ioe) {
}
return true;
}
public class Assign implements Serializable {
public String assignid;
public String assigncode;
public String assignname;
public Assign() {
}
public String getAssigncode() {
return assigncode;
}
public void setAssigncode(String assigncode) {
this.assigncode = assigncode;
}
public String getAssignid() {
return assignid;
}
public void setAssignid(String assignid) {
this.assignid = assignid;
}
public String getAssignname() {
return assignname;
}
public void setAssignname(String assignname) {
this.assignname = assignname;
}
}
}
]]>
<!--[if !supportLists]-->一?/span><!--[endif]-->Log4j的简单思想
Log4j 真的很简单，单到令h发指的地步。不是要记录日志吗？那就l你一?/span> Log Q然后你?/span> Log 来写东西p了，先来一个完整类CZQ?/span>
package
test;
import
org.apache.commons.logging.Log;
import
org.apache.commons.logging.LogFactory;
public
class
Test {
static
Log
log
= LogFactory.getLog(Test.
class
);
//protected final Log log = LogFactory.getLog(this.getClass());
public
void
log(){
log
.debug(
"Debug info."
);
log
.info(
"Info info"
);
log
.warn(
"Warn info"
);
log
.error(
"Error info"
);
log
.fatal(
"Fatal info"
);
}
/**
*
@param
args
*/
public
static
void
main(String[] args) {
Test test =
new
Test();
test.log();
}
}
别怕，看完q篇文章你就会觉得很单了?/span>
Log4j 默认把日志信息分Z个等U?/span>
debug < info < warn < error < fatal
虽然可以自己d{Q但是我觉得没有必要Q五个够用了吧！你要写入信息的时候就把信息归Z个等U中的一个，然后调用相应的函数即可?/span>
分五个等U到底有什么用呢？日志信息到底写到哪里MQ?/span>
?/span> LogFactory.getLog(Test. class ) ”又是什么意思捏Q接着往下看吧！
Log4j 的关键之处在于它的承思想。也是一?/span> Log 可以l承另外一?/span> Log 的属性（输出到哪里，日志{Q日志格式等{）。怎么l承Q?/span>
Log4j 是根?/span> Log 的名字来判断l承关系的，比如Q?/span>
名字为?/span> com.zhlmmc.lib ”的 Log 是?/span> com.zhlmmc.lib.log ”的 parent Q明白了吧！ Log4j q有一?/span> rootLogger Q相当于 Java ?/span> Object ?/span>
回过头来看?/span> LogFactory.getLog(Test. class ) ”这里的?/span> Test. class ”事实上传进ȝ?/span> Test q个cȝ完整路径Q包?/span> + cdQ，?/span> test.Test ”。这样如果存在?/span> test ”这?/span> Log 那么 Test q个 Log q承它Q否则就l承 rootLogger ?/span>
那具体的 Log 属性是在哪里定义的呢？
<!--[if !supportLists]-->二?/span><!--[endif]-->常见的配|文?/span>
虽然可以?/span> xml 或者在q行时用 Java 来配|?/span> Log4j Q但q是 properties 文g好用啊！
log4j.rootLogger=
info,
stdout
log4j.appender.stdout=
org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=
org.apache.log4j.PatternLayout
# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=
%5p
[%t]
(%F
:
%L)
-
%m%n
分析一下：
W一行，配置 log4j.rootLogger 你明白吧。应为它是根Qd配置一下，否则别的 Log l承什么啊。其他的 Log 可以配置也可以不配置。等号后面的W一个参数表C日志别，可以填五个别中的一U，后面的参数都是让 Log 知道输出到哪里，如果你想让日志输出到两个地方加两个输出参数Q比如：
log4j.rootLogger= info, stdout, file
q里?/span> info 表示Q该 Log 的日志别ؓ info Q所有别小?/span> info 的日志都不会被记录。比如用这个配|文件的话，我刚开始D的那个类?/span>
log
.debug(
"Debug info."
);
q句话是不v作用的，因ؓ debug 的别小?/span> info 。这样就很容易控制什么信息在调试的时候要昄Q什么信息在发布的时候要L。这些都不用改代码，很方便吧?/span>
但， stdout ?/span> file 又是什么呢Q?/span>
接着往下看Q就是配|?/span> stdout 了，q个名字是随便取的，你可以叫?/span> A Q?/span>
log4j.appender.A= org.apache.log4j.ConsoleAppender
那么上面?/span> rootLogger 的参?/span> stdout 也要Ҏ A Q其他用到的地方当然也要攏V这里的关键不是名字Q而是 appender cdQ比如这里的?/span> ConsoleAppender ”，看明白了吧，输出?/span> Console 。后面两行都是设|日志格式的Q一般情况下你就照抄吧。既然是最入门x于理?/span> Log4j 的工作原理，我就不介l?/span> file cd?/span> appender 了，一搜一大把?/span>
在实际的目开发中Q很可能遇到所引用的包?/span> Log4j 来记录日志，比如 Hibernate 。那么在q里你可以很Ҏ的控制这个包如何记录日志。比如在上面的配|文件中加一行：
log4j.logger.org.hibernate= fatal
那么所?/span> org.hibernate 包下面的cd只会昄很少的信息，因ؓ fatal 的别最高啊?/span>
<!--[if !supportLists]-->三?/span><!--[endif]-->部v
别怕，q可不是部v Tomcat 。把 log4j 的包?/span> commons-logging 的包Q加在一h两个Q放?/span> classpath 下面。然后把配置文g保存?/span> log4j.properties Q也攑֜ classpath 下面Q如果用 Eclipse 的话Q放?/span> src 目录下即可）。然后你可以跑了?/span>
]]>
]]>