Java反射机制

最新推荐文章于 2023-06-22 19:54:38 发布
最新推荐文章于 2023-06-22 19:54:38 发布
阅读量52 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51072735/article/details/118360267
版权

文章目录

概述

  • 反射机制的作用
    通过java语言的反射机制可以操作字节码文件(.class)
  • 相关的类
    java.lang.Class 代表整个类的字节码
    java.lang.reflect.Method 代表类中方法的字节码
    java.lang.reflect.Constructor 代表类中构造方法的字节码
    java.lang.reflect.Field 代表类中属性的字节码

获取class的三种方式

要操作类的字节码，首先要获取到类的字节码

  1. Class.forName(String className)
    Class类中的静态方法
    返回一个Class对象
    className是完整的类名带上包名
    forName在获取类时会运行类中的静态代码块
package com.wcy.code01;

/**
 * Class.forName获取类
 */
public class GetClassTest01 {
    public static void main(String[] args) {
        Class<?> c1 = null;
        Class<?> c2 = null;
        try {
        	//完整的类名加上包名
            c1 = Class.forName("com.wcy.code01.GetClassTest01");
            c2 = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c1);
        System.out.println(c2);
    }
}

在这里插入图片描述

  1. obj.getClass()
    通过对象来获取类
package com.wcy.code01;
import java.util.Date;

/**
 1. obj.getClass()获取类
 */
public class GetClassTest02 {
    public static void main(String[] args) {
        String s = new String(new char[]{'1', '2', '3'});
        Date d = new Date();
        Class<?> sc = s.getClass();
        Class<?> ds = d.getClass();
        System.out.println(sc);
        System.out.println(ds);
    }
}

在这里插入图片描述

  1. 类型使用class属性
    Java中无论什么类型都有class属性
package com.wcy.code01;

/**
 * 通过class属性来获取类
 */
public class GetClassTest03 {
    public static void main(String[] args) {
        Class<String> c1 = String.class;
        Class<Integer> c2 = int.class;
        Class<GetClassTest03> c3 = GetClassTest03.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}
  1. 以上三种方式获取的类是一样的
    因为只会加载一个类在方法区中，无论通过何种方式获取，获取的都是同样的结果
package com.wcy.code01;

/**
 * 三种方法获取的类是一样的
 */
public class GetClassTest04 {
    public static void main(String[] args) {
        String s = "111";
        Class<?> c1 = null;
        Class<?> c2 = null;
        Class<?> c3 = null;

        try {
            c1 = Class.forName("java.lang.String");
            c2 = s.getClass();
            c3 = String.class;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println(c1 == c2 && c2 == c3 && c1 == c3);

    }
}

在这里插入图片描述

通过反射机制实例化对象

