Java反射

已于 2024-09-01 13:07:47 修改
阅读量565 收藏 15
点赞数 9
文章标签： java 开发语言
于 2024-09-01 12:34:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36816794/article/details/141751253
版权

1. 反射

1.1. 反射引入

  • 编译时知道类或对象的具体信息，此时直接对类和对象进行操作即可，无需反射
  • 如果编译不知道类或对象的具体信息，就使用反射来实现。比如类名、属性和属性值放在XML文件中，需要在运行时读取XML文件，动态获取类的信息
public class Test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 编码/编译的时候，已经知道要创建类对象时，不需要反射
        // 创建对象
        /*Animal an = new Cat();
        an.nickName = "wangwang";
        an.run();*/
        // 编码/编译时，不知道要创建类对象，只有根据运行时动态获取的内容来创建对象，使用反射
        // 使用Properties类读取属性文件，最终得到了类的完整路径字符串
        String className = "com.wyb.why.Cat";
        Class clazz = Class.forName(className);
        Object an = clazz.newInstance();
        // 操作属性
        // 执行方法
    }
}
  • 反射的应用场合
    • 在编译时无法知道对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。
    • 比如log4j、Servlet、SSM框架技术都使用了反射
比如：log4j
   log4j.appender.stdout=org.apache.log4j.ConsoleAppender
   log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
比如：Servlet
<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>servlet.HelloServlet</servlet-class>
</servlet>
比如：SSM
<bean id="tm" class="org..jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
  • 反射的作用
    • 动态创建对象
    • 动态操作属性
    • 动态调用方法
  • 在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中
    • Class类：代表一个类
    • Constructor类：代表类的构造方法
    • Field类：代表类的成员变量（属性）
    • Method类：代表类的成员方法

1.2. 反射的入口-Class类

  • Class类是Java反射机制的起源和入口
    • 用于获取与类相关的各种信息
    • 提供了获取类信息的相关方法
    • Class类继承自Object类
  • Class类是所有类的共同的图纸
    • 每个类有自己的对象，好比图纸和实物的关系
    • 每个类也可看作是一个对象，有共同的图纸Class，存放类的结构信息，如类名、属性、方法、构造方法、父类和结构，能够通过相应方法取出相应信息
  • Class类的对象称为类对象
    在这里插入图片描述
package src.com.db1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class TestClass1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
        // 1. 获取一个类的结构信息（类对象、Class对象）
        Class clazz = Class.forName("com.wyb.why.Dog");
        // 2. 从类对象中获取类的各种结构信息
        // 2.1. 获取基本结构信息
        System.out.println(clazz.getName());
        System.out.println(clazz.getSimpleName());
        System.out.println(clazz.getSuperclass());
        System.out.println(Arrays.toString(clazz.getInterfaces()));
        // 2.2. 获取构造方法
        // 只能得到public修饰的构造方法
        // Constructor[] constructors = clazz.getConstructors();
        // 可以得到所有的构造方法
        Constructor[] constructors = clazz.getDeclaredConstructors();
        System.out.println(constructors.length);
        for (Constructor con : constructors) {
            System.out.println(con.getName() + "||" + Modifier.toString(con.getModifiers()) + "||" + Arrays.toString(con.getParameterTypes()));
        }
        // 获取无参构造方法
        // Constructor con = clazz.getConstructor();
        // Constructor con = clazz.getConstructor(String.class, String.class);
        Constructor con = clazz.getDeclaredConstructor(String.class, String.class);
        System.out.println(con);
        // 2.3. 获取属性
        // Field[] fields = clazz.getFields();
        Field[] fields = clazz.getDeclaredFields();
        System.out.println(fields.length);
        for (Field f : fields) {
            System.out.println(f);
        }
        // Field f = clazz.getField("color");
        // private默认protected、public都可以获取，但不包括父类的
        Field f = clazz.getDeclaredField("age");
        System.out.println(f);
        // 2.4. 获取方法
        // Method[] methods = clazz.getMethods();
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        // Method m = clazz.getMethod("shout", String.class);
        // Method m = clazz.getMethod("run"); // public
        Method m = clazz.getDeclaredMethod("run");
        System.out.println(m);
    }
}
  • Class类的常用方法
    在这里插入图片描述
  • 获取一个类的类对象的多种方式
    在这里插入图片描述
public class TestClass2 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1. 获取一个类的结构信息（类对象、Class对象）
        // 1.1. Class.forName(类的完整路径字符串)
        // Class clazz = Class.forName("java.lang.String");
        // 1.2. 类名.class
        // Class clazz = String.class;
        // 1.3. 对象名.getClass()
        String str = "wyb";
        Class clazz = str.getClass();
        // Integer in = new Integer(20);
        // 2. 从类对象中获取类的各种结构信息
        System.out.println(clazz.getName());
        System.out.println(clazz.getSimpleName());
        System.out.println(clazz.getSuperclass());
        System.out.println(Arrays.toString(clazz.getInterfaces()));
    }
}

