• 一个自定义输出的例子

1，在扩展这个appender的时候，我有参照consoleAppender的实现。核心就是说实现append方法，当然我们直接继承自AppenderSkeleton类来进行的扩展，所以可以直接拿到里面的一些属性，比如layput，比如erroHandler等等

2，刚开始的写这个类的时候，我直接定义了一个limit属性，用来控制日志输出次数，直接是在代码中赋的初始值，为了方便，所以我就想写进配置文件中，但是怎么都注入不进去，控制台一直报下面这个error：

log4j:WARN Failed to set property [limit] to value "3". 

没办法，我只要打开log4j本身的日志，配置文件中设值log4j.debug=true就OK。后来终于发现我的set方法有问题，这个方法这里必须是void返回类型的，而我一般的set方法都是返回自身this，所以这里没有注入。关于log4j处理set注入我下面一节会整理到。

3，当然我们在扩展的时候直接继承ConsoleAppender自这个类也是可以的，这样子的话只需要重写append方法就够了，其他的都不需要了。我自己试了一下测试通过，代码类似，这里不做赘述了。

我们经常编码，但是其实写反射的代码并不是很多，一般的在IOC框架中都是读取配置文件或者说扫描注解来获取相关key-value，返回跑下set方法的反射，就可以设值到一个对象里面去了，这样子的话就可以把一些属性的设值放入到配置文件中，实现解耦。

在以前我们是这样子编码的：

// 取出需要设置Field值的目标对象

				Object target = getObject(objAndProp[0]);

				// 该Field对应的setter方法名:set + "属性的首字母大写" + 剩下部分

				String mtdName = "set" + objAndProp[1].substring(0 , 1).toUpperCase() + objAndProp[1].substring(1);

				// 通过target的getClass()获取它实现类所对应的Class对象

				Class<?> targetClass = target.getClass();

				// 获取该属性对应的setter方法，下面这一行道出了springIOC的精髓，为什么实现XML我们每次都要提供get和set方法，除了注解的哦

				Method mtd = targetClass.getMethod(mtdName , String.class);

				// 通过Method的invoke方法执行setter方法，将config.getProperty(name)的属性值作为调用setter的方法的实参

				mtd.invoke(target , config.getProperty(name));

看过了log4j的源码以后，我们多了一种选择，就是使用JDK自带的PropertyDescriptor类，这个类就是按照javabean规范写的一个存储器。

该类里面有2个方法可以直接获取我们的get和set方法：setReadMethod，getWriteMethod。以后这也是一种尝试，必要的时候可以参照log4j来用这个方式跑反射。OK，我这里贴出log4j中该类的源码：

package org.apache.log4j.config;

import org.apache.log4j.Appender;

import org.apache.log4j.Level;

import org.apache.log4j.Priority;

import org.apache.log4j.helpers.LogLog;

import org.apache.log4j.helpers.OptionConverter;

import org.apache.log4j.spi.OptionHandler;

import org.apache.log4j.spi.ErrorHandler;

import java.beans.BeanInfo;

import java.beans.IntrospectionException;

import java.beans.Introspector;

import java.beans.PropertyDescriptor;

import java.io.InterruptedIOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Enumeration;

import java.util.Properties;

/**

 * General purpose Object property setter. Clients repeatedly invokes

 * {@link #setProperty setProperty(name,value)} in order to invoke setters

 * on the Object specified in the constructor. This class relies on the

 * JavaBeans {@link Introspector} to analyze the given Object Class using

 * reflection.

 *

 * <p>

 * Usage:

 *

 * <pre>

 * PropertySetter ps = new PropertySetter(anObject);

 * ps.set("name", "Joe");

 * ps.set("age", "32");

 * ps.set("isMale", "true");

 * </pre>

 *

 * will cause the invocations anObject.setName("Joe"), anObject.setAge(32),

 * and setMale(true) if such methods exist with those signatures.

 * Otherwise an {@link IntrospectionException} are thrown.

 *

 * @author Anders Kristensen

 * @since 1.1

 */

public class PropertySetter

{

	protected Object obj;

	protected PropertyDescriptor[] props;

