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());//1
System.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\modules
ClassLoader 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 Loader
ClassLoader 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的静态方法forName
Class<?> class1 = Class.forName("com.itheima.domain.Student");
//2、类名.class
Class<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);//true
System.out.println(class2 == class3);//true
System.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);
}
}