第三周笔记
一、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";
}
}