进阶技术基本知识

待我称王封你为后i 2023-10-14 22:42 25阅读 0赞

#### 进阶技术 ####

*  1.类加载器
 *   *  1.2类加载的过程
     *  1.3类加载的分类
     *  1.4双亲委派模型
     *  1.5ClassLoader 中的两个方法【应用】
 *  2.反射
 *   *  2.1反射的概述【理解】
     *  2.2获取Class类对象的三种方式【应用】
     *  2.3反射获取构造方法并使用
     *   *  2.3.1Class类获取构造方法对象的方法
         *  2.3.2Constructor类用于创建对象的方法
     *  2.4反射获取成员变量并使用【应用】
     *   *  2.4.1Class类获取成员变量对象的方法
         *  2.4.2Field类用于给成员变量赋值的方法
     *  2.5反射获取成员方法并使用【应用】
     *   *  2.5.1Class类获取成员方法对象的方法
         *  2.5.2Method类用于执行方法的方法
 *  3.枚举
 *   *  3.1概述【理解】
     *  3.2定义格式【应用】
     *  3.3枚举的特点【理解】
     *  3.4枚举的方法【应用】
 *  4.注解
 *   *  4.2自定义注解
     *  4.3元注解【理解】
 *  5.日志
 *   *  5.1日志体系结构和Log4J【理解】
     *  5.2配置文件详解【理解】
     *  5.3在项目中的应用【应用】

## 1.类加载器 ##

*  作用

负责将.class文件（存储的物理文件）加载在到内存中  
![在这里插入图片描述][9e6bd02ef06c431db90afb7b3ba77245.png]

### 1.2类加载的过程 ###

*  类加载时机
    
     *  创建类的实例（对象）
     *  调用类的类方法
     *  访问类或者接口的类变量，或者为该类变量赋值
     *  使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
     *  初始化某个类的子类
     *  直接使用java.exe命令来运行某个主类
 *  类加载过程
    
    1.  加载
        
         *  通过包名 + 类名，获取这个类，准备用流进行传输
         *  在这个类加载到内存中
         *  加载完毕创建一个class对象  
            ![在这里插入图片描述][354c8043f5f94809a3aea1d1e4d7fc8c.png]  
            链接
 *  验证
    
    确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全
    
    (文件中的信息是否符合虚拟机规范有没有安全隐患)  
    ![在这里插入图片描述][e9a1d969f24a40789d1bae936e0ee5b3.png]
 *  准备

负责为类的类变量（被static修饰的变量）分配内存，并设置默认初始化值

(初始化静态变量)  
![在这里插入图片描述][6300b327df7d482f83f4551f21978ed8.png]

*  解析
    
    将类的二进制数据流中的符号引用替换为直接引用
    
    (本类中如果用到了其他类，此时就需要找到对应的类)

![在这里插入图片描述][535c8d75b28b45baabefe98e88c485d9.png]

*  初始化

根据程序员通过程序制定的主观计划去初始化类变量和其他资源

(静态变量赋值以及初始化其他资源)  
![在这里插入图片描述][901ee8f01db74e1b8e615d569dd912b1.png]  
小结

*  当一个类被使用的时候，才会加载到内存
 *  类加载的过程: 加载、验证、准备、解析、初始化

### 1.3类加载的分类 ###

*  分类
    
     *  Bootstrap class loader：虚拟机的内置类加载器，通常表示为null ，并且没有父null
     *  Platform class loader：平台类加载器,负责加载JDK中一些特殊的模块
     *  System class loader：系统类加载器,负责加载用户类路径上所指定的类库
 *  类加载器的继承关系
    
     *  System的父加载器为Platform
     *  Platform的父加载器为Bootstrap

### 1.4双亲委派模型 ###

*  介绍

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式  
![在这里插入图片描述][6ad29ce9d3284b6a9d504f95c71e6282.png]

### 1.5ClassLoader 中的两个方法【应用】 ###

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>public static ClassLoader getSystemClassLoader()</td> 
       <td>获取系统类加载器</td> 
      </tr> 
      <tr> 
       <td>public InputStream getResourceAsStream(String name)</td> 
       <td>加载某一个资源文件</td> 
      </tr> 
     </tbody> 
    </table>
 *  示例代码

public class ClassLoaderDemo2 {
        
