logback.xml、抽象类、接口、多态、代码块、内部类、Lambda表达式、注解、动态代理、反射

学习在路上ing

已于 2024-07-09 10:13:14 修改

阅读量1k

点赞数 14

文章标签： logback xml spring boot

于 2024-03-26 10:53:52 首次发布

本文链接：https://blog.csdn.net/qq_21698517/article/details/137039301

版权

第三周笔记

一、logback.xml

引入依赖(包含有logging依赖)

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

在这里插入图片描述

1.logback的日志级别

Logger有五个日志级别，优先级由低到高分别是TRACE、DEBUG、INFO、WARN、ERROR，

（在打印日志的时候，只会打印当前日志级别高于或者等于当前日志级别的日志信息**）

2.springboot的默认日志级别

查看springboot项目的默认日志级别（结论：默认级别为INFO）

service层：

package com.cqgcxy.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * @projectName: logbook-study
 * @package: com.cqgcxy.service
 * @className: LogTest
 * @author: Qing
 * @description: TODO
 * @date: 2024/3/12 15:43
 * @version: 1.0
 */
@Service
public class LogTest {
    private static final Logger logger = LoggerFactory.getLogger(LogTest.class);
    public  void test() {
        logger.trace("===trace===");
        logger.debug("===debug===");
        logger.info("===info===");
        logger.warn("===warn===");
        logger.error("===error===");
    }
}

测试类：

package com.cqgcxy.service;


import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;

@SpringBootTest
public class LogTestTest {

    @Resource
    private LogTest logTest;
    @Test
    void testqwe() {
        logTest.test();
    }
}

输出结果：

在这里插入图片描述

3.日志级别的层级

（这里的日志级别如果没有指定，也会继承父类。）

在这里插入图片描述

4.logback配置文件

logback配置文件一般在springboot项目的src/main/resources目录下创建名为logback-spring.xml的文件

配置文件基本结构如下图：

在这里插入图片描述

4.1、configuration 标签

包含零个或多个<appender>元素，后跟零个或多个<logger>元素，后跟最多一个<root>元素(也可以没有)。

4.2、logger 标签（日志记录器）

用来控制要输出哪些日志记录语句，对日志信息进行级别限制。

有level属性、name属性、additivity属性，其中name属性必须要写，指定到哪一个类或者哪一个包，additivity表示是否向上一层传递打印信息，默认为true。可以包含 appender-ref 元素

示例：

<configuration>
    <logger level="ERROR" name="com.example.testlog.LogTest" additivity="false">
    	<appender-ref ref="STDOUT"></appender-ref>
    </logger>
</configuration>

4.3、root 标签

指定最基础的的日志输出级别

只有一个level属性，可以包含 appender-ref 元素。

level属性可以选择：

ALL: 所有级别的日志信息都记录
TRACE: 追踪信息
DEBUG: 调试信息
INFO: 普通信息
WARN: 警告信息
ERROR: 错误信息
OFF: 关闭日志记录器，不记录任何日志信息
INHERITED: 继承父级日志记录器的级别

示例：

<configuration>
    <root level="debug">
        <appender-ref ref="STDOUT"></appender-ref>
    </root>
</configuration>

4.4、appender 标签（附加器）

日志记录器会将输出的任务交给附加器完成，不同的附加器会将日志输出到不同的地方，例如控制台、文件、网络等。

几个常见的附加器：

1.控制台附加器：ch.qos.logback.core.ConsoleAppender
2.文件附加器：ch.qos.logback.core.FileAppender
3.滚动文件附加器：ch.qos.logback.core.rolling.RollingFileAppender

属性有name、class，class用来指定附加器，name来表示当前附件器的名字。其他需要指定附件器的标签，可以通过appender-ref标签中的ref来指定。可以包含encoder元素、fileter元素等

示例：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
</configuration>

4.5、filter标签(过滤器)

过滤器是附加器的一个组件，它是用于判断附件器是否输出日志。一个附件器可以包含多个过滤器。

过滤器只能有三个值，`DENY`、`NEUTRAL`、`ACCEPT`。
`DENY`: 不输出日志
`NEUTRAL`: 不决定是否输出日志
`ACCEPT`: 输出日志。
    
可以有三个元素，level元素、onMatch元素、onMismatch元素。
<level>：设置过滤级别
<onMatch>：用于配置符合过滤条件的操作
<onMismatch>：用于配置不符合过滤条件的操作。

示例：

<configuration>
 	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <filter>
            <level>info</level>
            <onMatch>DENY</onMatch>
            <onMismatch>ACCEPT</onMismatch>
        </filter>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
</configuration>

4.6、encoder标签

encoder最主要的就是pattern标签，用于控制输出日志的格式

%d: 表示日期
%-5level：日志级别
%thread：表示线程名
%logger：输出日志的类名
logger{length}：对输出日志的类名缩写展示
%msg：日志输出内容
%n：换行符
-：左对齐

