第27天(就业班) 泛型、泛型的反射、注解

1. 课程回顾

学过的组件：

    Dom4J/Xpath、DBUtils、C3p0、BeanUtils、log4J…

    Struts /  SPRing   / Hibernate

目标：

    1.  泛型

    2.  注解

    3. log4J  日志  (项目中)

    4.  枚举

2. 泛型

泛型的作用

l JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。

l 注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

l 泛形的基本术语，以ArrayList<E>为例：<>念着typeof

•    ArrayList<E>中的E称为类型参数变量

•    ArrayList<Integer>中的Integer称为实际类型参数

•    整个称为ArrayList<E>泛型类型

•    整个BaseDao<Type>ParameterizedType/Type

掌握的知识：

    基本用法、泛型擦除、泛型类/泛型方法/泛型接口、泛型关键字、反射泛型(案例)！

a. 概述

  泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

// 运行时期异常 

@Test	public void testGeneric() throws Exception {		// 集合的声明		List list = new ArrayList();		list.add("China");		list.add(1);				// 集合的使用		String str = (String) list.get(1);			}	// 使用泛型	@Test	public void testGeneric2() throws Exception {		// 声明泛型集合的时候指定元素的类型		List<String> list = new ArrayList<String>();		list.add("China");//		list.add(1);// 编译时期报错				String str = list.get(1); 	}泛型擦除，	泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！/*	 * 泛型擦除实例 	 	public void save(List<Person> p){	}	public void save(List<Dept> d){    // 报错： 与上面方法编译后一样	}	*/泛型写法:// 泛型写法	@Test	public void testGeneric3() throws Exception {		// 声明泛型集合，集合两端类型必须一致		List<Object> list = new ArrayList<Object>();		List<String> list1 = new ArrayList<String>();		List list2 = new ArrayList<String>();		List<Integer> list3 = new ArrayList();				// 错误		//List<Object> list4 = new ArrayList<String>();		// 错误： 泛型类型必须是引用类型,不能为基本类型		List<int> list5 = new ArrayList<int>();	}b. 泛型方法/泛型类/泛型接口作用：	设计公用的类、方法，对公用的业务实现进行抽取！ 	使程序更灵活！1. 泛型方法:public class GenericDemo {	// 定义泛型方法	public <K,T> T save(T t,K k) {		return null;	}		// 测试方法	@Test	public void testMethod() throws Exception {		// 使用泛型方法:  在使用泛型方法的时候，确定泛型类型		save(1.0f, 1);	}}3. 泛型类：public class GenericDemo<T> {	// 定义泛型方法	public <K> T save(T t,K k) {		return null;	}		public void update(T t) {	}		// 测试方法	@Test	public void testMethod() throws Exception {				// 泛型类：  在创建爱泛型类对象的时候，确定类型		GenericDemo<String> demo = new GenericDemo<String>();		demo.save("test", 1);	}}4. 泛型接口：/** * 泛型接口 * @author Jie.Yuan * * @param <T> */public interface IBaseDao<T> {	void save(T t );	void update(T t );}泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定public class BaseDao<T> implements IBaseDao<T> {泛型接口类型确定： 在业务实现类中直接确定接口的类型public class PersonDao implements IBaseDao<Person>{c. 泛型关键字泛型中： ?   			指定只是接收值extends      元素的类型必须继承自指定的类super        元素的类型必须是指定的类的父类关键字 ：  ?/** * 泛型, 涉及到一些关键字 *  * Ctrl + shift + R   查看当前项目中类 * Ctrl + shift + T   查看源码jar包中的类 * @author Jie.Yuan * */public class App_extends_super {		//只带泛型特征的方法	public void save(List<?> list) {		// 只能获取、迭代list;  不能编辑list	}	@Test	public void testGeneric() throws Exception {				// ?  可以接收任何泛型集合， 但是不能编辑集合值； 所以一般在方法参数中用		List<?> list = new ArrayList<String>();		//list.add("");// 报错	}}关键字 ：  extends    【上限】public class App_extends_super {	/**	 * list集合只能处理 Double/Float/Integer等类型	 * 限定元素范围：元素的类型要继承自Number类  (上限)	 * @param list	 */	public void save(List<? extends Number> list) {	}	@Test	public void testGeneric() throws Exception {		List<Double> list_1 = new ArrayList<Double>();		List<Float> list_2 = new ArrayList<Float>();		List<Integer> list_3 = new ArrayList<Integer>();				List<String> list_4 = new ArrayList<String>();				// 调用		save(list_1);		save(list_2);		save(list_3);		//save(list_4);	}}关键字 ：  super     【下限】/** * 泛型, 涉及到一些关键字 *  * Ctrl + shift + R   查看当前项目中类 * Ctrl + shift + T   查看源码jar包中的类 * @author Jie.Yuan * */public class App_super {	/**	 * super限定元素范围：必须是String父类   【下限】	 * @param list	 */	public void save(List<? super String> list) {	}	@Test	public void testGeneric() throws Exception {		// 调用上面方法，必须传入String的父类		List<Object> list1 = new ArrayList<Object>();		List<String> list2 = new ArrayList<String>();				List<Integer> list3 = new ArrayList<Integer>();		//save(list3);	}}泛型的反射案例，设置通用方法，会用到反射泛型！步骤：	1. 案例分析 /  实现	2. 涉及知识点(jdk api)	3. 优化 / 反射泛型反射泛型涉及API：Student    类型的表示Id   nameParameterizedType   参数化类型的表示ArrayList<String>();Type    接口，任何类型默认的接口！        包括： 引用类型、原始类型、参数化类型List<String>  list   =  new   ArrayList<String>();泛型集合：    list集合元素定义：new   ArrayList<String>();  中的String参数化类型：  ParameterizedType 即：“ArrayList<String> ” 为参数化类型反射泛型案例public class AdminDao extends BaseDao<Admin> {}public class AccountDao extends BaseDao<Account> {}/** * 所有dao的公用的方法，都在这里实现 * @author Jie.Yuan * */public class BaseDao<T>{		// 保存当前运行类的参数化类型中的实际的类型	private Class clazz;	// 表名	private String tableName;				// 构造函数： 1. 获取当前运行类的参数化类型； 2. 获取参数化类型中实际类型的定义(class)	public BaseDao(){		//  this  表示当前运行类  (AccountDao/AdminDao)		//  this.getClass()  当前运行类的字节码(AccountDao.class/AdminDao.class)		//  this.getClass().getGenericSuperclass();  当前运行类的父类，即为BaseDao<Account>		//                                           其实就是“参数化类型”， ParameterizedType   		Type type = this.getClass().getGenericSuperclass();		// 强制转换为“参数化类型”  【BaseDao<Account>】		ParameterizedType pt = (ParameterizedType) type;		// 获取参数化类型中，实际类型的定义  【new Type[]{Account.class}】		Type types[] =  pt.getActualTypeArguments();		// 获取数据的第一个元素：Accout.class		clazz = (Class) types[0];		// 表名  (与类名一样，只要获取类名就可以)		tableName = clazz.getSimpleName();	}		/**	 * 主键查询	 * @param id	主键值	 * @return      返回封装后的对象	 */	public T findById(int id){		/*		 * 1. 知道封装的对象的类型		 * 2. 表名【表名与对象名称一样， 且主键都为id】		 * 		 * 即，		 * 	  ---》得到当前运行类继承的父类  BaseDao<Account>		 *   ----》 得到Account.class		 */				String sql = "select * from " + tableName + " where id=? ";		try {			return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler<T>(clazz), id);		} catch (SQLException e) {			throw new RuntimeException(e);		}	}			/**	 * 查询全部	 * @return	 */	public List<T> getAll(){		String sql = "select * from " + tableName ;		try {			return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler<T>(clazz));		} catch (SQLException e) {			throw new RuntimeException(e);		}	}}4. 反射复习反射，可以在运行时期动态创建对象；获取对象的属性、方法；public class Admin {	// Field	private int id = 1000;	private String name = "匿名";		// Constructor	public Admin(){		System.out.println("Admin.Admin()");	}	public Admin(String name){		System.out.println("Admin.Admin()" + name);	}		// Method	public int getId() {		return id;	}	public void setId(int id) {		this.id = id;	}	public String getName() {		return name;	}	public void setName(String name) {		this.name = name;	}	}// 反射技术public class App {	// 1. 创建对象	@Test	public void testInfo() throws Exception {		// 类全名		String className = "cn.itcast.c_reflect.Admin";		// 得到类字节码		Class<?> clazz = Class.forName(className);				// 创建对象1: 默认构造函数简写		//Admin admin = (Admin) clazz.newInstance();				// 创建对象2： 通过带参数构造器创建对象		Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);		Admin admin = (Admin) constructor.newInstance("Jack");			}	@Test	//2. 获取属性名称、值	public void testField() throws Exception {				// 类全名		String className = "cn.itcast.c_reflect.Admin";		// 得到类字节码		Class<?> clazz = Class.forName(className);		// 对象		Admin admin =  (Admin) clazz.newInstance();				// 获取所有的属性名称		Field[]  fs =  clazz.getDeclaredFields();		// 遍历：输出每一个属性名称、值		for (Field f : fs) {			// 设置强制访问			f.setaccessible(true);			// 名称			String name = f.getName();			// 值			Object value = f.get(admin);						System.out.println(name + value);		}	}		@Test	//3. 反射获取方法	public void testMethod() throws Exception {				// 类全名		String className = "cn.itcast.c_reflect.Admin";		// 得到类字节码		Class<?> clazz = Class.forName(className);		// 对象		Admin admin =  (Admin) clazz.newInstance();				// 获取方法对象    public int getId() {		Method m = clazz.getDeclaredMethod("getId");		// 调用方法		Object r_value = m.invoke(admin);				System.out.println(r_value);	}	}4.注解以及注解的反射注解的概述从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是 Annotation(注解)。什么是Annotation，以及注解的作用?三个基本的 Annotation:@Override: 限定重写父类方法, 该注解只能用于方法@Deprecated: 用于表示某个程序元素(类, 方法等)已过时@SuppressWarnings: 抑制编译器警告.Annotation 其实就是代码里的特殊标记, 它用于替代配置文件，也就是说，传统方式通过配置文件告诉类如何运行，有了注解技术后，开发人员可以通过注解告诉类如何运行。在Java技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。掌握注解技术的要点：如何自定义注解如何反射注解，并根据反射的注解信息，决定如何去运行类注解作用，	1. 告诉编译器如何运行程序；	2. 简化(取代)配置文件   【案例后再看】常用的注解，package com.xp.d_anno;import java.util.List;import org.junit.Test;/** * 常用的注解 */public class App_1 {	// 重写父类的方法	@Override	public String toString() {		return super.toString();	}	// 抑制编译器警告	@SuppressWarnings(value = {"unused","unchecked"})	private void save() {		List list = null;	}	// 标记方法以及过时	@Deprecated	private void save1() {	}	@Test	public void testMain() throws Exception {	}}自定义注解定义新的 Annotation 类型使用 @interface 关键字声明注解的属性注解属性的作用：原来写在配置文件中的信息，可以通过注解的属性进行描述。Annotation 的属性声明方式：String name()或String[] likes();属性默认值声明方式：String name() default “xxx”;特殊属性value：如果注解中有一个名称value的属性，那么使用注解时可以省略value=部分，如@MyAnnotation(“xxx")特殊属性value[];枚举值之间使用逗号分隔@MyAnnotation(name="jack",age=30,likes={"唱歌","跳舞"})Jdk的元注解	元 Annotation指修饰Annotation的Annotation。JDK中定义了如下元Annotation：	@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 可以保留的域, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 通过这个变量指定域。•	RetentionPolicy.CLASS: 编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 不会保留注解. 这是默认值•	RetentionPolicy.RUNTIME:编译器将把注释记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注释•	RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释	@Target：指定注解用于修饰类的哪个成员. @Target 包含了一个名为 value，类型为ElementType(JDK6)的成员变量。	@Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档。	@Inherited: 被它修饰的 Annotation 将具有继承性.如果某个类使用了被 @Inherited 修饰的 Annotation, 则其子类将自动具有该注解。提取注解信息	JDK 5.0 在 java.lang.reflect 包下新增了 AnnotationElement 接口, 该接口代表程序中可以接受注释的程序元素	当一个 Annotation 类型被定义为运行时 Annotation 后, 该注释才是运行时可见, 当 class 文件被载入时保存在 class 文件中的 Annotation 才会被虚拟机读取	程序可以调用 AnnotationElement 对象的如下方法来访问 Annotation 信息 package com.xp.d_anno;import static java.lang.annotation.ElementType.CONSTRUCTOR;import static java.lang.annotation.ElementType.FIELD;import static java.lang.annotation.ElementType.LOCAL_VARIABLE;import static java.lang.annotation.ElementType.METHOD;import static java.lang.annotation.ElementType.PARAMETER;import static java.lang.annotation.ElementType.TYPE;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;/** * 自定义注解  (描述一个作者) */// 元注解 - 1. 定义注解的可用范围@Target({TYPE,FIELD , METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})//@Target({METHOD,FIELD,TYPE})   指定只能在方法、字段、类上用；// 元注解 - 2. 指定注解的声明周期@Retention(RetentionPolicy.RUNTIME)   // 字节码级别有效public @interface Author {		String authorName() default "Jet";	int age() default 30;		String remark();}package com.xp.d_anno;public @interface Id {}package com.xp.d_anno;import java.lang.reflect.Method;import javax.persistence.Id;import org.junit.Test;/** * 测试：自定义注解的语法 */public class App_2 {	private String test;		@Id	@Author(remark = "保存信息！！！", age = 19)	public void save() throws Exception {		// 获取注解信息： name/age/remark		// 1. 先获取代表方法的Method类型;		Class clazz = App_2.class;		Method m = clazz.getMethod("save");				// 2. 再获取方法上的注解		Author author = m.getAnnotation(Author.class);		// 获取输出注解信息		System.out.println(author.authorName());		System.out.println(author.age());		System.out.println(author.remark());	}	@Test	public void testMain() throws Exception {		save();	}}元注解元注解，表示注解的注解！指定注解的可用范围：@Target({TYPE,     类FIELD,     字段METHOD,  方法PARAMETER,   参数CONSTRUCTOR, 构造器 LOCAL_VARIABLE  局部变量})// 元注解 - 2. 指定注解的声明周期@Retention(RetentionPolicy.SOURCE)    注解只在源码级别有效@Retention(RetentionPolicy.CLASS)      注解在字节码即别有效  默认值@Retention(RetentionPolicy.RUNTIME)   注解在运行时期有效5.注解案例优化当表名与数据库名称不一致、 字段与属性不一样、主键不叫id， 上面的BaseDao不能用！这是，	可以通过配置文件(xml) 解决！注解：	简化XML配置， 程序处理非常方便！	(不便于维护： 例如修改字段名，要重新编译！)XML	便于维护！  需要些读取代码！package com.xp.utils;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;import static java.lang.annotation.ElementType.FIELD;/** * 描述一个字段 */@Target({FIELD})@Retention(RetentionPolicy.RUNTIME)  // 指定注解在运行时期有效public @interface Column {	String columnName();}package com.xp.utils;import static java.lang.annotation.ElementType.FIELD;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;/** * 描述一个主键字段 * @author Jie.Yuan * */@Target({FIELD})@Retention(RetentionPolicy.RUNTIME)  // 指定注解在运行时期有效public @interface Id {}package com.xp.utils;import static java.lang.annotation.ElementType.TYPE;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;/** * 注解，描述表名称 * @author Jie.Yuan * */@Target({TYPE})@Retention(RetentionPolicy.RUNTIME)  // 指定注解在运行时期有效public @interface Table {	String tableName();}package com.xp.e_eg;import com.xp.utils.Column;import com.xp.utils.Id;import com.xp.utils.Table;//Admin=a_admin@Table(tableName="a_admin")public class Admin {	@Id	@Column(columnName = "a_id")	private int id;		@Column(columnName = "a_userName")	private String userName;		@Column(columnName = "a_pwd")	private String pwd;		public int getId() {		return id;	}	public void setId(int id) {		this.id = id;	}	public String getUserName() {		return userName;	}	public void setUserName(String userName) {		this.userName = userName;	}	public String getPwd() {		return pwd;	}	public void setPwd(String pwd) {		this.pwd = pwd;	}	@Override	public String toString() {		return "Admin [id=" + id + ", pwd=" + pwd + ", userName=" + userName				+ "]";	}}package com.xp.e_eg;import java.lang.reflect.Field;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import org.apache.commons.beanutils.BeanUtils;import org.apache.commons.dbutils.ResultSetHandler;import com.xp.b_reflect.JdbcUtils;import com.xp.utils.Column;import com.xp.utils.Id;import com.xp.utils.Table;/** * 解决优化的问题： * 	  1. 当数据库表名与类名不一致、  *    2. 字段与属性不一样、 *    3. 主键不叫id  *     */public class BaseDao<T> {		// 当前运行类的类型	private Class<T> clazz;	// 表名	private String tableName;	// 主键	private String id_primary;	// 拿到当前运行类的参数化类型中实际的类型  ( BaseDao<Admin> ,  Admin.class)	public BaseDao(){		Type type = this.getClass().getGenericSuperclass();		ParameterizedType pt = (ParameterizedType) type;		Type[] types = pt.getActualTypeArguments();		clazz = (Class<T>) types[0];				//已经拿到：  Admin.class				/*******1. 获取表名*******/		Table table = clazz.getAnnotation(Table.class);		tableName = table.tableName();				/*******2. 获取主键字段*******/		//获取当前运行类的所有字段、遍历、获取每一个字段上的id注解		Field[] fs = clazz.getDeclaredFields();		for (Field f : fs) {						// 设置强制访问			f.setAccessible(true);						// 获取每一个字段上的id注解			Id anno_id = f.getAnnotation(Id.class);						// 判断			if (anno_id != null) {				// 如果字段上有id注解，当前字段(field)是主键； 再获取字段名称				Column column = f.getAnnotation(Column.class);				// 主键				id_primary = column.columnName();				// 跳出循环				break;			}		}				System.out.println("表：" + tableName);		System.out.println("主键：" + id_primary);	}			public T findById(int id){		try {			String sql = "select * from " + tableName + " where " + id_primary +"=?";			/*			 * DbUtils的已经封装好的工具类：BeanHandler?   属性=字段			 */			return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler<T>(clazz), id);		} catch (Exception e) {			throw new RuntimeException(e);		}	}			public List<T> getAll(){		try {			String sql = "select * from " + tableName;			return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler<T>(clazz));		} catch (Exception e) {			throw new RuntimeException(e);		}	}	}/** * 自定义结果集：封装单个Bean对象 */class BeanHandler<T> implements ResultSetHandler<T>{	// 保存传入的要封装的类的字节码	private Class<T> clazz;	public BeanHandler(Class<T> clazz) {		this.clazz = clazz;	}		// 封装结果集的方法	@Override	public T handle(ResultSet rs) throws SQLException {		try {			// 创建要封装的对象  ‘1’			T t = clazz.newInstance(); 			// 向下读一行			if (rs.next()) {								// a. 获取类的所有的Field字段数组				Field[] fs = clazz.getDeclaredFields();								// b. 遍历， 得到每一个字段类型：Field				for (Field f : fs) {									// c. 获取”属性名称“					String fieldName = f.getName();										// e. 获取Field字段上注解   【@Column(columnName = "a_userName")】					Column column =  f.getAnnotation(Column.class);										// f. ”字段名“					String columnName = column.columnName();        // 数据库中字段 a_userName										// g. 字段值					Object columnValue = rs.getObject(columnName);										// 设置（BeanUtils组件）					BeanUtils.copyProperty(t, fieldName, columnValue);				}			}			return t;		} catch (Exception e) {			throw new RuntimeException(e);		}	}}/** * 自定义结果集：封装多个Bean对象到List集合 */class BeanListHandler<T> implements ResultSetHandler<List<T>>{		// 要封装的单个对象	private Class<T> clazz;	public BeanListHandler(Class<T> clazz){		this.clazz = clazz;	}	// 把从数据库查询到的没一行记录，封装为一个对象，再提交到list集合， 返回List<T>	@Override	public List<T> handle(ResultSet rs) throws SQLException {		List<T> list = new ArrayList<T>();		try {			// 向下读一行			while (rs.next()) {								// 创建要封装的对象  ‘1’				T t = clazz.newInstance(); 								// a. 获取类的所有的Field字段数组				Field[] fs = clazz.getDeclaredFields();								// b. 遍历， 得到每一个字段类型：Field				for (Field f : fs) {									// c. 获取”属性名称“					String fieldName = f.getName();										// e. 获取Field字段上注解   【@Column(columnName = "a_userName")】					Column column =  f.getAnnotation(Column.class);										// f. ”字段名“					String columnName = column.columnName();        // 数据库中字段 a_userName										// g. 字段值					Object columnValue = rs.getObject(columnName);										// 设置（BeanUtils组件）					BeanUtils.copyProperty(t, fieldName, columnValue);				}				// 对象添加到集合				list.add(t);			}			return list;		} catch (Exception e) {			throw new RuntimeException(e);		}	}}package com.xp.e_eg;public class AdminDao extends BaseDao<Admin> {}package com.xp.e_eg;import org.junit.Test;public class App {	@Test	public void testDao() throws Exception {		AdminDao adminDao = new AdminDao();//		Admin admin = adminDao.findById(8);//		System.out.println(admin);		System.out.println(adminDao.findById(8));		System.out.println(adminDao.getAll());	}}Log4j日志组件程序中为什么用日志组件？	简单来说，为了项目后期部署上线后的维护、错误排查！Log4j,  log for java, 开源的日志组件！使用步骤：	1. 下载组件，引入jar文件;		log4j-1.2.11.jar	2. 配置 :  src/log4j.properties	3. 使用# 通过根元素指定日志输出的级别、目的地： #  日志输出优先级： debug < info < warn < error log4j.rootLogger=info,console,file############# 日志输出到控制台 ############## 日志输出到控制台使用的api类log4j.appender.console=org.apache.log4j.ConsoleAppender# 指定日志输出的格式： 灵活的格式log4j.appender.console.layout=org.apache.log4j.PatternLayout# 具体格式内容log4j.appender.console.layout.ConversionPattern=%d %p %c.%M()-%m%n############# 日志输出到文件 #############log4j.appender.file=org.apache.log4j.RollingFileAppender# 文件参数： 指定日志文件路径log4j.appender.file.File=../logs/MyLog.log# 文件参数： 指定日志文件最大大小log4j.appender.file.MaxFileSize=5kb# 文件参数： 指定产生日志文件的最大数目log4j.appender.file.MaxBackupIndex=100# 日志格式log4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=%d %c.%M()-%m%npackage com.xp.f_log4j;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.junit.Test;public class App {		Log log = LogFactory.getLog(App.class);		@Test	public void save() {		try {			log.info("保存： 开始进入保存方法");			int i = 1/0;						log.info("保存： 执行保存结束，成功");		} catch (Exception e) {						log.error("执行App类Save()方法出现异常！");  // 异常						e.printStackTrace();		}	}		/*	 * 思考： 日志的输出级别作用？	 * 	 ----> 控制日志输出的内容。	 */	@Test	public void testLog() throws Exception {		// 输出不同级别的提示		log.debug("调试信息");		log.info("信息提示");		log.warn("警告");		log.error("异常");			}}