        public static void main(String[] args) throws IOException {
        
            //static ClassLoader getSystemClassLoader() 获取系统类加载器
            //InputStream getResourceAsStream(String name)  加载某一个资源文件
    
            //获取系统类加载器
            ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
    
            //利用加载器去加载一个指定的文件
            //参数：文件的路径（放在src的根目录下，默认去那里加载）
            //返回值：字节流。
            InputStream is = systemClassLoader.getResourceAsStream("prop.properties");
    
            Properties prop = new Properties();
            prop.load(is);
    
            System.out.println(prop);
    
            is.close();
        }
    }

## 2.反射 ##

### 2.1反射的概述【理解】 ###

*  反射机制
    
    是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；  
    对于任意一个对象，都能够调用它的任意属性和方法；  
    这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

### 2.2获取Class类对象的三种方式【应用】 ###

*  三种方式分类
    
     *  类名.class属性
     *  对象名.getClass()方法
     *  Class.forName(全类名)方法  
        ![在这里插入图片描述][e2d9e3fc8ebd4eb594100ff93a77723d.png]

public class ReflectDemo1 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            //1.Class类中的静态方法forName("全类名")
            //最为常用
                //全类名:包名 + 类名
            Class clazz = Class.forName("com.itheima.myreflect2.Student");
            System.out.println(clazz);
    
            //2.通过class属性来获取
            Class clazz2 = Student.class;
            System.out.println(clazz2);
    
            //3.利用对象的getClass方法来获取class对象
            //创建了对象才可以使用
            //getClass方法是定义在Object类中.
            Student s = new Student();
            Class clazz3 = s.getClass();
            System.out.println(clazz3);
    
            System.out.println(clazz == clazz2);//ture
            System.out.println(clazz2 == clazz3);//ture
        }

### 2.3反射获取构造方法并使用 ###

#### 2.3.1Class类获取构造方法对象的方法 ####

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Constructor&lt;?&gt;[] getConstructors()</td> 
       <td>返回所有公共构造方法对象的数组</td> 
      </tr> 
      <tr> 
       <td>Constructor&lt;?&gt;[] getDeclaredConstructors()</td> 
       <td>返回所有构造方法对象的数组</td> 
      </tr> 
      <tr> 
       <td>Constructor getConstructor(Class&lt;?&gt;… parameterTypes)</td> 
       <td>返回单个公共构造方法对象</td> 
      </tr> 
      <tr> 
       <td>Constructor getDeclaredConstructor(Class&lt;?&gt;… parameterTypes)</td> 
       <td>返回单个构造方法对象</td> 
      </tr> 
     </tbody> 
    </table>

#### 2.3.2Constructor类用于创建对象的方法 ####

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>T newInstance(Object…initargs)</td> 
       <td>根据指定的构造方法创建对象</td> 
      </tr> 
      <tr> 
       <td>setAccessible(boolean flag)</td> 
       <td>设置为true,表示取消访问检查</td> 
      </tr> 
     </tbody> 
    </table>

### 2.4反射获取成员变量并使用【应用】 ###

#### 2.4.1Class类获取成员变量对象的方法 ####

*  方法分类
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Field[] getFields()</td> 
       <td>返回所有公共成员变量对象的数组</td> 
      </tr> 
      <tr> 
       <td>Field[] getDeclaredFields()</td> 
       <td>返回所有成员变量对象的数组</td> 
      </tr> 
      <tr> 
       <td>Field getField(String name)</td> 
       <td>返回单个公共成员变量对象</td> 
      </tr> 
      <tr> 
       <td>Field getDeclaredField(String name)</td> 
       <td>返回单个成员变量对象</td> 
      </tr> 
     </tbody> 
    </table>

public class Student {
        
    
        public String name;
    
        public int age;
    
        public String gender;
    
