Java进阶学习第十四天（泛型、反射泛型、注解、Log4J日志组件）
一、泛型
1、概述
泛型是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 list = new ArrayList();
list.add("China");
// list.add(1);// 编译时期报错
String str = list.get(1);
}
2、泛型擦除
泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！
//泛型擦除实例
public void save(List p){
}
public void save(List d){ // 报错：与上面方法编译后一样
}
3、泛型写法
@Test
public void testGeneric3() throws Exception {
// 声明泛型集合，集合两端类型必须一致
List4、泛型方法、泛型类、泛型接口
作用：设计公用的类、方法，对公用的业务实现进行抽取, 使程序更灵活！
① 泛型方法
public class GenericDemo {
// 定义泛型方法
public T save(T t,K k) {
return null;
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 使用泛型方法:在使用泛型方法的时候，确定泛型类型
save(1.0f,1);
}
}
② 泛型类
public class GenericDemo {
// 定义泛型方法
public T save(T t,K k) {
return null;
}
public void update(T t) {
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 泛型类： 在创建爱泛型类对象的时候，确定类型
GenericDemo demo = new GenericDemo();
demo.save("test", 1);
}
}
③ 泛型接口
public interface IBaseDao {
void save(T t );
void update(T t );
}
泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定
public class BaseDaoImpl implements BaseDao {
}
泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class PersonDao implements BaseDao{
}
5、泛型关键字
① ? ：指定只是接收值
/**
* Ctrl + shift + R 查看当前项目中类
* Ctrl + shift + T 查看源码jar包中的类
* Ctrl + shift + L 查看方法返回值
*/
public class App_extends_super {
//只带泛型特征的方法
public void save(List list) {
// 只能获取、迭代list，不能编辑list
}
@Test
public void testGeneric() throws Exception {
// ? 可以接收任何泛型集合，但是不能编辑集合值，所以一般在方法参数中用
List list = new ArrayList();
//list.add("");// 报错
}
}
② extends【上限】 ：元素的类型必须继承自指定的类
public class App_extends_super {
/**
* list集合只能处理 Double/Float/Integer等类型
* 限定元素范围：元素的类型要继承自Number类(上限)
* @param list
*/
public void save(List list) {
}
@Test
public void testGeneric() throws Exception {
List list_1 = new ArrayList();
List list_2 = new ArrayList();
List list_3 = new ArrayList();
List list_4 = new ArrayList();
// 调用
save(list_1);
save(list_2);
save(list_3);
//save(list_4);
}
}
③ super【下限】：元素的类型必须是指定的类的父类
public class App_super {
/**
* super限定元素范围：必须是String父类（下限）
* @param list
*/
public void save(List list) {
}
@Test
public void testGeneric() throws Exception {
// 调用上面方法，必须传入String的父类
List二、、泛型的反射（反射泛型）
1、反射泛型涉及API
① Type：接口，任何类型默认的接口！包括： 引用类型、原始类型、参数化类型
② 参数化类型： ParameterizedType
List
即：ArrayList 为参数化类型
③ 反射泛型案例
public class AdminDao extends BaseDao {}
public class AccountDao extends BaseDao {}
/**
* 所有dao的公用的方法，都在这里实现
*/
public class BaseDao{
private Class clazz; // 保存当前运行类的参数化类型中的实际的类型
private String tableName; // 表名
// 构造函数： 通过获取当前运行类的参数化类型，来获取参数化类型中实际类型的定义(class)
public BaseDao(){
// this 表示当前运行类：(AccountDao/AdminDao)
// this.getClass() 当前运行类的字节码(AccountDao.class/AdminDao.class)
// this.getClass().getGenericSuperclass(); 当前运行类的父类，即为BaseDao
// 其实就是“参数化类型”：ParameterizedType
Type type = this.getClass().getGenericSuperclass();
// 强制转换为“参数化类型”：BaseDao
ParameterizedType pt = (ParameterizedType) type;
// 获取参数化类型中，实际类型的定义：new Type[]{Account.class}
Type types[] = pt.getActualTypeArguments();
// 获取数据的第一个元素：Accout.class
clazz = (Class) types[0];
// 表名：与类名一样，只要获取类名就可以
tableName = clazz.getSimpleName();
}
/**
* 主键查询
* @param id 主键值
* @return T 返回封装后的对象
*/
public T findById(int id){
/*
* 1. 知道封装的对象的类型
* 2. 表名【表名与对象名称一样，且主键都为id】
*
* 首先 ---》得到当前运行类继承的父类 BaseDao
* 然后 ---》得到Account.class
*/
String sql = "select * from " + tableName + " where id=? ";
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler(clazz), id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 查询全部
*/
public List getAll(){
String sql = "select * from " + tableName ;
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler(clazz));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
2、反射复习
① 反射：可以在运行时期动态创建对象以及获取对象的属性、方法
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);
}
}
三、注解
1、注解与注释
① 注解，告诉编译器如何运行程序！
② 注释， 给程序员阅读，对编译、运行没有影响；
2、注解作用
① 告诉编译器如何运行程序
② 简化(取代)配置文件
3、常用的注解：@Override、@SuppressWarnings、@Deprecated
// 重写父类的方法
@Override
public String toString() {
return super.toString();
}
// 抑制编译器警告
@SuppressWarnings({"unused","unchecked"})
private void save() {
List list = null;
}
// 标记方法以及过时
@Deprecated
private void save1() {
}
4、自定义注解
通过自定义注解，可以给类、字段、方法上添加描述信息！
① 注解基本写法
/**
* 自定义注解(描述一个作者)
*/
public @interface Author {
/**
* 注解属性
* 1. 修饰为默认或public
* 2. 不能有主体
*/
String name();
int age();
}
使用：
@Author(name = "Jet", age = 30)
public void save() {}
② 带默认值的注解
public @interface Author {
/**
* 注解属性
* 1. 修饰为默认或public
* 2. 不能有主体
*/
String name();
int age() default 30;// 带默认值的注解，使用的时候就可以不写此属性值
}
③ 默认名称的注解
注解属性名称为value，这就是默认名称
public @interface Author {
// 如果注解名称为value,使用时候可以省略名称，直接给值
// (且注解只有一个属性时候才可以省略名称)
String value();
}
使用：
@Author("Jet")
@Author(value = "Jet")
④ 注解属性类型为数组
public @interface Author {
String[] value() default {"test1","test2"};
}
使用：
@Author（{""，""}）
public void save() {}
⑤ 元注解：表示注解的注解
◆ 指定注解的可用范围：
@Target({
TYPE, 类
FIELD, 字段
METHOD, 方法
PARAMETER, 参数
CONSTRUCTOR, 构造器
LOCAL_VARIABLE 局部变量
})
◆ 指定注解的声明周期：
@Retention(RetentionPolicy.SOURCE) 注解只在源码级别有效
@Retention(RetentionPolicy.CLASS) 注解在字节码即别有效：默认值
@Retention(RetentionPolicy.RUNTIME) 注解在运行时期有效
◆ 注解反射
@Target({TYPE,FIELD , METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
//@Target({METHOD,FIELD,TYPE}) 指定只能在方法、字段、类上用；
@Retention(RetentionPolicy.RUNTIME) // 字节码级别有效
public @interface Author {
String authorName() default "Jet";
int age() default 30;
String remark();
}
public class Demo {
private String test;
@Id
@Author(remark = "保存信息！！！", age = 19)
public void save() throws Exception {
// 获取注解信息： name/age/remark
// 1. 先获取代表方法的Method类型;
Class clazz = Demo.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();
}
}
5、注解：优化BaseDao的代码
当表名与数据库名称不一致、 字段与属性不一样、主键不叫id， 上面的BaseDao不能用！一方面，可以通过配置文件(XML) 解决（便于维护，但是需要读取代码）！
@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
+ "]";
}
}
/**
* 解决优化的问题：
* 1. 当数据库表名与类名不一致、
* 2. 字段与属性不一样
* 3. 主键不叫id
*/
public class BaseDao {
// 当前运行类的类型
private Class clazz;
// 表名
private String tableName;
// 主键
private String id_primary;
// 拿到当前运行类的参数化类型中实际的类型：BaseDao，Admin.class
public BaseDao(){
Type type = this.getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;
Type[] types = pt.getActualTypeArguments();
clazz = (Class) 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(clazz), id);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public List getAll(){
try {
String sql = "select * from " + tableName;
return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler(clazz));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
/**
* 自定义结果集：封装单个Bean对象
*/
class BeanHandler implements ResultSetHandler{
// 保存传入的要封装的类的字节码
private Class clazz;
public BeanHandler(Class 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 implements ResultSetHandler>{
// 要封装的单个对象
private Class clazz;
public BeanListHandler(Class clazz){
this.clazz = clazz;
}
// 把从数据库查询到的每一行记录，封装为一个对象，再提交到list集合，返回List
@Override
public List handle(ResultSet rs) throws SQLException {
List list = new ArrayList();
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);
}
}
}
注解：简化XML配置， 程序处理非常方便，但是不便于维护： 例如修改字段名，要重新编译！
四、Log4J日志组件
1、程序中为什么用日志组件？
简单来说，为了项目后期部署上线后的维护、错误排查！
2、Log4j：log for java，开源的日志组件！
3、使用步骤
① 下载组件，引入jar文件：log4j-1.2.11.jar
② 配置： src/log4j.properties
③ 使用
public class Demo {
Log log = LogFactory.getLog(Demo.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("异常");
}
}
# 通过根元素指定日志输出的级别、目的地：
# 日志输出优先级： 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.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d %c.%M()-%m%n