示例：

<encoder>
 	<pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{36} - %msg%n</pattern>
</encoder>

在这里插入图片描述

4.7、property标签

property标签用来定义变量，有两个属性，name和value；其中name的值是变量的名称，value的值时变量定义的值

示例：

<property name="HOME" value="../log">

<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
	<file>${HOME}/log.log</file>
</appender>

整体演示：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <property name="LOG_PATH" value="C:/Users/lenovo/Desktop/ssm-1128/"/>
    <property name="LOG_FILE" value="logfile"/>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>${LOG_PATH}${LOG_FILE}.log</file>
        <append>true</append>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%-5level] %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>


    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>

    <logger level="trace" name="com.cqgcxy.service" additivity="false">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
    </logger>
  
</configuration>

二、抽象类

1.什么是抽象类


public class AbstractTest1 {
    /*
        抽象类: 特殊的父类

        问题: 特殊在哪里呢?
        回答: 内部允许编写抽象方法

        问题: 什么是抽象方法?
        回答: 当我们将共性的方法, 抽取到父类之后, 发现这个方法在父类中无法给出具体明确(描述不清了)
                而且这个方法, 还是子类必须要有的方法, 就可以设计为抽象方法.
     */
    public static void main(String[] args) {

    }
}

abstract class Animal {
    public abstract void eat();
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

2.抽象类的注意事项

public class AbstractTest2 {
    /*
        抽象类的注意事项 :

            1. 抽象类不能实例化
                - 如果抽象类允许创建对象, 就可以调用内部没有方法体的, 抽象方法了
            2. 抽象类存在构造方法
                - 交给子类, 通过super进行访问
            3. 抽象类中可以存在普通方法
                - 可以让子类继承到继续使用
            4. 抽象类的子类
                    1). 要么重写抽象类中的所有抽象方法
                    2). 要么是抽象类
     */
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();

    }
}

abstract class A {
    public abstract void showA();
}

abstract class B extends A {

    @Override
    public void showA() {

    }

    public abstract void showB();
}

class C extends B {

    @Override
    public void showB() {

    }
}


abstract class Fu {

    public Fu() {

    }

    public abstract void show();

    public void method() {
        System.out.println("method...");
    }

}

class Zi extends Fu {

    public Zi() {
        super();
    }

    @Override
    public void show() {

    }
}

3.abstract关键字的冲突

在这里插入图片描述

三、接口

1.什么是接口

体现的思想就是声明 [规则]

package minterface;

public class InterfaceTest1 {
    /*
        接口: 体现的思想就是声明 [规则]

        思路: 如果发现一个类, 所有的组成, 都是抽象方法
                    - 没有成员变量
                    - 没有普通方法

                    这种类, 我们通常会设计为Java中的接口, 因为现在这个类存在的唯一价值, 就只是声明规则了


        ---------------------------------

        接口的定义格式:

                interface 接口名 {}

        注意: 接口不允许实例化

        接口和类之间是实现关系, 通过implements关键字来完成

                class 类名 implements 接口名 {}

                实现类(接口的子类):

                        1. 重写所有抽象方法
                        2. 将实现类变成抽象类
     */
    public static void main(String[] args) {
        // 创建实现类对象
        InterImpl ii = new InterImpl();
        ii.method();
        ii.show();
    }
}

interface Inter {
    public abstract void show();
    public abstract void method();
}

class InterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("show...");
    }

    @Override
    public void method() {
        System.out.println("method...");
    }
}

2.接口的成员特点

package minterface;



public class InterfaceTest2 {
    /*
        接口的成员特点 :

            1. 成员变量 : 只能定义常量, 因为系统会默认加入三个关键字
                                public static final
                                - 这三个关键字没有顺序关系

            2. 成员方法 : 只能是抽象方法, 因为系统会默认加入两个关键字
                                public abstract

            3. 构造方法 : 没有
     */
    public static void main(String[] args) {
        System.out.println(Inter.num);
    }
}

interface MyInter {
    public static final int NUM = 10;

    public abstract void show();

    void method();
}

3.接口和类之间的各种关系

package minterface;

interface InterA {
    void show();
}

interface InterB {
    void show();
}

interface InterC extends InterA, InterB {
    void show();
}

class InterCImpl implements InterC {

    @Override
    public void show() {

    }
}

public class InterfaceTest3 {
    /*
        接口和类之间的各种关系 :

            1. 类和类之间 : 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承

            2. 类和接口之间 : 实现关系, 可以单实现, 也可以多实现, 甚至可以在继承一个类的同时, 实现多个接口

            3. 接口和接口之间 : 继承关系, 可以单继承, 也可以多继承
     */
    public static void main(String[] args) {

    }
}

class Fu {
    public void show() {
        System.out.println("Fu..show");
    }
}

