第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以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

// 运行时期异常 

@Testpublic void testGeneric() throws Exception {// 集合的声明List list = new ArrayList();list.add("China");list.add(1);// 集合的使用String str = (String) list.get(1);}// 使用泛型@Testpublic 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){    // 报错： 与上面方法编译后一样}*/泛型写法:// 泛型写法@Testpublic 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;}// 测试方法@Testpublic 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) {}// 测试方法@Testpublic 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}@Testpublic 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) {}@Testpublic 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) {}@Testpublic 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.classclazz = (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 {// Fieldprivate int id = 1000;private String name = "匿名";// Constructorpublic Admin(){System.out.println("Admin.Admin()");}public Admin(String name){System.out.println("Admin.Admin()" + name);}// Methodpublic 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. 创建对象@Testpublic 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 {// 重写父类的方法@Overridepublic String toString() {return super.toString();}// 抑制编译器警告@SuppressWarnings(value = {"unused","unchecked"})private void save() {List list = null;}// 标记方法以及过时@Deprecatedprivate void save1() {}@Testpublic 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());}@Testpublic 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;}@Overridepublic 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;}// 封装结果集的方法@Overridepublic T handle(ResultSet rs) throws SQLException {try {// 创建要封装的对象  ‘1’T t = clazz.newInstance(); // 向下读一行if (rs.next()) {// a. 获取类的所有的Field字段数组Field[] fs = clazz.getDeclaredFields();// b. 遍历， 得到每一个字段类型：Fieldfor (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>@Overridepublic 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. 遍历， 得到每一个字段类型：Fieldfor (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 {@Testpublic 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.jar2. 配置 :  src/log4j.properties3. 使用# 通过根元素指定日志输出的级别、目的地： #  日志输出优先级： 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);@Testpublic void save() {try {log.info("保存： 开始进入保存方法");int i = 1/0;log.info("保存： 执行保存结束，成功");} catch (Exception e) {log.error("执行App类Save()方法出现异常！");  // 异常e.printStackTrace();}}/* * 思考： 日志的输出级别作用？ *  ----> 控制日志输出的内容。 */@Testpublic void testLog() throws Exception {// 输出不同级别的提示log.debug("调试信息");log.info("信息提示");log.warn("警告");log.error("异常");}}