其中，类名.class、对象名.getClass()方式在编码时已经知道了要操作的类，而Class.forName()方式在操作时，可以知道也可以不知道要操作的类，所以当编码时还不知道要操作的类时，只能使用Class.forName()的方式

3.3. 使用反射创建对象

调用无参构造方法创建对象

  • 方法1：通过Class的newInstance()方法
    • 该方法要求该Class对象的对应类有无参构造方法
    • 执行newInstance()实际上就是执行无参构造方法来创建该类的实例
  • 方法2：通过Constructor的newInstance()方法
    • 先使用Class对象获取指定的Constructor对象
    • 再调用Constructor对象的newInstance()创建Class对象对应类的对象
    • 通过该方法可选择使用指定构造方法来创建对象
/*
* 通过Class的newInstance()方法创建对象
* */
public class TestConstructor {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        String className = "com.wyb.why.Dog";
        Class clazz = Class.forName(className);
        // 直接使用Class的方法创建对象
        Object obj = clazz.newInstance();
        System.out.println(obj.toString());
    }
}

/*
* 通过Constructor的newInstance()方法创建对象
* */
public class TestConstructor1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String className = "com.wyb.why.Dog";
        Class clazz = Class.forName(className);
        // 获取无参数构造方法
        Constructor con = clazz.getConstructor();
        // 使用无参数构造方法来创建对象
        Object obj = con.newInstance();
    }
}

调用有参数构造方法创建对象：只能通过Construtor的newInstance()方法来创建对象

/*
* 通过Constructor的newInstance()方法来创建对象
* */
public class TestConstructor2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String className = "com.wyb.why.Dog";
        Class clazz = Class.forName(className);
        Constructor con = clazz.getDeclaredConstructor(String.class, String.class);
        // 使用反射创建对象
        // 突破封装性的限制，即使是private、默认的也可以访问
        con.setAccessible(true);
        Object obj = con.newInstance("dog1", "black");
    }
}
  • 反射优点：功能强大
    1. 编码时不知道具体的类型，可以使用反射动态操作
    2. 突破封装的限制，即使private的成员也可以进行操作
  • 反射缺点
    1. 代码繁琐，可读性差
    2. 突破封装的显示，即使private的成员也可以进行操作

2. 反射技术

2.1. 使用反射操作属性

通过Class对象的getFields()或getField()方法可以获得该类所包括的全部Field属性或指定Field属性。

  • getXxx(Object obj)：获取obj对象该Field的属性值。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用get(Object obj)
  • setXxx(Object obj, Xxx val)：将obj对象的该Field赋值val。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用set(Object obj, Object val)
  • setAccessible(Boolean flag)：若flag为true，则取消属性的访问权限控制，即使private属性也可以进行访问
public class TestField {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String className = "com.wyb.why.Dog";
        Class clazz = Class.forName(className);
        Object dog = clazz.getConstructor().newInstance();
        // 获取属性
        Field f1 = clazz.getField("color");
        Field f2 = clazz.getDeclaredField("age");
        // 给属性复制
        f1.set(dog, "black");
        f2.setAccessible(true);
        f2.set(dog, 10);
        // 输出给属性
        System.out.println(f1.get(dog)); // dog.color
        System.out.println(f2.get(dog)); // dog.age
        System.out.println(dog);
    }
}

2.2. 使用反射执行方法

  • 通过Class对象的getMethod()方法可以获得该类所包括的全部方法，返回值是Method[]
  • 通过Class对象的getMethod()方法可以获得该类所包括的指定方法，返回值是Method
  • 每个Method对象对应一个方法，获得Method对象后，可以调用其invoke()来调用对象方法
  • Object invoke(Object obj, Object[] args)：obj代表当前方法所属的对象的名字，args代表当前方法的参数列表，返回值Object是当前方法的返回值
public class TestMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String className = "com.wyb.why.Dog";
        Class clazz = Class.forName(className);
        Object dog = clazz.getConstructor().newInstance();
        // 获取方法
        Method m1 = clazz.getMethod("shout");
        Method m2 = clazz.getMethod("add", int.class, int.class);
        // 使用反射执行方法
        m1.invoke(dog);
        Object result = m2.invoke(dog, 10, 20);
    }
}

2.3. 使用反射操作泛型