interface A {
    void show();
}

interface B {
    void show();
}

class Zi extends Fu implements A, B {

}

小节：抽象类和接口的对比

在这里插入图片描述

四、多态

1.多态的前提、对象多态、行为多态

package polymorphism;

public class PolymorphismTest1 {
    /*
        多态的前提 :
                    有继承 / 实现关系
                    有方法重写
                    有父类引用指向子类对象

        1. 对象多态
                    Animal a1 = new Dog();
                    Animal a2 = new Cat();

                    好处: 方法的形参定义为父类类型, 这个方法就可以接收到该父类的任意子类对象了

        2. 行为多态
                    好处: 同一个方法, 具有多种不同表现形式, 或形态的能力
     */
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());

    }

    public static void useAnimal(Animal a) {        // Animal a = new Dog();
          a.eat();                                  // Animal a = new Cat();
    }

}

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

2.多态中的转型

在这里插入图片描述

3.接口中的default关键字

允许定义非抽象方法, 需要加入default关键字(解决接口的升级问题)

package jdk8;

public class InterfaceTest {
    /*
        JDK8版本接口特性:

            1. 允许定义非抽象方法, 需要加入default关键字

                    - 作用: 解决接口的升级问题
                    - 注意事项:
                                1. public可以省略, 但是default不能省略
                                2. 默认方法, 实现类是允许重写的, 但是需要去掉default关键字
                                3. 如果实现了多个接口, 多个接口中存在相同的默认方法, 实现类必须重写默认方法

            2. 允许定义静态方法

                     - 理解: 既然接口已经允许方法带有方法体了, 干脆也放开静态方法, 可以类名调用

                     - 注意事项 :
                                    1. public可以省略, 但是static不能省略
                                    2. 接口中的静态方法, 只允许接口名进行调用, 不允许实现类通过对象调用
     */
    public static void main(String[] args) {
        AInterImpl a = new AInterImpl();
        a.method();

        A.function();
    }
}

interface A {
    default void method() {
        System.out.println("A...method");
    }

    static void function() {
        System.out.println("A...static...function");
    }
}

interface Inter {
    void show();

    void print();

    default void method() {
        System.out.println("Inter...method");
    }

}

class AInterImpl extends Object implements Inter, A {


    @Override
    public void show() {
        System.out.println("AInterImpl...show");
    }

    @Override
    public void print() {
        System.out.println("AInterImpl...print");
    }

    @Override
    public void method() {
        A.super.method();
        Inter.super.method();
    }

}

class BInterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("BInterImpl...show");
    }

    @Override
    public void print() {
        System.out.println("BInterImpl...print");
    }
}

五、代码块

1.局部代码块

2.构造代码块

3.静态代码块

package block;

import java.net.Socket;

public class BlockTest {
    /*
        代码块 : 使用 { } 括起来的代码被称为代码块

        分类 :
                1. 局部代码块
                        位置: 方法中的一对大括号
                        作用: 限定变量的生命周期, 提早的释放内存

                2. 构造代码块
                        位置: 类中方法外的一对大括号
                        特点: 在创建对象, 执行构造方法的时候, 就会执行构造代码块 (优先于构造方法执行)
                        作用: 将多个构造方法中, 重复的代码, 抽取到构造代码块中, 从而提升代码的复用性

                3. 静态代码块
                        位置: 类中方法外的一对大括号, 需要加入static关键字
                        特点: 随着类的加载而执行, 因为类只加载一次, 所以也就只执行一次
                        作用: 对数据进行初始化
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student {

    static String school;

    static {
        school = "黑马程序员";
        System.out.println("static...Student类的静态代码块");

        // Socket
    }

    {
        System.out.println("Student类的构造代码块");
        System.out.println("好好学习");
    }

    public Student(){

        System.out.println("空参构造方法...");
    }

    public Student(int num){
        System.out.println("带参构造方法...");
    }

}

六、内部类

1.成员内部类

在类中定义的类

package inner;

public class InnerTest {
    /*
        内部类: 在类中定义的类

        创建对象格式: 外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();

        成员访问细节 :

                    1. 内部类中, 访问外部类成员 : 直接访问, 包括私有
                    2. 外部类中, 访问内部类成员 : 需要创建对象访问
     */
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.num);
        oi.show();

        System.out.println("---------------------");

        MyOuter.MyInner mm = new MyOuter().new MyInner();
        mm.show();
    }
}

class MyOuter {

    int num = 10;

    class MyInner {

        int num = 20;

        public void show(){
            int num = 30;

            System.out.println(num);                            // 30
            System.out.println(this.num);                       // 20
            System.out.println(MyOuter.this.num);               // 10
        }

    }

}

class Outer {

    private void method(){
        System.out.println("method...");

        Inner i = new Inner();
        System.out.println(i.num);
    }