        private int money = 300;
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", gender='" + gender + '\'' +
                    ", money=" + money +
                    '}';
        }
    }
    public class ReflectDemo1 {
        
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        
           // method1();
            //method2();
            //method3();
            //method4();
    
        }
    
        private static void method4() throws ClassNotFoundException, NoSuchFieldException {
        
            //        Field getDeclaredField(String name)：返回单个成员变量对象
            //1.获取class对象
            Class clazz = Class.forName("com.itheima.myreflect4.Student");
      
            //2.获取money成员变量
            Field field = clazz.getDeclaredField("money");
      
            //3.打印一下
            System.out.println(field);
        }
      
        private static void method3() throws ClassNotFoundException, NoSuchFieldException {
        
            //        Field getField(String name)：返回单个公共成员变量对象
            //想要获取的成员变量必须是真实存在的
            //且必须是public修饰的.
            //1.获取class对象
            Class clazz = Class.forName("com.itheima.myreflect4.Student");
      
            //2.获取name这个成员变量
            //Field field = clazz.getField("name");
            //Field field = clazz.getField("name1");
            Field field = clazz.getField("money");
             System.out.println(field);
            //获取成员修饰符
            int modifiers  =  clazz.getModifiers();
            System.out.println(modifiers);
            //获取成员类型
            Class<?> type  = clazz.getType();
             System.out.println(type);
           
           
        }
      
        private static void method2() throws ClassNotFoundException {
        
            //        Field[] getDeclaredFields()：返回所有成员变量对象的数组
            //1.获取class对象
            Class clazz = Class.forName("com.itheima.myreflect4.Student");
      
            //2.获取所有的Field对象
            Field[] fields = clazz.getDeclaredFields();
      
            //3.遍历
            for (Field field : fields) {
        
                System.out.println(field);
            }
        }
      
        private static void method1() throws ClassNotFoundException {
        
            //        Field[] getFields()：返回所有公共成员变量对象的数组
      
            //1.获取class对象
            Class clazz = Class.forName("com.itheima.myreflect4.Student");
      
            //2.获取Field对象.
            Field[] fields = clazz.getFields();
      
            //3.遍历
            for (Field field : fields) {
        
                System.out.println(field);
            }
        }
    }

#### 2.4.2Field类用于给成员变量赋值的方法 ####

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>void set(Object obj, Object value)</td> 
       <td>赋值</td> 
      </tr> 
      <tr> 
       <td>Object get(Object obj)</td> 
       <td>获取值</td> 
      </tr> 
     </tbody> 
    </table>

### 2.5反射获取成员方法并使用【应用】 ###

#### 2.5.1Class类获取成员方法对象的方法 ####

*  方法分类
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Method[] getMethods()</td> 
       <td>返回所有公共成员方法对象的数组，包括继承的(父类中所有公共方法)</td> 
      </tr> 
      <tr> 
       <td>Method[] getDeclaredMethods()</td> 
       <td>返回所有成员方法对象的数组，不包括继承的</td> 
      </tr> 
      <tr> 
       <td>Method getMethod(String name, Class&lt;?&gt;… parameterTypes)</td> 
       <td>返回单个公共成员方法对象</td> 
      </tr> 
      <tr> 
       <td>Method getDeclaredMethod(String name, Class&lt;?&gt;… parameterTypes)</td> 
       <td>返回单个成员方法对象</td> 
      </tr> 
     </tbody> 
    </table>

#### 2.5.2Method类用于执行方法的方法 ####

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Object invoke(Object obj, Object… args)</td> 
       <td>运行方法</td> 
      </tr> 
     </tbody> 
    </table>
    
    参数一: 用obj对象调用该方法
    
    参数二: 调用方法的传递的参数(如果没有就不写)
    
    返回值: 方法的返回值(如果没有就不写)

public class ReflectDemo2 {
        
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        
    
            //1.获取class对象
            Class clazz = Class.forName("com.itheima.myreflect5.Student");
            //2.获取里面的Method对象  function4
            Method method = clazz.getMethod("function4", String.class);
            //3.运行function4方法就可以了
            //3.1创建一个Student对象,当做方法的调用者
            Student student = (Student) clazz.newInstance();
            //3.2运行方法
            Object result = method.invoke(student, "zhangsan");
            //4.打印一下返回值
            System.out.println(result);
        }
    }

## 3.枚举 ##

### 3.1概述【理解】 ###

为了间接的表示一些固定的值，Java就给我们提供了枚举  
是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内

*  enum与Enum的区别：

enum是在jdk1.5之后出现的，为了定义枚举实际上就是让这个类继承Enum类；

Enum类抽象类，没有实际意义

### 3.2定义格式【应用】 ###

*  格式
    
        public enum s {
                 
        	枚举项1,枚举项2,枚举项3;
        }
        注意: 定义枚举类要用关键字enum
 *  示例代码

// 定义一个枚举类，用来表示春，夏，秋，冬这四个固定值
    public enum Season {
        
        SPRING,SUMMER,AUTUMN,WINTER;
    }

### 3.3枚举的特点【理解】 ###

*  特点
    
     *  所有枚举类都是Enum的子类
     *  我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
     *  每一个枚举项其实就是该枚举的一个对象
     *  枚举也是一个类，也可以去定义成员变量
     *  枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
     *  枚举类可以有构造器，但必须是private的，它默认的也是private的。
        
        枚举项的用法比较特殊：枚举(“”);
     *  枚举类也可以有抽象方法，但是枚举项必须重写该方法