  • newInstance() jdk8后弃用
  • 调用该方法会调用类中的无参构造方法来实例化对象
package com.wcy.code01;

public class NewInstanceTest01 {
    public static void main(String[] args) {
        try {
            Class<?> c1 = Class.forName("com.wcy.code01.User");

            //使用newInstance实例化对象
            Object o = c1.newInstance();
            System.out.println(o);
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}


class User {
    public User() {
        System.out.println("调用了无参构造方法！");
    }

}

在这里插入图片描述

使用反射机制实现使用配置文件实例化对象

通过读取配置文件中的内容来实例化对象，这样可以不用更改代码就可以实例化不同的对象。

配置文件中的内容

# 需要实例化的类 只需要更改此处的类名即可
classname=com.wcy.code01.User

package com.wcy.code01;

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * 使用配置文件实例化对象
 */
public class NewInstanceTest02 {
    public static void main(String[] args) {
        FileReader fileReader = null;
        Properties properties = null;
        try {
            //字符流读取配置文件
            fileReader = new FileReader("src/name.properties");
            //创建属性类对象map
            properties = new Properties();
            //加载配置文件
            properties.load(fileReader);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭配置文件读取
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (properties != null) {
            //获取配置文件中的类名
            String className = properties.getProperty("classname");
            try {
                //获取类名实例化对象
                Class<?> c = Class.forName(className);
                Object o = c.newInstance();
                System.out.println(o);
            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

反射机制获取属性

  • 基本方法
Field getField(String name)返回一个 Field对象，它反映此表示的类或接口的指定公共成员字段 类对象。
Field[] getFields()返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段 类对象。
Field getDeclaredField(String name)返回一个 Field对象，它反映此表示的类或接口的指定已声明字段和类对象。
Field[] getDeclaredFields()返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。
package com.wcy.code02;


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 反射机制获取属性
 */
public class ReflectField {
    public static void main(String[] args) throws Exception {
        Class<?> s = Class.forName("com.wcy.code02.User");
        //获取类中的所有public属性
        Field[] fields = s.getFields();
        System.out.println("属性个数" + fields.length);

        //获取名字
        System.out.println("属性信息：" + fields[0].getName());

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

        //获取所有的属性
        Field[] declaredFields = s.getDeclaredFields();
        System.out.println("属性个数" + declaredFields.length);
        for (Field field : declaredFields) {
            //获取属性类型
            Class<?> type = field.getType();
            String typeSimpleName = type.getSimpleName();
            //获取名字
            String fieldName = field.getName();
            //获取修饰符列表 返回的数字 需要转换
            int modifiers = field.getModifiers();
            //将数字代表的修饰符转换为字符串
            String modifiersString = Modifier.toString(modifiers);
            //打印所有的信息
            System.out.println(
                    "属性信息：" + typeSimpleName + "-->" + fieldName + "-->" + modifiersString
            );
        }
    }
}

在这里插入图片描述

通过反射机制还原java代码

  • 通过类名来获取属性，并还原java代码
package com.wcy.code02;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 通过反射机制来获取类中的属性
 * 并将反编译成标准的java代码
 */
public class ReflectField01 {
    public static void main(String[] args) throws Exception{
        //获取类
        Class<?> c = Class.forName("com.wcy.code02.User");
        //拼接字符串
        StringBuilder stringBuilder = new StringBuilder();
        //获取所有字段
        Field[] declaredFields = c.getDeclaredFields();

        //拼接类修饰符，类名，大括号
        stringBuilder.append(Modifier.toString(c.getModifiers()));
        stringBuilder.append(" class ");stringBuilder.append(c.getSimpleName());
        stringBuilder.append(" {\n");

        //拼接字段名
        for(Field field:declaredFields){
            stringBuilder.append("\t");
            stringBuilder.append(Modifier.toString(field.getModifiers()));

            //没有修饰符就不加空格
            if(!Modifier.toString(field.getModifiers()).equals("")) {
                stringBuilder.append(" ");
            }
            stringBuilder.append(field.getType().getSimpleName());
            stringBuilder.append(" ");
            stringBuilder.append(field.getName());
            stringBuilder.append(";\n");
        }

        //最后的大括号
        stringBuilder.append("}");
        System.out.println(stringBuilder);

    }
}

在这里插入图片描述
获取String中的字段
在这里插入图片描述

反射机制操作属性

  • 赋值和获取值
  • field.set() field.get()
package com.wcy.code02;

import java.lang.reflect.Field;

/**
 * 通过反射来操作属性
 * 赋值
 * 获取值
 */
public class ReflectField02 {
    public static void main(String[] args) throws  Exception{
        Class<?> c = Class.forName("com.wcy.code02.User");
        //实例化一个对象
        Object o = c.newInstance();

        //首先获取属性 通过名称获取
        Field no = c.getDeclaredField("no");

        //设置值
        //给o对象的no属性设置值
        no.set(o, 10086);

        //获取值
        //获取o对象的no值
        System.out.println(no.get(o));

    }
}

class User {
    public int no;
    private String name;
    protected int age;
    boolean sex;
    public static final double PI = 3.1415926;
}

反射机制操作私有属性

用上面的方法还不能操作私有的属性会报错
Class com.wcy.code02.ReflectField02 can not access a member of class com.wcy.code02.User with modifiers "private"
需要设置field.setAccessible(true);才可以操作私有属性

package com.wcy.code02;

import java.lang.reflect.Field;

/**
 * 通过反射来操作属性
 * 赋值
 * 获取值
 */
public class ReflectField02 {
    public static void main(String[] args) throws  Exception{
        Class<?> c = Class.forName("com.wcy.code02.User");
        //实例化一个对象
        Object o = c.newInstance();

        //首先获取属性 通过名称获取
        Field no = c.getDeclaredField("no");
        //获取私有属性
        Field name = c.getDeclaredField("name");

        //设置值
        //给o对象的no属性设置值
        no.set(o, 10086);

        //要更改私有属性的值必须设置
        name.setAccessible(true);
        name.set(o, "wcy");

        //获取值
        //获取o对象的no值
        System.out.println(no.get(o));
        System.out.println(name.get(o));

    }
}

反射机制操作方法

获取方法相关的信息

  • 一系列get方法 见名知意 和获取属性基本一样
package com.wcy.code03;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;

/** 反射 method
 * 获取class中method的信息
 */
public class ReflectMethod01 {
    public static void main(String[] args) throws Exception{
        Class<?> c = Class.forName("com.wcy.code03.UserService");
        Method[] methods = c.getDeclaredMethods();
        //拼接字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (Method method: methods){
            //获取修饰符
            String modifier = Modifier.toString(method.getModifiers());
            stringBuilder.append(modifier);
            stringBuilder.append(" ");
            //获取返回值类型
            String returnType = method.getReturnType().getSimpleName();
            stringBuilder.append(returnType);
            stringBuilder.append(" ");
            //获取方法名称
            String methodName = method.getName();
            stringBuilder.append(methodName);
            stringBuilder.append("(");
            //获取参数类型列表
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter: parameters) {
                //参数类型
                String typeName = parameter.getType().getSimpleName();
                stringBuilder.append(typeName);
                stringBuilder.append(" ");
                //参数名称 获取不到真的名字 arg0 arg1...
                String name = parameter.getName();
                stringBuilder.append(name);
                stringBuilder.append(",");
            }
            //去除空格
            if(stringBuilder.charAt(stringBuilder.length()-1)==','){
                stringBuilder.deleteCharAt(stringBuilder.length()-1);
            }
            stringBuilder.append(")\n");
        }
        System.out.println(stringBuilder);

    }
}

/**
 * 模拟登陆注销功能
 */
class UserService{
    /**
     * 模拟登陆方法
     * @param name:用户名
     * @param password:密码
     * @return 是否登陆成功
     */
    public boolean login(String name, String password){
        return name.equals("wcy") && password.equals("123");
    }

    public void logout(){
        System.out.println("退出登陆成功！");
    }

}

在这里插入图片描述

反射机制调用方法

  • public Object invoke(Object obj, Object… args)
  • 获取方法后通过调用invoke来调用
package com.wcy.code03;

import java.lang.reflect.Method;

/**
 * 反射机制调用方法 ！重要
 * 调用方法的四要素
 *      1.对象
 *      2.方法名
 *      3.参数
 *      4.返回值
 *  无论是普通调用还是反射机制调用都是需要的四要素
 *
 *  可变长参数补充：
 *      type... args
 *      -可变长参数
 *      -必须放在参数列表的最后
 *          public void login(int i, String... args){}
 *      - 传入多个参数会变成一个数组
 *      - 也可以直接传入一个对应类型的数组
 */
public class ReflectMethod02 {
    public static void main(String[] args) throws Exception{
        //普通调用
        UserService userService = new UserService();
        boolean isLogin = userService.login("wcy", "123");
        System.out.println(isLogin);

        //反射调用
        // 1 获取类实例对象
        Class<?> c = Class.forName("com.wcy.code03.UserService");
        Object o = c.newInstance();
        // 2 获取方法 获取的方法参数类型必须一致
        // java支持方法重载 所以方法名可能重复 需要用参数类型来限制
        Method login = c.getMethod("login", String.class, String.class);
        // 3 传参调用 获取返回值 通过invoke调用
        Object isLogin1 = login.invoke(o, "wcy", "123");
        System.out.println(isLogin1);
    }
}



/**
 * 模拟登陆注销功能
 */
class UserService{
    /**
     * 模拟登陆方法
     * @param name:用户名
     * @param password:密码
     * @return 是否登陆成功
     */
    public boolean login(String name, String password){
        return name.equals("wcy") && password.equals("123");
    }

    public void logout(){
        System.out.println("退出登陆成功！");
    }

}

在这里插入图片描述
通过反射机制，极大的降低了代码的耦合性，所有需要操作的逻辑，一次书写无需改变，只需将需要改变的部分添加到配置文件中，通过资源读取即可。

反射机制操作构造函数

获取构造方法的相关信息

  • 和前面大同小异
package com.wcy.code04;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;

/**
 * 获取构造方法
 */
public class ReflectConstructor01 {
    public static void main(String[] args) throws Exception{
        Class<?> c = Class.forName("com.wcy.code04.Student");
        Constructor<?>[] constructors = c.getDeclaredConstructors();
        for (Constructor<?> constructor: constructors){
            //修饰符
            String modifiers = Modifier.toString(constructor.getModifiers());
            System.out.println(modifiers);
            //参数列表
            Parameter[] parameters = constructor.getParameters();
            for(Parameter parameter:parameters){
                //获取类型
                String type = parameter.getType().getSimpleName();
                System.out.println(type);

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

    }
}

class Student{
    int no;
    String name;
    boolean sex;
    int age;

    public Student() {
    }

    public Student(int no) {
        this.no = no;
    }

    public Student(int no, String name, boolean sex) {
        this.no = no;
        this.name = name;
        this.sex = sex;
    }

    public Student(int no, String name, boolean sex, int age) {
        this.no = no;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

通过构造方法实例化对象

package com.wcy.code04;


import java.lang.reflect.Constructor;

/**
 * 通过构造方法来实例化对象
 * 前面实例化对象都是通过obj.newInstance()来实例化
 * 现在通过构造方法来实例化
 */
public class ReflectConstructor02 {
    public static void main(String[] args) throws Exception{
        Class<?> c = Class.forName("com.wcy.code04.Student");

        // 通过obj.newInstance()来实例化
        // 这样会默认自动调用无参构造方法来实例化一个对象
        Object o1 = c.newInstance();
        System.out.println(o1);

        //通过构造方法来实例化
        //4参数的构造方法 通过参数类型来选取
        Constructor<?> constructor1 = c.getDeclaredConstructor(int.class, String.class, boolean.class, int.class);
        //还是通过newInstance()方法实例化，参数就是需要初始化的参数
        Object o2 = constructor1.newInstance(10086, "wcy", true, 20);
        System.out.println(o2);

        //1个参数构造方法
        Constructor<?> constructor2 = c.getDeclaredConstructor(int.class);
        Object o3 = constructor2.newInstance(10000);
        System.out.println(o3);

        //无参构造
        Constructor<?> constructor3 = c.getDeclaredConstructor();
        Object o4 = constructor3.newInstance();
        System.out.println(o4);
    }
}

在这里插入图片描述

通过反射机制获取父类相关信息

package com.wcy.code04;

/**
 * 获取父类
 * 只要获取到了父类
 * 就可以用之前的方法获取属性方法等
 */
public class ReflectSuper01 {
    public static void main(String[] args) throws Exception{
        Class<?> c = Class.forName("java.lang.reflect.Method");
        //获取父类
        Class<?> superclass = c.getSuperclass();

        //名称
        String name = superclass.getName();
        System.out.println(name);

        //获取该类实现的接口
        //Class<?>[] interfaces1 = c.getInterfaces();

        //父类实现的接口
        Class<?>[] interfaces = superclass.getInterfaces();
        for (Class<?> in : interfaces) {
            String name1 = in.getName();
            System.out.println(name1);
        }
    }
}
即将秃头的小老弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java反射机制原理
Palpitate_fx的博客
06-19 929
Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。第一种是从reflectionData直接取，reflectionData是弱引
java反射机制原理详解
m0_56863607的博客
03-01 654
java 反射
Java反射02 : Class对象获取的三种方式和通过反射实例化对象的两种方式
韩超的博客 (hanchao5272)
02-24 6242
[超级通道 : Java反射学习系列-绪论] 1.Class对象获取的三种方式 上一章节已经说过，一般情况下，Java反射操作都需要首先获取Class对象。获取Class对象的方式有三种。 公有属性class 方法getClass() Class.forName() 下面是示例代码： /** * &lt;p&gt;Title: Java获取Class对象的三种方式&lt;/...
Java 反射机制
lucky_fd的博客
04-30 1950
Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象 (一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
Java基础篇：反射机制详解
热门推荐
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java反射机制详解
最新发布
让优秀成为一种习惯！
06-22 2893
Java反射是指在运行时动态地获取和操作类的信息以及调用对象的方法和属性，而不需要在编译期间知道类名或者其成员变量和方法具体等的信息。通过Java反射机制，可以实现动态创建对象、调用对象的方法、修改对象的属性值等操作，这为程序的灵活性和扩展性提供了很大的便利。
Java反射机制及其作用
weixin_42416780的博客
10-13 1344
反射 1、反射的基本概念 反射库是一个提供了一系列丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序，能够分析类能力的程序称之为反射（reflection）。 通过反射能够将Java类中各个部分映射成为一个个Java对象，比如构造器、成员变量、方法。 2、反射的作用 Ⅰ. 反射最重要的用途就是开发各种通用框架，反射机制能够具有在运行时分析类的能力、在运行时查看对象。 Ⅱ. 反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。 Ⅲ. 当
Java反射机制练习题
该博主太懒了，简介都不写
03-16 1213
使用反射可以获取私有属性和方法。但是需要注意，如果类中的私有属性或方法被定义为私有final的话，是无法通过反射来修改其值或调用其方法的。
Java 反射机制快速入门及常见方法全归纳。
yzh2776680982的博客
08-21 3008
▶Class也是类，因此也继承Object类▶Class类对象不是new出来的，而是系统创建的▶对于某个类的Class类对象,在内存中只有一份。因为类只加载一次▶每个类的实例都会记得自己是由哪个Class实例所生成▶通过Class对象可以完整地得到一个类的完整结构，通过一系列API▶Class对象是存放在堆的▶类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码，变量名，方法名，访问权限等等）▶常见方法▶代码示例▶基本概念。...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
java 反射机制
08-31
本文将深入探讨Java反射机制，并结合给出的代码示例进行解析。 首先，我们来看如何通过反射获取类的基本信息。在代码中，`Class.forName("reflection.User")` 是用来加载名为 `User` 的类，返回一个 `Class` 对象。...
JAVA反射机制实例教程
09-04
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以访问和修改私有成员，调用私有方法，创建对象，以及对类、接口、字段和方法进行操作，极大地...
Java反射机制用法总结
08-25
Java反射机制是Java语言提供的一种强大的工具，它允许程序在运行时动态地获取类的信息并进行操作。在Java中，每个类都是一个`java.lang.Class`的实例，这使得我们能够在运行时检查类的结构，包括其属性、方法和构造...
JavaWeb
wcy的博客
12-02 789
文章目录JavaWeb 的概念什么是 JavaWeb什么是请求什么是响应请求和响应的关系Web 资源的分类TomCat服务器常用的 Web 服务器Tomcat 服务器和 Servlet 版本的对应关系Tomcat 的使用安装目录介绍启动 Tomcat 服务器常见的启动失败的情况有另一种启动 tomcat 服务器的方式Tomcat 的停止如何修改 Tomcat 的端口号如何部暑 web 工程到 Tomcat 中IDEA整合TomcatWeb 工程的目录介Servlet什么是 Servlet手动实现 Servl
SpringBoot学习记录02——yaml配置
wcy的博客
08-31 542
文章目录SpringBoot配置文件yaml概述yaml基础语法注释基本类型对象和map数组yaml注入配置文件注释处理器配置文件占位符导入指定配置文件properties配置文件@ConfigurationProperties和 @Value对比 SpringBoot配置文件 SpringBoot使用一个全局的配置文件 ， 配置文件名称是固定的为application application.properties key1=value1 key2=value2 application.yaml 注
SpringBoot——整合SpringSecurity
wcy的博客
09-13 453
Spring Security是一个框架，侧重于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring Security的真正强大之处在于它可以轻松地扩展以满足定制需求 环境准备 静态资源 素材下载 编写路由controller @Controller public class RouterController { @GetMapping({"/", "/index", "/index.html"}) public String index() {
SpringBoot——整合Druid
wcy的博客
09-11 384
Druid Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。 Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。 使用Druid 导入依赖 <!-- https://mvnrepository.com/artifact/com.alibaba/druid --> <dependency> <groupId>com.alibaba<
SpringBoot——Shiro
wcy的博客
09-14 228
文章目录主要功能QuickStart环境搭建重要的几个核心步骤springboot整合shiro Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。 主要功能 三个核心组件：Subject, SecurityManager 和 Realms. Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是
Java反射机制详解与应用
"学习目标-理解Java反射机制，掌握Reflection API的使用，了解抽象工厂模式在反射中的应用。" 在Java编程中，反射机制是一种强大的工具，它允许我们在程序运行时检查类、接口、字段和方法的信息，甚至能够在运行时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值