进阶篇-Day17：JAVA的日志、枚举、类加载器、反射等介绍】

目录

• 1、日志
• • 1.1 日志概念
  • 1.2 日志框架
  • • （1） Logback框架：
    • （2）配置文件介绍：
• 2、枚举
• 3、类加载器
• • 3.1 类加载器的介绍
  • 3.2 类加载器的加载过程：加载、链接、初始化
  • 3.3 类加载器的分类
  • 3.4 双亲委派模式
  • 3.4 ClassLoaser的常用成员方法
• 4、反射
• • 4.1 反射概念
  • 4.2 反射的使用
  • • 4.2.1 获取类的字节码对象：
    • 4.2.2 反射类中的构造方法
    • 4.2.3 反射类中的成员变量
    • 4.2.4 反射类中的成员方法
    • 4.2.5 案例：
    • • （1）
      • （2）

1、日志

1.1 日志概念

前面我们其实已经在记录日志，如下所示，通过将信息打印到控制台来查看程序运行到哪里了。

接下来学习日志框架来记录日志。

1.2 日志框架

（1） Logback框架：

1、引入三个jar包：


这里有教程下载：https://www.cnblogs.com/yumengqifei/p/16407919.html

2、导入配置文件

3、获取日志对象使用：

package com.itheima.log;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;public class LogTest {public static void main(String[] args) {//获取日志对象Logger logger = LoggerFactory.getLogger("LogTest.class");logger.info("记录了一条日志");}
}

运行结果：

（2）配置文件介绍：

下面是logback.xml的样例（可复制后自己改），以及说明：

<?xml version="1.0" encoding="UTF-8" ?>
<configuration><!-- 控制台应用器:表示当前的日志信息是可以输出到控制台的 --><appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"><!-- 输出流对象，默认System.out，也可使用System.err --><!-- 输出流对象，默认System.out，也可使用System.err --><target>System.err</target><!-- 格式化输出：%d:表示日期%thread:表示线程名%-5level:表示级别从左显示5个字符宽度%c:表示获取日志时传入的字符串%msg:表示日志消息%n:是换行符--><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %c [%thread]: %msg%n</pattern></encoder></appender><!-- 文件应用器:输出的方向通向文件 --><appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"><!-- 日志输出路径 --><file>logs/myapp.log</file><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern><charset>utf-8</charset></encoder><!-- 指定日志文件拆分和压缩规则 --><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!-- 通过指定压缩文件名称，来确定分割文件方式 --><fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.%i.log</fileNamePattern><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><!-- 文件拆分大小 --><maxFileSize>100MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy></rollingPolicy></appender><!--日志级别:level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL, OFF。默认debug<root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。--><root level="all"><appender-ref ref="CONSOLE" /><appender-ref ref="FILE" /></root></configuration>

2、枚举

直接看一个例子：

package com.itheima.my_enum;public class Enum_Test {/*** 枚举介绍：Java中一种特殊的类型，常用于信息的标记和分类，和常量相比，有如下特点：*         1、常量*         2、枚举：入参严谨、提示性更强、代码优雅*/public static void main(String[] args) {method(Season.SUMMER);//注意：入参是枚举类Season的对象System.out.println(Season.SPRING.getCode());//1System.out.println(Season.SPRING.getName());//春天System.out.println(Season.SPRING.getDesc());//我是春天}private static void method(Season season) {switch (season){case SPRING:System.out.println("春天");break;case SUMMER:System.out.println("夏天");break;case AUTUMN:System.out.println("秋天");break;case WINTER:System.out.println("冬天");break;}}
}enum Season{//枚举项：枚举类的对象SPRING("1", "春天", "我是春天"),SUMMER("2", "夏天", "我是夏天"),AUTUMN("3", "秋天", "我是秋天"),WINTER("4", "冬天", "我是冬天");private final String code;private final String name;private final String desc;//枚举类的带参构造方法，则枚举类的对象入参必须要写private Season(String code, String name, String desc){this.code = code;this.name = name;this.desc = desc;}public String getCode() {return code;}public String getName() {return name;}public String getDesc() {return desc;}
}

3、类加载器

3.1 类加载器的介绍

3.2 类加载器的加载过程：加载、链接、初始化

上述的解析需要解释一下，如果一个类只是被加载到方法区，那么这个类里的其他类只是一个符号，并没有创建地址，只有当这个类被创建了之后，这个类里的其他类才会分配地址，也就是上述说的：将常量池中的符号引用解析为直接引用。

3.3 类加载器的分类

package com.itheima.classloader;
import sun.net.spi.nameservice.dns.DNSNameService;
public class ClassLoaderTest {/*** 各自类加载器的职责*/public static void main(String[] args) {//1、加载JDK自带的类 BootStrap ClassLoader (启动类加载器)ClassLoader classLoader1 = String.class.getClassLoader();System.out.println(classLoader1);//2、Platform ClassLoader (平台类加载器)  jdk8的话，获取的是jre\lib\ext\   jdk9及之后的话  lib\modulesClassLoader classLoader2 = DNSNameService.class.getClassLoader();System.out.println(classLoader2);//3、Application ClassLoader (系统类加载器) 加载自己编写的类ClassLoader classLoader3 = ClassLoaderTest.class.getClassLoader();System.out.println(classLoader3);//sun.misc.Launcher$AppClassLoader@18b4aac2//4、测试类加载器的上下级关系System.out.println(classLoader3.getParent());//获取他的上级System.out.println(classLoader3.getParent().getParent());//获取他上级的上级}
}

3.4 双亲委派模式

3.4 ClassLoaser的常用成员方法

package com.itheima.classloader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;public class ClassLoaderMethod {public static void main(String[] args) throws IOException {//获取系统类加载器 Application Class LoaderClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();System.out.println(systemClassLoader);//通过系统类加载器，加载配置文件//系统类加载器加载我们自己编写的类，因为自己编写的类在src文件夹下，因此下面的路径写相对路径即可InputStream is = systemClassLoader.getResourceAsStream("config1.properties");//FileReader fileReader = new FileReader("config1.properties");//之前我们通过字符流加载配置文件Properties prop = new Properties();prop.load(is);//prop.load(fileReader);is.close();String username = prop.getProperty("username");String password = prop.getProperty("password");System.out.println(username);System.out.println(password);}
}

4、反射

4.1 反射概念

正常java程序运行时，先将.java文件编译成.class的字节码文件后，将需要用到的字节码文件加载到方法区进行调用。而反射机制实际上就是直接拿到.class的字节码文件后作解剖，即直接操作字节码文件对应的对象（即字节码对象，注：java中万物皆对象）。

4.2 反射的使用

4.2.1 获取类的字节码对象：

package com.itheima.reflect;
import com.itheima.domain.Student;public class ReflectDemo1 {/*** 获取字节码对象的三种方式*/public static void main(String[] args) throws ClassNotFoundException {//1、通过Class的静态方法forNameClass<?> class1 = Class.forName("com.itheima.domain.Student");//2、类名.classClass<Student> class2 = Student.class;//3、Object类中的getClass()Student stu = new Student();Class<? extends Student> class3 = stu.getClass();System.out.println(class1);System.out.println(class2);System.out.println(class3);//字节码文件只有一份，那这三种方法获取到的字节码对象应该也是指向同一个地址，我们看下是否是这样:返回为true，表明正确System.out.println(class1 == class2);//trueSystem.out.println(class2 == class3);//trueSystem.out.println(class3 == class1);//true}
}

4.2.2 反射类中的构造方法

package com.itheima.reflect;
import java.lang.reflect.Constructor;public class ReflectDemo2 {/*** 反射类中的构造方法** 1. Constructor<?>[]  getConstructors()                                 返回所有公共构造方法对象的数组* 2. Constructor<?>[]  getDeclaredConstructors()                         返回所有构造方法对象的数组* 3. Constructor<?>[]  getConstructor(Class<?>...parameterTypes)         返回单个公共构造方法对象,参数是字节码对象,用来识别返回哪个构造方法* 4. Constructor<?>[]  getDeclaredConstructor(Class<?>...parameterTypes) 返回单个构造方法对象,参数是字节码对象,识别返回哪个构造方法** --------------------------------------------------------------------------------------------------------* 创建对象的方法* 1.T newInstance(Object...initargs)    根据指定的构造方法创建对象* 2.setAccessible(boolean flag)         设置为true,表示取消访问检查*/public static void main(String[] args) throws Exception {//1、获取类的字节码对象Class<?> studentClass = Class.forName("com.itheima.domain.Student");//2、反射构造方法对象
//        Constructor<?>[] constructors = studentClass.getConstructors();//返回所有公共构造方法对象的数组Constructor<?>[] constructors = studentClass.getDeclaredConstructors();//返回所有构造方法对象的数组for (Constructor<?> constructor : constructors) {System.out.println(constructor);}//3、反射单个构造方法
//        Constructor<?> constructor = studentClass.getConstructor();//返回单个公共构造方法对象Constructor<?> constructor = studentClass.getDeclaredConstructor(String.class, int.class);//返回带参构造方法对象constructor.setAccessible(true);//设置为true,表示取消访问检查。即:私有构造方法也可以有权限使用System.out.println(constructor);//4、通过构造方法对象，完成实例化Object o = constructor.newInstance("小明", 67);System.out.println(o);}
}

4.2.3 反射类中的成员变量

package com.itheima.reflect;
import com.itheima.domain.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;public class ReflectDemo3 {/*** 反射类中的成员变量* 1.Field[] getFields()                   返回所有公共成员变量对象的数组* 2.Field[] getDeclaredFields()           返回所有成员变量对象的数组* 3.Field getFields(String name)          返回单个公共成员变量对象* 4.Field getDeclaredFields(String name)  返回单个成员变量对象--------------------------------------------------------------------* Field类的设置和获取方法* 1.void set(Object obj, Object value)    赋值* 2.Object get(Object obj)                获取值*/public static void main(String[] args) throws Exception {//1、获取类的字节码对象Class<Student> studentClass = Student.class;//2、反射内部的成员变量对象Field[] declaredFields = studentClass.getDeclaredFields();//暴力返回所有的成员变量（私有共有都返回）Field[] fields = studentClass.getFields();//返回所有的公共成员变量for (Field declaredField : declaredFields) {System.out.println(declaredField);}Field ageField = studentClass.getDeclaredField("age");Field nameField = studentClass.getDeclaredField("name");//3、设置访问权限ageField.setAccessible(true);nameField.setAccessible(true);//4、使用成员变量，完成赋值和获取操作Constructor<Student> constructor = studentClass.getConstructor();//获取反射类的构造方法Student student = constructor.newInstance();//用反射类的构造方法new一个对象ageField.set(student, 34);nameField.set(student, "马斯");System.out.println(ageField.get(student));System.out.println(nameField.get(student));}
}

4.2.4 反射类中的成员方法

package com.itheima.reflect;
import com.itheima.domain.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;public class ReflectDemo4 {/*** 反射类中的成员方法* 1.Method[] getMethods()               返回所有公共成员方法对象的数组，包括继承的* 2.Method[] getDeclaredMethods()       返回所有公成员方法对象的数组，不包括继承的* 3.Method getMethod(String name, Class<?>...parameterTypes)         返回单个* 4.Method getDeclaredMethod(String name, Class<?>...parameterTypes) 返回单个* ----------------------------------------------------------------------------* Method类的执行方法* Object invoke(Object obj, Object... args)       运行方法*/public static void main(String[] args) throws Exception{//1、获取字节码对象Class<Student> studentClass = Student.class;//2、通过字节码对象，反射内部的成员方法对象(所有public修饰的)Method[] methods = studentClass.getMethods();//返回所有公共成员方法对象的数组，包括继承的Method[] declaredMethods = studentClass.getDeclaredMethods();//返回所有公成员方法对象的数组，不包括继承的for (Method method : declaredMethods) {System.out.println(method);}//3、通过字节码对象，反射指定的成员方法Method method1 = studentClass.getMethod("eat");//eat为方法名，空参eat()方法Method method2 = studentClass.getMethod("eat", int.class);//eat为方法名，带参数的eat(int num)方法System.out.println(method1);System.out.println(method2);//4、让反射到的成员方法执行Constructor<Student> constructor = studentClass.getConstructor();//用反射类的构造方法创建对象Student student = constructor.newInstance();method2.invoke(student, 2);//第一个参数为对象，第二个参数为方法的参数}
}

4.2.5 案例：

（1）

package com.itheima.reflect;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;public class ReflectTest1 {/*** 需求：请向一个泛型为 Integer 的集合，添加一个 String 字符串* 思路：Java 中的泛型是假的，只在编译的时候有效。也就是说，字节码文件里没有泛型*/public static void main(String[] args) throws Exception {ArrayList<Integer> arrayList = new ArrayList<>();Collections.addAll(arrayList, 1, 2, 3, 4);//1、获取list集合对象的字节码对象Class<? extends ArrayList> listClass = arrayList.getClass();//2、反射类中的add成员方法Method addMethod = listClass.getMethod("add", Object.class);//3、调用add方法，添加字符串。注：因为字节码文件没有泛型，因此我们可以向之前定义泛型为int的集合添加字符串addMethod.invoke(arrayList, "哈哈");System.out.println(arrayList);//[1, 2, 3, 4, 哈哈]}
}

（2）

public class Student {private String name;private int age;public void eat(){System.out.println("学生吃饭...");}public void study(){System.out.println("学生学习...");}
}

public class Teacher {private String name;private int age;public void eat(){System.out.println("老师吃饭...");}public void teach(){System.out.println("老师教学...");}
}

public class Worker {private String name;private int age;public void sleep(){System.out.println("工人睡觉...");}public void work(){System.out.println("工人工作...");}
}

config.properties文件：

className=com.itheima.reflect.Worker
methodName=sleep

package com.itheima.reflect;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;public class Test {/*** 从配置文件读取类名和方法名，然后获取字节码对象后，反射其方法并调用*/public static void main(String[] args) throws Exception{//1、加载配置文件InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("testConfig.properties");//2、创建properties集合加载数据Properties prop = new Properties();prop.load(is);is.close();//3、取出数据String className = prop.getProperty("className");String methodName = prop.getProperty("methodName");//4、获取字节码对象Class<?> aClass = Class.forName(className);//5、用字节码对象反射构造方法并创建对象Object instance = aClass.getConstructor().newInstance();//6、反射成员方法并调用Method eat = aClass.getMethod(methodName);eat.invoke(instance);}
}