### 3.4枚举的方法【应用】 ###

*  方法介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>String name()</td> 
       <td>获取枚举项的名称</td> 
      </tr> 
      <tr> 
       <td>int ordinal()</td> 
       <td>返回枚举项在枚举类中的索引值</td> 
      </tr> 
      <tr> 
       <td>int compareTo(E o)</td> 
       <td>比较两个枚举项，返回的是索引值的差值</td> 
      </tr> 
      <tr> 
       <td>String toString()</td> 
       <td>返回枚举常量的名称</td> 
      </tr> 
      <tr> 
       <td>static T valueOf(Class type,String name)</td> 
       <td>获取指定枚举类中的指定名称的枚举值</td> 
      </tr> 
      <tr> 
       <td>values()</td> 
       <td>获得所有的枚举项</td> 
      </tr> 
     </tbody> 
    </table>

public enum Season {
        
        SPRING,SUMMER,AUTUMN,WINTER;
    }
    
    public class EnumDemo {
        
        public static void main(String[] args) {
        
    //        String name() 获取枚举项的名称
            String name = Season.SPRING.name();
            System.out.println(name);
            System.out.println("-----------------------------");
    
    //        int ordinal() 返回枚举项在枚举类中的索引值
            int index1 = Season.SPRING.ordinal();
            int index2 = Season.SUMMER.ordinal();
            int index3 = Season.AUTUMN.ordinal();
            int index4 = Season.WINTER.ordinal();
            System.out.println(index1);
            System.out.println(index2);
            System.out.println(index3);
            System.out.println(index4);
            System.out.println("-----------------------------");
    
    //        int compareTo(E o) 比较两个枚举项，返回的是索引值的差值
            int result = Season.SPRING.compareTo(Season.WINTER);
            System.out.println(result);//-3
            System.out.println("-----------------------------");
    
    //        String toString()   返回枚举常量的名称
            String s = Season.SPRING.toString();
            System.out.println(s);
            System.out.println("-----------------------------");
    
    //        static <T> T valueOf(Class<T> type,String name)
    //        获取指定枚举类中的指定名称的枚举值
            Season spring = Enum.valueOf(Season.class, "SPRING");
            System.out.println(spring);
            System.out.println(Season.SPRING == spring);
            System.out.println("-----------------------------");
    
    //        values()       获得所有的枚举项
            Season[] values = Season.values();
            for (Season value : values) {
        
                System.out.println(value);
            }
        }
    }

## 4.注解 ##

*  概述
    
    对我们的程序进行标注和解释
 *  注解和注释的区别
    
     *  注释: 给程序员看的
     *  注解: 给编译器看的
 *  使用注解进行配置配置的优势
    
    代码更加简洁,方便
    
    注解可以用在类上，构造器上，方法上，成员变量上等等，比如@Override，@Test

### 4.2自定义注解 ###

*  格式
    
    public @interface 注解名称 \{
    
    public 属性类型 属性名() default 默认值 ;
    
    \}
 *  属性类型
    
     *  基本数据类型
     *  String
     *  Class
     *  注解
     *  枚举
     *  以上类型的一维数组

public @interface Anno2 {
        
    }
    
    public enum Season {
        
        SPRING,SUMMER,AUTUMN,WINTER;
    }
    
    public @interface Anno1 {
        
    
        //定义一个基本类型的属性
        int a () default 23;
    
        //定义一个String类型的属性
        public String name() default "itheima";
    
        //定义一个Class类型的属性
        public Class clazz() default Anno2.class;
    
        //定义一个注解类型的属性
        public Anno2 anno() default @Anno2;
    
        //定义一个枚举类型的属性
        public Season season() default Season.SPRING;
    
        //以上类型的一维数组
        //int数组
        public int[] arr() default {
        1,2,3,4,5};
    
        //枚举数组
        public Season[] seasons() default {
        Season.SPRING,Season.SUMMER};
    
        //value。后期我们在使用注解的时候，如果我们只需要给注解的value属性赋值。
        //那么value就可以省略
        public String value();
    
    }
    
    //在使用注解的时候如果注解里面的属性没有指定默认值。
    //那么我们就需要手动给出注解属性的设置值。
    //@Anno1(name = "itheima")
    @Anno1("abc")
    public class AnnoDemo {
        
    }

注意

如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可