    class Inner {
        int num = 10;

        public void show(){
            System.out.println("show...");
            method();
        }
    }

}

2.静态内部类

static 修饰的成员内部类

package inner;

public class StaticInnerTest {
    /*
        静态内部类 : static 修饰的成员内部类

        创建对象格式 : 外部类名.内部类名 对象名 = new 外部类名.内部类对象();

        注意事项 : 静态只能访问静态
     */
    public static void main(String[] args) {
        OuterClass.InnerClass.show();
    }
}

class OuterClass {

    int num1 = 10;
    static int num2 = 20;

    static class InnerClass {

        public static void show(){
            System.out.println("show...");

            OuterClass o = new OuterClass();
            System.out.println(o.num1);

            System.out.println(num2);
        }

    }

}

3.局部内部类

package inner;

public class LocalClassTest {
    /*
        局部内部类: 放在方法、代码块、构造器等执行体中
     */
    public static void main(String[] args) {
        A a = new A();
        a.show();
    }
}

class A {

    public void show(){

        class B {
            public void method(){
                System.out.println("method...");
            }
        }

        B b = new B();
        b.method();

    }

}

4.匿名内部类

package inner;

public class AnonClassTest1 {
    /*
        匿名内部类 :

            概述 : 匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
            前提 : 需要存在一个接口或类
            格式 :
                    new 类名\接口名 () {

                    }

                    new 类名(){}  : 代表继承这个类
                    new 接口名(){} : 代表实现这个接口

            结论 : 可以让代码变得更加简洁, 在定义类的时候对其进行实例化
     */
    public static void main(String[] args) {

        // 问题: 方法的形参是接口类型, 我们该传入的是什么?
        // 答案: 传入的是该接口的实现类对象
        useInter(new InterImpl());

        useInter(new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类...show...");
            }
        });

    }

    public static void useInter(Inter i){   // Inter i = new InterImpl();
        i.show();
    }
}

interface Inter {
    void show();
}

class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("InterImpl...show...");
    }
}

七、lambda表达式

1.简化匿名内部类的代码写法

package lambda;

public class LambdaDemo1 {
    /*
         Lambda表达式 : JDK8开始后的一种新语法形式

            作用 : 简化匿名内部类的代码写法。
            格式 : () -> {}

                     () : 匿名内部类被重写方法的形参列表
                     {} : 被重写方法的方法体代码

     */
    public static void main(String[] args) {

        useInterA(new InterA() {
            @Override
            public void show() {
                System.out.println("匿名内部类, 重写后的show方法...");
            }
        });

        System.out.println("--------------------");

        useInterA(() -> {
            System.out.println("匿名内部类, 重写后的show方法...");
        });

    }

    public static void useInterA(InterA a) {
        a.show();
    }
}

interface InterA {
    void show();
}

反例：( Lambda表达式, 只允许操作函数式编程接口 : 有, 且仅有一个抽象方法的接口)

package lambda;

public class LambdaDemo2 {
    /*
        Lambda表达式, 只允许操作函数式编程接口 : 有, 且仅有一个抽象方法的接口
     */
    public static void main(String[] args) {

        useInterB(new InterB() {
            @Override
            public void show1() {
                System.out.println("匿名内部类...show1...");
            }

            @Override
            public void show2() {
                System.out.println("匿名内部类...show2...");
            }
        });

        System.out.println("-----------------------");

        // useInterB( () -> {} ); // 不能这样写

    }

    public static void useInterB(InterB b) {
        b.show1();
        b.show2();
    }
}

// @FunctionalInterface 验证是否为函数式接口
interface InterB {
    void show1();
    void show2();
}

2.Lambda表达式的省略写法

规定：

** 在这里插入图片描述
**

2.1 无参数，只有一条代码逻辑

package lambda.test;

public class LambdaTest1 {
    public static void main(String[] args) {

        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类, 重写后的show方法...");
            }
        });

        System.out.println("-----------------------");

        useShowHandler(() -> System.out.println("Lambda表达式, 重写后的show方法..."));

    }

    public static void useShowHandler(ShowHandler showHandler) {
        showHandler.show();
    }

}

interface ShowHandler {
    void show();
}

2.2 一个参数，只有一条代码逻辑

package lambda.test;

public class LambdaTest2 {
    public static void main(String[] args) {

        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("匿名内部类打印:" + msg);
            }
        });
        System.out.println("---------------------");

        useStringHandler(msg -> System.out.println("Lambda打印:" + msg));

    }

    public static void useStringHandler(StringHandler stringHandler) {

        stringHandler.printMessage("itheima");
    }
}

interface StringHandler {
    void printMessage(String msg);
}

2.3 无参数，代码逻辑为一条：return语句

package lambda.test;

import java.util.Random;