	/**

	 * Create a new PropertySetter for the specified Object. This is done

	 * in prepartion for invoking {@link #setProperty} one or more times.

	 *

	 * @param obj

	 *            the object for which to set properties

	 */

	public PropertySetter(Object obj)

	{

		this.obj = obj;

	}

	/**

	 * Uses JavaBeans {@link Introspector} to computer setters of object to be

	 * configured.

	 */

	protected void introspect()

	{

		try

		{

			BeanInfo bi = Introspector.getBeanInfo(obj.getClass());

			props = bi.getPropertyDescriptors();

		}

		catch (IntrospectionException ex)

		{

			LogLog.error("Failed to introspect " + obj + ": " + ex.getMessage());

			props = new PropertyDescriptor[0];

		}

	}

	/**

	 * Set the properties of an object passed as a parameter in one

	 * go. The <code>properties</code> are parsed relative to a

	 * <code>prefix</code>.

	 *

	 * @param obj

	 *            The object to configure.

	 * @param properties

	 *            A java.util.Properties containing keys and values.

	 * @param prefix

	 *            Only keys having the specified prefix will be set.

	 */

	public static void setProperties(Object obj, Properties properties, String prefix)

	{

		new PropertySetter(obj).setProperties(properties, prefix);

	}

	/**

	 * Set the properites for the object that match the

	 * <code>prefix</code> passed as parameter.

	 *

	 *

	 */

	public void setProperties(Properties properties, String prefix)