*  自定义注解案例
    
     *  需求
        
        自定义一个注解@Test,用于指定类的方法上,如果某一个类的方法上使用了该注解,就执行该方法
     *  实现步骤
        
        1.  自定义一个注解Test,并在类中的某几个方法上加上注解
        2.  在测试类中,获取注解所在的类的Class对象
        3.  获取类中所有的方法对象
        4.  遍历每一个方法对象,判断是否有对应的注解
     *  代码实现

//表示Test这个注解的存活时间
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface Test {
        
    }
    
    public class UseTest {
        
    
        //没有使用Test注解
        public void show(){
        
            System.out.println("UseTest....show....");
        }
    
        //使用Test注解
        @Test
        public void method(){
        
            System.out.println("UseTest....method....");
        }
    
        //没有使用Test注解
        @Test
        public void function(){
        
            System.out.println("UseTest....function....");
        }
    }
    
    public class AnnoDemo {
        
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
        
            //1.通过反射获取UseTest类的字节码文件对象
            Class clazz = Class.forName("com.itheima.myanno3.UseTest");
    
            //创建对象
            UseTest useTest = (UseTest) clazz.newInstance();
    
            //2.通过反射获取这个类里面所有的方法对象
            Method[] methods = clazz.getDeclaredMethods();
    
            //3.遍历数组，得到每一个方法对象
            for (Method method : methods) {
        
                //method依次表示每一个方法对象。
                //isAnnotationPresent(Class<? extends Annotation> annotationClass)
                //判断当前方法上是否有指定的注解。
                //参数：注解的字节码文件对象
                //返回值：布尔结果。  true 存在  false 不存在
                if(method.isAnnotationPresent(Test.class)){
        
                    method.invoke(useTest);
                }
            }
        }
    }

### 4.3元注解【理解】 ###

*  概述
    
    元注解就是描述注解的注解
 *  元注解介绍
    
    <table> 
     <thead> 
      <tr> 
       <th>元注解名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>@Target</td> 
       <td>指定了注解能在哪里使用</td> 
      </tr> 
      <tr> 
       <td>@Retention</td> 
       <td>可以理解为保留时间(生命周期)</td> 
      </tr> 
      <tr> 
       <td>@Inherited</td> 
       <td>表示修饰的自定义注解可以被子类继承</td> 
      </tr> 
      <tr> 
       <td>@Documented</td> 
       <td>表示该自定义注解，会出现在API文档里面。</td> 
      </tr> 
     </tbody> 
    </table>

@Target({
        ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})  //指定注解使用的位置（成员变量，类，方法）
    @Retention(RetentionPolicy.RUNTIME) //指定该注解的存活时间
    //@Inherited //指定该注解可以被继承
    public @interface Anno {
        
    }
    
    @Anno
    public class Person {
        
    }
    
    public class Student extends Person {
        
        public void show(){
        
            System.out.println("student.......show..........");
        }
    }
    
    public class StudentDemo {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            //获取到Student类的字节码文件对象
            Class clazz = Class.forName("com.itheima.myanno4.Student");
    
            //获取注解。
            boolean result = clazz.isAnnotationPresent(Anno.class);
            System.out.println(result);
        }
    }

## 5.日志 ##

*  概述
    
    程序中的日志可以用来记录程序在运行的时候点点滴滴。并可以进行永久存储。
 *  日志与输出语句的区别
    
    <table> 
     <thead> 
      <tr> 
       <th></th> 
       <th>输出语句</th> 
       <th>日志技术</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>取消日志</td> 
       <td>需要修改代码，灵活性比较差</td> 
       <td>不需要修改代码，灵活性比较好</td> 
      </tr> 
      <tr> 
       <td>输出位置</td> 
       <td>只能是控制台</td> 
       <td>可以将日志信息写入到文件或者数据库中</td> 
      </tr> 
      <tr> 
       <td>多线程</td> 
       <td>和业务代码处于一个线程中</td> 
       <td>多线程方式记录日志，不影响业务代码的性能</td> 
      </tr> 
     </tbody> 
    </table>

### 5.1日志体系结构和Log4J【理解】 ###

![在这里插入图片描述][1036c83f765d4e6f9e7e62232a578f23.png]

*  Log4J
    
    Log4j是Apache的一个开源项目。
    
    通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件等位置。
    
    我们也可以控制每一条日志的输出格式。
    
    通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
    
    最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
 *  Apache基金会
    
    Apache软件基金会（也就是Apache Software Foundation，简称为ASF），为支持开源软件项目而办的一个非盈利性组织。

### 5.2配置文件详解【理解】 ###