public class LambdaTest3 {
    public static void main(String[] args) {

        useRandomNumHandler(new RandomNumHandler() {
            @Override
            public int getNumber() {
                return new Random().nextInt(100) + 1;
            }
        });

        System.out.println("-----------------------");

        useRandomNumHandler(() -> new Random().nextInt(100) + 1);

    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
        // RandomNumHandler randomNumHandler = new RandomNumHandler() {
        //            @Override
        //            public int getNumber() {
        //                Random r = new Random();
        //                int num = r.nextInt(100) + 1;
        //                return num;
        //            }
        //        }
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}

interface RandomNumHandler {
    int getNumber();
}

2.4 链各个参数，代码逻辑为一条：return语句

package lambda.test;

public class LambdaTest4 {
    public static void main(String[] args) {

        useCalculator((a, b) -> a + b);

        System.out.println("---------------------------");

        useCalculator((a, b) -> a - b);

    }

    public static void useCalculator(Calculator calculator) {
        // Calculator calculator = new Calculator() {
        //            @Override
        //            public int calc(int a, int b) {
        //                return a + b;
        //            }
        //        }
        int result = calculator.calc(10, 20);
        System.out.println(result);
    }

}

interface Calculator {
    int calc(int a, int b);
}

小节：匿名内部类和Lambda的对比

在这里插入图片描述

八、注解

1. 元注解

1.1 @Target

TYPE：类、接口（包括注解类型）或枚举声明。
FIELD：字段声明（包括枚举常量）。
METHOD：方法声明。
PARAMETER：参数声明。
CONSTRUCTOR：构造函数声明。
LOCAL_VARIABLE：局部变量声明。
ANNOTATION_TYPE：注解类型声明。
PACKAGE：包声明。
TYPE_PARAMETER：类型参数声明。
TYPE_USE：任何类型使用的地方。

1.2 @Retention

SOURCE：注解将被编译器丢弃，不会包含在编译后的 class 文件中。
CLASS：注解将被编译器记录在编译后的 class 文件中，但在运行时不会被虚拟机保留，默认的保留策略。
RUNTIME：注解将被编译器记录在编译后的 class 文件中，并在运行时由虚拟机保留，以便可以通过反射机制读取。

2.自定义注解

2.1 基于spring容器

示例

@Target(ElementType.TYPE) 作用在类上

@Retention(RetentionPolicy.RUNTIME) 运行时保留

package test1;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


//注解的保留策略
@Retention(RetentionPolicy.RUNTIME)
//用于指定注解可以应用的目标元素类型
@Target(ElementType.TYPE)
//使用 @interface 关键字创建自定义的注解类型
public @interface MyAnnotationClass {

    String name() default "";

}

@Target(ElementType.METHOD) 作用在方法上

@Retention(RetentionPolicy.RUNTIME) 运行时保留

package test1;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//注解的保留策略
@Retention(RetentionPolicy.RUNTIME)
//用于指定注解可以应用的目标元素类型
@Target(ElementType.METHOD)
//使用 @interface 关键字创建自定义的注解类型
public @interface MyAnnotationMethod {

    String name() default "";

}

package test1;


@MyAnnotationClass(name = "hahha")
public class MyClass {




    @MyAnnotationMethod(name = "Hello")
    public void myMethod() {
        System.out.println("Hello, World!");
    }

    //    @MyAnnotationMethod(name = "Hello1")
    public void myMethod1() {
        System.out.println("Hello, World!");
    }
}

2.2 基于spring工具包

package test1;


import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.AnnotationTypeFilter;

import java.lang.reflect.Method;
import java.util.Set;


public class NotSpring {

    //不基于spring 容器
    //基于spring工具包 扫描
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //创建一个spring的扫描组件， true为懒加载
        ClassPathScanningCandidateComponentProvider classPathScanningCandidateComponentProvider = new ClassPathScanningCandidateComponentProvider(false);
        //扫描自定义的注解类 过滤器
        classPathScanningCandidateComponentProvider.addIncludeFilter(new AnnotationTypeFilter(MyAnnotationClass.class));

        //使用 Spring 的类路径扫描器 ClassPathScanningCandidateComponentProvider 来查找指定包下的 Bean 定义，并将其保存在一个 Set<BeanDefinition> 集合中
        Set<BeanDefinition> beanDefinitions = classPathScanningCandidateComponentProvider.findCandidateComponents("com.cqgcxy.test1");