没有出现泛型之前，Java中的所有数据类型包括：

  • primitive types：基本类型
  • raw type：原始类型。不仅指平常所指的类，还包括数组、接口、注解、枚举等结构
    Class类的一个具体对象代表一个指定的原始类型和基本类型
    泛型出现之后，也就扩充了数据类型：
  • parameterized types（参数话类型）：就是平常用到的泛型List<T>、Map<K, V>的List和Map
  • type variables（类型变量）：比如List<T>中的T等
  • arrat types（数组类型）：带泛型的数组：List<T>[]、T[]
  • WildcardType（泛型表达式类型，通配符类型）：List<? extends Number>
    使用泛型，擦出的是方法体中局部变量上定义的泛型，在泛型类、泛型接口中定义的泛型，在成员变量、成员方法上定义的泛型，依旧会保存。保留下来的信息可以通过反射获取。
    Class类的一个具体对象代表一个指定的基本类型和原始类型
    为了能够通过反射操作泛型，但是实现扩展性而不影响之前操作，Java就新增了ParameterizedType, TypeVariable, GenericArrayType, WildcardType几个类型来代表不能被归一道Class类中的类型，和原始类型齐名。
    在这里插入图片描述
public class TestGeneric {
    public void method1(Map<Integer, Student> map, List<Student> list, String str) {
    }
    public Map<Integer, Student> method2() {
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        Class clazz = TestGeneric.class;
        Method method1 = clazz.getMethod("method1", Map.class, List.class, String.class);
        // 获取参数类型（不带泛型）
        Class[] paramTypes = method1.getParameterTypes();
        for (Class clazz2 : paramTypes) {
            System.out.println(clazz2);
        }
        // 获取参数类型（带泛型）
        Type[] types = method1.getGenericParameterTypes();
        System.out.println(types.length);
        for (Type type : types) {
            System.out.println(type);
            if(type instanceof ParameterizedType) {
                Type[] typeArgs = ((ParameterizedType) type).getActualTypeArguments();
                for (Type arg : typeArgs) {
                    System.out.println("\t" + arg);
                }
            }
        }
        // 获取返回值类型（不带泛型）
        Method method2 = clazz.getMethod("method2");
        Class returnType = method2.getReturnType();
        System.out.println(returnType);
        // 获取返回值类型（带泛型）
        Type returnType1 = method2.getGenericReturnType();
        Type[] typeArgs = ((ParameterizedType) returnType1).getActualTypeArguments();
        for (Type type : typeArgs) {
            System.out.println("\t" + type);
        }
        // 获取数组元素的类型
        Student[] arr = new Student[10];
        Class componentType = arr.getClass().getComponentType();
        System.out.println(componentType);
    }
}

给集合添加泛型后，可以限制元素类型，提高安全性。使用反射还可以突破泛型的限制

public class TestGeneric1 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<String> list = new ArrayList<>();
        Class clazz = list.getClass();
        // 获取add放阿法
        Method method = clazz.getMethod("add", Object.class);
        // 使用反射调用add方法
        method.invoke(list, 100);
        method.invoke(list, new Date());
        System.out.println(list);
    }
}

3. 反射应用：完善DBUtil，提取select()

3.1. 认识ResultSetMetaData

利用ResultSet的getMetaData方法可以获得ResultSetMeta对象，而ResultSetMetaData存储了ResultSet的MetaData
MetaData：元数据，就是描述及解释含义的数据
ResultSet是以表格的形式存在的，所以MetaData就包括了数据的字段名称、类型以及数目等表格所具备的信息。

3.2. 提取DBUtil的select()

public class TestResultSetMetaData {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 将相应数据库的jar包放入项目
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        // 加载驱动
        String driver = "com.mysql.cj.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3006/table";
        String user = "root";
        String password = "root";
        Class.forName(driver);
        // 建立数据库的连接
        conn = DriverManager.getConnection(url, user, password);
        // 创建一个SQL命令发送器
        stmt = conn.createStatement();
        // 使用SQL命令发送器来发送SQL命令并得到结果
        String sql = "select empno, ename, hiredate, sal from emp;";
        rs = stmt.executeQuery(sql);
        // 得到结果集的结构
        ResultSetMetaData rsmd = rs.getMetaData();
        System.out.println(rsmd.getColumnCount());
        for (int i = 0; i < rsmd.getColumnCount(); i++) {
            System.out.println(rsmd.getColumnName(i + 1) + "\t" + rsmd.getColumnTypeName(i + 1) + "\t" + rsmd.getColumnClassName(i + 1));
        }
        // 关闭数据库连接
    }
}

方法摘要：
在这里插入图片描述