	{

		int len = prefix.length();

		for (Enumeration e = properties.propertyNames(); e.hasMoreElements();)

		{

			String key = (String) e.nextElement();

			// handle only properties that start with the desired frefix.

			if (key.startsWith(prefix))

			{

				// ignore key if it contains dots after the prefix

				if (key.indexOf('.', len + 1) > 0)

				{

					// System.err.println("----------Ignoring---["+key

					// +"], prefix=["+prefix+"].");

					continue;

				}

				String value = OptionConverter.findAndSubst(key, properties);

				key = key.substring(len);

				if (("layout".equals(key) || "errorhandler".equals(key)) && obj instanceof Appender)

				{

					continue;

				}

				//

				// if the property type is an OptionHandler

				// (for example, triggeringPolicy of org.apache.log4j.rolling.RollingFileAppender)

				PropertyDescriptor prop = getPropertyDescriptor(Introspector.decapitalize(key));

				if (prop != null && OptionHandler.class.isAssignableFrom(prop.getPropertyType()) && prop.getWriteMethod() != null)

				{

					OptionHandler opt = (OptionHandler) OptionConverter.instantiateByKey(properties, prefix + key, prop.getPropertyType(), null);

					PropertySetter setter = new PropertySetter(opt);

					setter.setProperties(properties, prefix + key + ".");

					try

					{

						Method writeMethod = prop.getWriteMethod();

						System.out.println("woqu=" + writeMethod);

						prop.getWriteMethod().invoke(this.obj, new Object[] { opt });

					}

					catch (IllegalAccessException ex)

					{

						LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex);

					}

					catch (InvocationTargetException ex)

					{

						if (ex.getTargetException() instanceof InterruptedException || ex.getTargetException() instanceof InterruptedIOException)

						{

							Thread.currentThread().interrupt();

						}

						LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex);

					}

					catch (RuntimeException ex)

					{

						LogLog.warn("Failed to set property [" + key + "] to value \"" + value + "\". ", ex);

					}

					continue;

				}

				setProperty(key, value);

			}

		}

		activate();

	}

	/**

	 * Set a property on this PropertySetter's Object. If successful, this

	 * method will invoke a setter method on the underlying Object. The

	 * setter is the one for the specified property name and the value is

	 * determined partly from the setter argument type and partly from the

	 * value specified in the call to this method.

	 *

	 * <p>

	 * If the setter expects a String no conversion is necessary.

	 * If it expects an int, then an attempt is made to convert 'value'

	 * to an int using new Integer(value). If the setter expects a boolean,

	 * the conversion is by new Boolean(value).

	 *

	 * @param name

	 *            name of the property

	 * @param value

	 *            String value of the property

	 */

	public void setProperty(String name, String value)

	{

		if (value == null)

		{

			return;

		}

		name = Introspector.decapitalize(name);

		PropertyDescriptor prop = getPropertyDescriptor(name);

		// LogLog.debug("---------Key: "+name+", type="+prop.getPropertyType());

		if (prop == null)

		{

			LogLog.warn("No such property [" + name + "] in " + obj.getClass().getName() + ".");

		}

		else

		{

			try

			{

				setProperty(prop, name, value);

			}

			catch (PropertySetterException ex)

			{

				LogLog.warn("Failed to set property [" + name + "] to value \"" + value + "\". ", ex.rootCause);

			}

		}

	}

	/**

	 * Set the named property given a {@link PropertyDescriptor}.

	 *

	 * @param prop

	 *            A PropertyDescriptor describing the characteristics

	 *            of the property to set.

	 * @param name

	 *            The named of the property to set.

	 * @param value

	 *            The value of the property.

	 */

	public void setProperty(PropertyDescriptor prop, String name, String value) throws PropertySetterException

	{

		Method setter = prop.getWriteMethod();

		if (setter == null)

		{

			throw new PropertySetterException("No setter for property [" + name + "].");

		}

		Class[] paramTypes = setter.getParameterTypes();

		if (paramTypes.length != 1)

		{

			throw new PropertySetterException("#params for setter != 1");

		}

		Object arg;

		try

		{

			arg = convertArg(value, paramTypes[0]);

		}

		catch (Throwable t)

		{

			throw new PropertySetterException("Conversion to type [" + paramTypes[0] + "] failed. Reason: " + t);

		}

		if (arg == null)

		{

			throw new PropertySetterException("Conversion to type [" + paramTypes[0] + "] failed.");

		}

		LogLog.debug("Setting property [" + name + "] to [" + arg + "].");

		try

		{

			setter.invoke(obj, new Object[] { arg });

		}

		catch (IllegalAccessException ex)

		{

			throw new PropertySetterException(ex);

		}

		catch (InvocationTargetException ex)

		{

			if (ex.getTargetException() instanceof InterruptedException || ex.getTargetException() instanceof InterruptedIOException)

			{

				Thread.currentThread().interrupt();

			}

			throw new PropertySetterException(ex);

		}

		catch (RuntimeException ex)

		{

			throw new PropertySetterException(ex);

		}

	}

	/**

	 * Convert <code>val</code> a String parameter to an object of a

	 * given type.

	 */

	protected Object convertArg(String val, Class type)

	{

		if (val == null)

		{

			return null;

		}

		String v = val.trim();

		if (String.class.isAssignableFrom(type))

		{

			return val;

		}

		else if (Integer.TYPE.isAssignableFrom(type))

		{

			return new Integer(v);

		}

		else if (Long.TYPE.isAssignableFrom(type))

		{

			return new Long(v);

		}

		else if (Boolean.TYPE.isAssignableFrom(type))

		{

			if ("true".equalsIgnoreCase(v))

			{

				return Boolean.TRUE;

			}

			else if ("false".equalsIgnoreCase(v))

			{

				return Boolean.FALSE;

			}

		}

		else if (Priority.class.isAssignableFrom(type))

		{

			return OptionConverter.toLevel(v, Level.DEBUG);

		}

		else if (ErrorHandler.class.isAssignableFrom(type))

		{

			return OptionConverter.instantiateByClassName(v, ErrorHandler.class, null);

		}

		return null;

	}

	protected PropertyDescriptor getPropertyDescriptor(String name)

	{

		if (props == null)

		{

			introspect();

		}

		for (int i = 0; i < props.length; i++)

		{

			if (name.equals(props[i].getName()))

			{

				return props[i];

			}

		}

		return null;

	}

	public void activate()

	{

		if (obj instanceof OptionHandler)

		{

			((OptionHandler) obj).activateOptions();

		}

	}

}

Log4j源码还是写的不错的，特别是一些小巧的设计，比如hashtable的性能提升，比如layout引入了解释器模式等等，都是值得我们借鉴的，在扩展性方面也写的挺好。

如果有必要的我们可以自己重写一个appender来实现我们自己的特定功能，OK，先这样子吧。