        //for循环遍历路径下有 @MyAnnotationClass 注解的类
        for (BeanDefinition beanDefinition : beanDefinitions) {
            //使用BeanDefinition类的getBeanClassName 获取bean定义的类名
            String beanClassName = beanDefinition.getBeanClassName();
            //通过反射API的Class类的forName方法，通过类名获取对应的 Class 对象
            Class<?> clazz = Class.forName(beanClassName);
            //通过getMethods方法 返回该类上声明的所有方法（包括公共、保护、默认和私有）的列表。
            Method[] methods = clazz.getMethods();
            //for循环遍历当前类的所有方法
            for (Method method : methods) {
                /*使用AccessibleObject类中的isAnnotationPresent()方法
                来判断一个方法是否被标注了 MyAnnotationMethod 注解*/
                if (method.isAnnotationPresent(MyAnnotationMethod.class)) {
                    //使用 getAnnotation() 方法来获取一个方法上的 MyAnnotationMethod 注解实例（对象）
                    MyAnnotationMethod annotation = method.getAnnotation(MyAnnotationMethod.class);
                    System.out.println("方法: " + method.getName() + " 上的注解值为：" + annotation.name());
                }
            }
        }


    }


}

九、动态代理

示例：

1.需代理类

public class BigStar implements Star {

    private String name;


    public BigStar(String name) {
        this.name = name;
    }

    // 唱歌 跳舞
    @Override
    public String sing(String name) {
        System.out.println(this.name + "正在唱" + name);
        return "谢谢";
    }

    @Override
    public void dence() {
        System.out.println(this.name + "正在跳舞");
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

2.需代理类接口

public interface Star {
    public abstract String sing(String name);

    public abstract void dence();
}

3.代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @projectName: studyDemo
 * @package: PACKAGE_NAME
 * @className: ProxyUtil
 * @author: Qing
 * @description: TODO
 * @date: 2024/3/14 16:05
 * @version: 1.0
 */

/*
 *  类的作用：
 *          创建一个代理
 */
public class ProxyUtil {

    /*
     * 方法的作用：
     *      给一个明星的对象，创建代理
     *
     * 形参：
     *      被代理的明星对象
     *
     * 返回值：
     *       给明星创建的代理
     *
     *
     * */


    public static Star createProxy(BigStar bigStar) {
        /*
         *   java.lang.reflect.Proxy类： 提供了为对象产生代理对象的方法：
         *   public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
         *   参数一： 用于指定用那个类加载器，去加载生产的代理类
         *   参数二： 指定接口，这些接口用于指定生成的代理长什么样（有哪些方法）
         *   参数三： 用来指定生成的代理对象要干什么事情
         * */

        Star star = (Star) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        /*
                         * 参数一：代理的对象
                         * 参数二：要运行的方法
                         * 参数三：方法的参数
                         * */
                        if ("sing".equals(method.getName())) {
                            System.out.println("准备话筒，收钱");
                        } else if ("dance".equals(method.getName())) {
                            System.out.println("准备场地，收钱");
                        }
                        return method.invoke(bigStar, args);
                    }
                });
        return star;
    }
}

十、反射

反射允许对封装类的字段、方法和构造函数的信息进行编程访问

1.获取class(字节码文件)对象的三种方式

在这里插入图片描述

示例：

被反射的类：

package test;

/**
 * @projectName: studyDemo
 * @package: test
 * @className: Student
 * @author: Qing
 * @description: TODO
 * @date: 2024/3/14 16:51
 * @version: 1.0
 */
public class Student {


    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

反射方法：

package test;

public class MyReflectDemo {
    /*
    * 获取class对象的三种方式
    *   1.Class.forName("类的全限定名（全类名）")
    *   2.类名.class
    *   3.对象.getClass();
    * */

    public static void main(String[] args) throws ClassNotFoundException {

        // 1. 第一种方式
        // 全类名： 包名 + 类名
        // 最为常用的
        Class clazz1 = Class.forName("test.Student");

        // 2. 第二种方式
        // 一般更多的是当做参数进行传递
        Class clazz2 = Student.class;

        // 3. 第三种方式
        Student student = new Student();
        Class clazz3 = student.getClass();

        System.out.println(clazz1 == clazz2); // true
        System.out.println(clazz2 == clazz3); // true
    }
}

2.获取构造方法

方法名	说明
Constructor<?>[] getConstructors()	获得所有的构造（只能public修饰）
Constructor<?>[] getDeclaredConstructors()	获得所有的构造（包含private修饰）
Constructor getConstructor(Class<?>… parameterTypes)	获取指定构造（只能public修饰）
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	获取指定构造（包含private修饰）

代码示例:

package test2;


public class Student {

    private String name;
    private int age;

    public  Student () {

    }

    public  Student (String name) {
        this.name = name;
    }

    protected   Student (int age) {
        this.age = age;
    }