public abstract class DBUtil {
    public static<T> List<T> executeQuery(String sql, Object params[], String className) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        List<T> list = new ArrayList<T>();
        try {
            // 获取连接
            conn = DBUtil.getConnection();
            // 创建Statement
            pstmt = conn.prepareStatement(sql);
            // 使用Statement发送SQL命令并得到结果
            for (int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);
            }
            rs = pstmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            // 处理结果（封装到List中）
            while (rs.next()) {
                // 使用反射创建一个对象
                Class clazz = Class.forName(className);
                T entity = (T)clazz.newInstance();
                // 取出当前行的某列并存入对象（使用反射调用方法）
                for (int i = 0; i < rsmd.getColumnCount(); i++) {
                    // 获取结果集当前列的名称
                    String columnName = rsmd.getColumnName(i + 1).toLowerCase();
                    // 根据当前列的名称或当前列的值
                    Object value = rs.getObject(columnName);
                    // 通过反射方法调用方法entity.setEmpNo(value);
                    String methodName = "set" + columnName.substring(0, 1).toUpperCase() + columnName.substring(1);
                    Class paramType = Class.forName(rsmd.getColumnClassName(i + 1));
                    Method method = clazz.getMethod(methodName, paramType);
                    method.invoke(entity, value);
                    // 将对象加入到集合中
                    list.add(entity);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBUtil.closeAll(rs, pstmt, conn);
        }
        return list;
    }
    public static<T> List<T> executeQuery(String sql, Object params[], Class clazz) {}
}

提取了两个重载的方法，区别在于第三个参数，可以传入类的完整路径字符串，也可以直接传入类的Class信息

3.3. 简化DAO的select 方法

public class EmployeeDaoImpl implements EmplpyeeDao{
    @Override
    public Employee findById(int empNo) {
        String sql = "select * from emp where empno = ?";
        Object[] params = {empNo};
        List<Employee> empList = DBUtil.executeQuery(sql, params, "com.wyb.entity.Employee");
        if(empList.size() == 0) {
            return null;
        }else {
            return empList.get(0);
        }
    }
    @Override
    public List<Employee> findAll() {
        String sql = "select * from emp";
        Object params[] = {};
        return DBUtil.executeQuery(sql, params, Employee.class);
    }
}

可以看到，提取了DBUtil的查询方法之后，DAO层的查询方法代码大大简化了。数据库框架Hibernate、MyBatis的底层就是这样实现的

Qi妙代码
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java反射技术详解
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
java 反射
喵酱
03-29 2349
参考资料： Java反射技术详解_黄林晴的博客-CSDN博客_java反射 Java高级篇（四）——反射 - JAdam - 博客园 一、什么是反射 　　反射就是把Java类中的各个成分映射成一个个的Java对象。 即在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能调用它的任意一个方法和属性。 这种动态获取信息及动态调用对象方法的功能叫Java的反射机制。 1. 反射机制的功能 　　Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属
Java反射（通俗易懂）
qq_51515673的博客
05-17 10万+
目录 1、反射介绍 2、反射API 2.1 获取类对应的字节码的对象（三种） 2.2 常用方法 3、反射的应用 3.1 创建 : 测试物料类 3.2 获取类对象 3.3 获取成员变量 3.4 通过字节码对象获取类的成员方法 3.5 通过字节码对象获取类的构造方法 4、创建对象 1、反射介绍 Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，...
java反射调用get/set方法
吴名氏的博客
06-14 9万+
java反射调用get/set方法
Java反射的用途
果酱 の 博客
07-20 4646
Java反射是一项强大的特性，它为我们提供了在运行时获取和操作类的信息的能力。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至实现动态代理。Java反射是一种强大的特性，它允许我们在运行时获取和操作类的信息。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至可以实现动态代理。通过动态代理，我们可以在运行时生成代理对象，并在代理对象中添加额外的逻辑。在许多情况下，我们需要在运行时获取类的信息，例如类的名称、修饰符、父类、接口等。通过反射，我们可以访问和修改对象的字段。
Java反射（超详细！）
热门推荐
一只小菜鸡
10-02 12万+
1、反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 2、反射机制的相关类在哪个包下？ java.lang.reflect.*; 3、反射机制相关的重要的类有哪些？ 类 含义 java.lang.Class 代表整个字节码。代表一个类型，代表整个类。 java.lang.reflect.Method 代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Con
Java 反射
卓原的进化之旅
11-15 1844
JAVA反射机制 JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制 功能 1、获得某个对象的属...
JAVA反射
Dgs的博客
06-30 1266
JDK 反射使用
Java反射介绍
派大星的博客
09-21 1426
总结介绍java反射基本知识，希望对java安全初学者有所帮助。
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
Java反射技术原理与用法实例分析
08-19
Java反射技术原理与用法实例分析 Java反射技术是Java语言中的一种动态语言技术，能够在运行时解析外部对象的信息。通过反射技术，可以动态地获取类以及类中的成员，并可以调用该类成员。 产生反射技术的需求： 在...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 613
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
操作系统原子操作
zzt_is_me的博客
08-28 5989
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 3745
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
最新发布
央顺科技官方博客
08-31 968
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Qi妙代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值