*  三个核心
    
     *  Loggers(记录器) 日志的级别
        
        Loggers组件在此系统中常见的五个级别：DEBUG、INFO、WARN、ERROR 和 FATAL。
        
        DEBUG < INFO < WARN < ERROR < FATAL。
        
        Log4j有一个规则：只输出级别不低于设定级别的日志信息。
     *  Appenders(输出源) 日志要输出的地方
        
        把日志输出到不同的地方，如控制台（Console）、文件（Files）等。
        
         *  org.apache.log4j.ConsoleAppender（控制台）
         *  org.apache.log4j.FileAppender（文件）
     *  Layouts(布局) 日志输出的格式
        
        可以根据自己的喜好规定日志输出的格式
        
        常用的布局管理器：
        
        org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
        
        org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
        
            org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）
 *  配置根Logger
    
     *  格式
        
        log4j.rootLogger=日志级别，appenderName1，appenderName2，…
     *  日志级别
        
        OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。
     *  appenderName1
        
        就是指定日志信息要输出到哪里。可以同时指定多个输出目的地，用逗号隔开。
        
        例如：log4j.rootLogger＝INFO，ca，fa
 *  ConsoleAppender常用的选项
    
     *  ImmediateFlush=true
        
        表示所有消息都会被立即输出，设为false则不输出，默认值是true。
     *  Target=System.err
        
        默认值是System.out。
 *  FileAppender常用的选项
    
     *  ImmediateFlush=true
        
        表示所有消息都会被立即输出。设为false则不输出，默认值是true
     *  Append=false
        
        true表示将消息添加到指定文件中，原来的消息不覆盖。
        
        false则将消息覆盖指定的文件内容，默认值是true。
     *  File=D:/logs/logging.log4j
        
        指定消息输出到logging.log4j文件中
 *  PatternLayout常用的选项
    
     *  ConversionPattern=%m%n
        
        设定以怎样的格式显示消息  
        ![在这里插入图片描述][ad92ca41bedd4b509d21e8d2edde78d0.png]

### 5.3在项目中的应用【应用】 ###

*  步骤
    
    1.  导入相关的依赖
    2.  将资料中的properties配置文件复制到src目录下
    3.  在代码中获取日志的对象
    4.  按照级别设置记录日志信息

@WebServlet(urlPatterns = "/servlet/loginservlet")
    public class LoginServlet implements HttpServlet{
        
    
        //获取日志的对象
        private static final Logger LOGGER = LoggerFactory.getLogger(LoginServlet.class);
    
        @Override
        public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
        
           //处理
            System.out.println("LoginServlet处理了登录请求");
    
            LOGGER.info("现在已经处理了登录请求，准备给浏览器响应");
    
           //响应
            httpResponse.setContentTpye("text/html;charset=UTF-8");
            httpResponse.write("登录成功");
        }
    }

[9e6bd02ef06c431db90afb7b3ba77245.png]: https://img-blog.csdnimg.cn/9e6bd02ef06c431db90afb7b3ba77245.png
[354c8043f5f94809a3aea1d1e4d7fc8c.png]: https://img-blog.csdnimg.cn/354c8043f5f94809a3aea1d1e4d7fc8c.png
[e9a1d969f24a40789d1bae936e0ee5b3.png]: https://img-blog.csdnimg.cn/e9a1d969f24a40789d1bae936e0ee5b3.png
[6300b327df7d482f83f4551f21978ed8.png]: https://img-blog.csdnimg.cn/6300b327df7d482f83f4551f21978ed8.png
[535c8d75b28b45baabefe98e88c485d9.png]: https://img-blog.csdnimg.cn/535c8d75b28b45baabefe98e88c485d9.png
[901ee8f01db74e1b8e615d569dd912b1.png]: https://img-blog.csdnimg.cn/901ee8f01db74e1b8e615d569dd912b1.png
[6ad29ce9d3284b6a9d504f95c71e6282.png]: https://img-blog.csdnimg.cn/6ad29ce9d3284b6a9d504f95c71e6282.png
[e2d9e3fc8ebd4eb594100ff93a77723d.png]: https://img-blog.csdnimg.cn/e2d9e3fc8ebd4eb594100ff93a77723d.png
[1036c83f765d4e6f9e7e62232a578f23.png]: https://img-blog.csdnimg.cn/1036c83f765d4e6f9e7e62232a578f23.png
[ad92ca41bedd4b509d21e8d2edde78d0.png]: https://img-blog.csdnimg.cn/ad92ca41bedd4b509d21e8d2edde78d0.png