    private  Student (String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package test2;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class MyReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    /*
        Class类中用于获取构造方法的方法
            Constructor<?>[] getConstructors()                                返回所有公共构造方法对象的数组
            Constructor<?>[] getDeclaredConstructors()                        返回所有构造方法对象的数组
            Constructor<T> getConstructor(Class<?>... parameterTypes)         返回单个公共构造方法对象
            Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回单个构造方法对象


        Constructor类中用于创建对象的方法
            T newInstance(Object... initargs)                                 根据指定的构造方法创建对象
            setAccessible(boolean flag)                                       设置为true,表示取消访问检查
    */

        //1.获取class字节码文件对象
        Class clazz = Class.forName("com.itheima.myreflect2.Student");

        //2.获取构造方法
       /* Constructor[] cons1 = clazz.getConstructors();
        for (Constructor con : cons1) {
            System.out.println(con);
        }
        Constructor[] cons2 = clazz.getDeclaredConstructors();
        for (Constructor con : cons2) {
            System.out.println(con);
        }*/


       /* Constructor con1 = clazz.getDeclaredConstructor();
        System.out.println(con1);

        Constructor con2 = clazz.getDeclaredConstructor(String.class);
        System.out.println(con2);

        Constructor con3 = clazz.getDeclaredConstructor(int.class);
        System.out.println(con3);*/

        Constructor con4 = clazz.getDeclaredConstructor(String.class,int.class);
/*
        int modifiers = con4.getModifiers();
        System.out.println(modifiers);


        Parameter[] parameters = con4.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }*/

        //暴力反射：表示临时取消权限校验
        con4.setAccessible(true);
        Student stu = (Student) con4.newInstance("张三", 23);

        System.out.println(stu);


    }
}

在这里插入图片描述

3.获取构造方法并创建对象

涉及到的方法：newInstance

代码示例：

//首先要有一个javabean类
public class Student {
    private String name;

    private int age;


    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}



//测试类中的代码：
//需求1：
//获取空参，并创建对象

//1.获取整体的字节码文件对象
Class clazz = Class.forName("com.itheima.a02reflectdemo1.Student");
//2.获取空参的构造方法
Constructor con = clazz.getConstructor();
//3.利用空参构造方法创建对象
Student stu = (Student) con.newInstance();
System.out.println(stu);


System.out.println("=============================================");


//测试类中的代码：
//需求2：
//获取带参构造，并创建对象
//1.获取整体的字节码文件对象
Class clazz = Class.forName("com.itheima.a02reflectdemo1.Student");
//2.获取有参构造方法
Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
//3.临时修改构造方法的访问权限（暴力反射）
con.setAccessible(true);
//4.直接创建对象
Student stu = (Student) con.newInstance("zhangsan", 23);
System.out.println(stu);

4.获取成员变量

规则：

get表示获取

Declared表示私有

最后的s表示所有，复数形式

如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

方法名：

方法名	说明
Field[] getFields()	返回所有成员变量对象的数组（只能拿public的）
Field[] getDeclaredFields()	返回所有成员变量对象的数组，存在就能拿到
Field getField(String name)	返回单个成员变量对象（只能拿public的）
Field getDeclaredField(String name)	返回单个成员变量对象，存在就能拿到

代码示例：

public class ReflectDemo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //获取成员变量对象

        //1.获取class对象
        Class clazz = Class.forName("com.itheima.reflectdemo.Student");

        //2.获取成员变量的对象（Field对象)只能获取public修饰的
        Field[] fields1 = clazz.getFields();
        for (Field field : fields1) {
            System.out.println(field);
        }

        System.out.println("===============================");

        //获取成员变量的对象（public + private）
        Field[] fields2 = clazz.getDeclaredFields();
        for (Field field : fields2) {
            System.out.println(field);
        }

        System.out.println("===============================");
        //获得单个成员变量对象
        //如果获取的属性是不存在的，那么会报异常
        //Field field3 = clazz.getField("aaa");
        //System.out.println(field3);//NoSuchFieldException

        Field field4 = clazz.getField("gender");
        System.out.println(field4);

        System.out.println("===============================");
        //获取单个成员变量（私有）
        Field field5 = clazz.getDeclaredField("name");
        System.out.println(field5);

    }
}



public class Student {
    private String name;

    private int age;

    public String gender;

    public String address;


    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }


    public Student(String name, int age, String gender, String address) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + ", address = " + address + "}";
    }
}

5.获取成员变量并获取值和修改值

方法	说明
void set(Object obj, Object value）	赋值
Object get(Object obj)	获取值

代码示例：

public class ReflectDemo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Student s = new Student("zhangsan",23,"广州");
        Student ss = new Student("lisi",24,"北京");

        //需求：
        //利用反射获取成员变量并获取值和修改值

        //1.获取class对象
        Class clazz = Class.forName("com.itheima.reflectdemo.Student");

        //2.获取name成员变量
        //field就表示name这个属性的对象
        Field field = clazz.getDeclaredField("name");
        //临时修饰他的访问权限
        field.setAccessible(true);

        //3.设置(修改)name的值
        //参数一：表示要修改哪个对象的name？
        //参数二：表示要修改为多少？
        field.set(s,"wangwu");

        //3.获取name的值
        //表示我要获取这个对象的name的值
        String result = (String)field.get(s);

        //4.打印结果
        System.out.println(result);

        System.out.println(s);
        System.out.println(ss);

    }
}


public class Student {
    private String name;
    private int age;
    public String gender;
    public String address;


    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }


    public Student(String name, int age, String gender, String address) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + ", address = " + address + "}";
    }
}

6.获取成员方法

规则：

get表示获取

Declared表示私有

最后的s表示所有，复数形式

如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

方法名	说明
Method[] getMethods()	返回所有成员方法对象的数组（只能拿public的）
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，存在就能拿到
Method getMethod(String name, Class<?>… parameterTypes)	返回单个成员方法对象（只能拿public的）
Method getDeclaredMethod(String name, Class<?>… parameterTypes)	返回单个成员方法对象，存在就能拿到

代码示例：

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取class对象
        Class<?> clazz = Class.forName("com.itheima.reflectdemo.Student");


        //2.获取方法
        //getMethods可以获取父类中public修饰的方法
        Method[] methods1 = clazz.getMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

        System.out.println("===========================");
        //获取所有的方法（包含私有）
        //但是只能获取自己类中的方法
        Method[] methods2 = clazz.getDeclaredMethods();
        for (Method method : methods2) {
            System.out.println(method);
        }

        System.out.println("===========================");
        //获取指定的方法（空参）
        Method method3 = clazz.getMethod("sleep");
        System.out.println(method3);

        Method method4 = clazz.getMethod("eat",String.class);
        System.out.println(method4);

        //获取指定的私有方法
        Method method5 = clazz.getDeclaredMethod("playGame");
        System.out.println(method5);
    }
}

7.获取成员方法并运行

方法

Object invoke(Object obj, Object… args) ：运行方法

参数一：用obj对象调用该方法

参数二：调用方法的传递的参数（如果没有就不写）

返回值：方法的返回值（如果没有就不写）

代码示例：

package com.itheima.a02reflectdemo1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.获取字节码文件对象
        Class clazz = Class.forName("com.itheima.a02reflectdemo1.Student");
		
        //2.获取一个对象
        //需要用这个对象去调用方法
        Student s = new Student();
        
        //3.获取一个指定的方法
        //参数一：方法名
        //参数二：参数列表，如果没有可以不写
        Method eatMethod = clazz.getMethod("eat",String.class);
        
        //运行
        //参数一：表示方法的调用对象
        //参数二：方法在运行时需要的实际参数
        //注意点：如果方法有返回值，那么需要接收invoke的结果
        //如果方法没有返回值，则不需要接收
        String result = (String) eatMethod.invoke(s, "重庆小面");
        System.out.println(result);

    }
}



public class Student {
    private String name;
    private int age;
    public String gender;
    public String address;


    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    private void study(){
        System.out.println("学生在学习");
    }

    private void sleep(){
        System.out.println("学生在睡觉");
    }

    public String eat(String something){
        System.out.println("学生在吃" + something);
        return "学生已经吃完了，非常happy";
    }
}

zz.getMethod(“eat”,String.class);
System.out.println(method4);

    //获取指定的私有方法
    Method method5 = clazz.getDeclaredMethod("playGame");
    System.out.println(method5);
}

}


### 7.获取成员方法并运行

方法

 Object invoke(Object obj, Object... args) ：运行方法

参数一：用obj对象调用该方法

参数二：调用方法的传递的参数（如果没有就不写）

返回值：方法的返回值（如果没有就不写）

代码示例：

```java
package com.itheima.a02reflectdemo1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.获取字节码文件对象
        Class clazz = Class.forName("com.itheima.a02reflectdemo1.Student");
		
        //2.获取一个对象
        //需要用这个对象去调用方法
        Student s = new Student();
        
        //3.获取一个指定的方法
        //参数一：方法名
        //参数二：参数列表，如果没有可以不写
        Method eatMethod = clazz.getMethod("eat",String.class);
        
        //运行
        //参数一：表示方法的调用对象
        //参数二：方法在运行时需要的实际参数
        //注意点：如果方法有返回值，那么需要接收invoke的结果
        //如果方法没有返回值，则不需要接收
        String result = (String) eatMethod.invoke(s, "重庆小面");
        System.out.println(result);

    }
}



public class Student {
    private String name;
    private int age;
    public String gender;
    public String address;


    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    private void study(){
        System.out.println("学生在学习");
    }

    private void sleep(){
        System.out.println("学生在睡觉");
    }

    public String eat(String something){
        System.out.println("学生在吃" + something);
        return "学生已经吃完了，非常happy";
    }
}

学习在路上ing

关注

14
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
logback.xml、抽象类、接口、多态、代码块、内部类、Lambda表达式、注解、动态代理、反射

第三周笔记一、logback.xml引入依赖(包含有logging依赖) <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>1.logback的日志级别Logger有五个日
复制链接

扫一扫