注解和反射

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量60 收藏
点赞数
分类专栏： java面试 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/klxtstet/article/details/131535307
版权

注解和反射

1.注解使用理解

1.Annotation的作用：不是程序本身，可以对程序作出解释（这一点和注释（comment）没什么区别）可以被其他程序（比如：编译器等）读取
  2.Annotation 的格式
注解是以“@注释名”在代码中存储在的，还可以添加一些参数值，例如：@SuppressWarning（value=“unchecked”）.
  3.Annotation 在哪里使用？
可以附加在package 、class、method、field 等上面，相当于给他们添加了额外的辅助信息
我们可以通过反射机制实现对这些元数据的访问

2.内置注解

1.@Override：
  定义在java.lang.Override 中，此注解只使用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。

在这里插入图片描述

2.@Deprecated：
  定义在java.lang.Deprecated中，此注解，可以用于修辞方法、属性、类、表示不鼓励程序员使用这样的元素，同时是因为它很危险或者存在更好的选择。（一般来说表示废弃了的方法、或者类等等）

在这里插入图片描述

3.@SuppressWarnings：
  定义在java.lang.SuppressWarings 中，用来抑制编译时的警告信息，
与前两个注解有所不同，需要添加一个参数才能正确使用，这些参数都是已经定义好了的
@SuppressWarnings（“all”）
@SuppressWarnings（“unchecked”）
@SuppressWarnings（value={“unchecked”，“deprecation”}）
等等

用于镇压警告

在这里插入图片描述

在这里插入图片描述

3.元注解

元注解的作用就是负责注解其他注解，Java定义了四个标准的meta-annotation类型，它们被用来提供对其他annotation 类型做说明。

这些类型和它们锁支持的类在java.langannotation 包中可以找到（@Target，@Retention，@Documented，@Inherited）
1.@Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
2.@Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期（SOURCE（源代码） CLASS（字节码）RUNTIEM（运行时））
3.@Document：说明该注解将被包含在javadoc中
4.@Inherited：说明子类可以继承父类中的该注解

4.自定义注解

使用@interface 自定义注解是，自动继承了 java.lang.annotation.Annotation接口

分析：
  1.@Interited 用来声明一个注解，格式：public @ interface 注解名{ 定义内容 }
  2.其中的每一个方法实际上是声明了一个配置参数
  3.方法的名称就是参数的名称
  4.返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）。
  5.可以通过default 来声明参数的默认值
  6.如果只有一个参数成员，一般参数名为value
  7.注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

项目开发中注解使用-AOP注解

参考项目地址
重复提交注解案例
自定义注解

package org.dromara.common.idempotent.annotation;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * 自定义注解防止表单重复提交
 *
 * @author Lion Li
 */
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit {

    /**
     * 间隔时间(ms)，小于此时间视为重复提交
     */
    int interval() default 5000;

    TimeUnit timeUnit() default TimeUnit.MILLISECONDS;

    /**
     * 提示消息 支持国际化 格式为 {code}
     */
    String message() default "{repeat.submit.message}";

}


package org.dromara.common.idempotent.aspectj;

import cn.dev33.satoken.SaManager;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.crypto.SecureUtil;
import org.dromara.common.core.constant.GlobalConstants;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.exception.ServiceException;
import org.dromara.common.core.utils.MessageUtils;
import org.dromara.common.core.utils.ServletUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.json.utils.JsonUtils;
import org.dromara.common.redis.utils.RedisUtils;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile;

import java.time.Duration;
import java.util.Collection;
import java.util.Map;
import java.util.StringJoiner;

/**
 * 防止重复提交(参考美团GTIS防重系统)
 *
 * @author Lion Li
 */
@Aspect
public class RepeatSubmitAspect {

    private static final ThreadLocal<String> KEY_CACHE = new ThreadLocal<>();

    @Before("@annotation(repeatSubmit)")
    public void doBefore(JoinPoint point, RepeatSubmit repeatSubmit) throws Throwable {
        // 如果注解不为0 则使用注解数值
        long interval = repeatSubmit.timeUnit().toMillis(repeatSubmit.interval());

        if (interval < 1000) {
            throw new ServiceException("重复提交间隔时间不能小于'1'秒");
        }
        HttpServletRequest request = ServletUtils.getRequest();
        String nowParams = argsArrayToString(point.getArgs());

        // 请求地址（作为存放cache的key值）
        String url = request.getRequestURI();

        // 唯一值（没有消息头则使用请求地址）
        String submitKey = StringUtils.trimToEmpty(request.getHeader(SaManager.getConfig().getTokenName()));

        submitKey = SecureUtil.md5(submitKey + ":" + nowParams);
        // 唯一标识（指定key + url + 消息头）
        String cacheRepeatKey = GlobalConstants.REPEAT_SUBMIT_KEY + url + submitKey;
        if (RedisUtils.setObjectIfAbsent(cacheRepeatKey, "", Duration.ofMillis(interval))) {
            KEY_CACHE.set(cacheRepeatKey);
        } else {
            String message = repeatSubmit.message();
            if (StringUtils.startsWith(message, "{") && StringUtils.endsWith(message, "}")) {
                message = MessageUtils.message(StringUtils.substring(message, 1, message.length() - 1));
            }
            throw new ServiceException(message);
        }
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(repeatSubmit)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, RepeatSubmit repeatSubmit, Object jsonResult) {
        if (jsonResult instanceof R<?> r) {
            try {
                // 成功则不删除redis数据 保证在有效时间内无法重复提交
                if (r.getCode() == R.SUCCESS) {
                    return;
                }
                RedisUtils.deleteObject(KEY_CACHE.get());
            } finally {
                KEY_CACHE.remove();
            }
        }
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e         异常
     */
    @AfterThrowing(value = "@annotation(repeatSubmit)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, RepeatSubmit repeatSubmit, Exception e) {
        RedisUtils.deleteObject(KEY_CACHE.get());
        KEY_CACHE.remove();
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray) {
        StringJoiner params = new StringJoiner(" ");
        if (ArrayUtil.isEmpty(paramsArray)) {
            return params.toString();
        }
        for (Object o : paramsArray) {
            if (ObjectUtil.isNotNull(o) && !isFilterObject(o)) {
                params.add(JsonUtils.toJsonString(o));
            }
        }
        return params.toString();
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Object value : collection) {
                return value instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Object value : map.values()) {
                return value instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
               || o instanceof BindingResult;
    }

}

5.Java反射概述

动态 VS 静态语言

动态语言
  是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言:Object-C、C#、JavaScript、PHP、Python等。

静态语言
  与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

Java Reflection
  Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。（写出来的代码编译成.class之后就不能变了）

Class c = Class.forName("java.lang.String")
1

在这里插入图片描述
Java 反射机制提供的功能

1.在运行时判断任意一个对象所属的类
  2.在运行时构造任意一个类的对象
  3.在运行时判断任意一个类所具有的成员变量和方法
  4.在运行时获取泛型信息
  5.在运行时调用任意一个对象的成员变量和方法
  6.在运行时处理注解
  7.生成动态代理

反射优缺点

优点:
  可以实现动态创建对象和编译，体现出很大的灵活性

缺点:
  对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

反射相关主要API

java.lang.Class :代表一个类

java.lang.reflect.Method:代表类的方法

java.lang.reflect.Field:代表类的成员变量

java.lang.reflect.Constructor:代表类的构造器

6.Class 类

在Object类中定义了以下的方法，此方法将被所有子类继承

public final native Class<?> getClass();
1

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即:可以通过对象反射求出类的名称。

Class 类的常用方法

在这里插入图片描述

获取Class类的实例

1.若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

Class clazz= Person.class;
1

2.已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class clazz = person.getClass();
1

3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

Class clazz= Class.forName("demo01.Student");

package cn.bloghut.reflection;

/**

 * @author by 闲言

 * @classname Test03

 * @description 测试Class类的创建方式有哪些

 * @date 2021/7/31 17:21
   */
   public class Test03 {

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

       Person person = new Student();
       System.out.println("这个人是："+person.name);
       
       //方式1：通过对象获得
       Class c1 = person.getClass();
       System.out.println(c1.hashCode());
       
       //方式2. forname 获取
       Class c2 = Class.forName("cn.bloghut.reflection.Student");
       System.out.println(c2.hashCode());
       
       //方式3. 通过类名.class 获得
       Class c3 = Student.class;
       System.out.println(c3.hashCode());
       
       //方式4：基本内置类型的包装类都有一个Type 属性
       Class<Integer> c4 = Integer.TYPE;
       System.out.println(c4);
       
       ///获得父类类型
       Class superclass = c1.getSuperclass();
       System.out.println(superclass);


    }

}

class Person {
    String name;

    public Person() {
    }
    
    public Person(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

}

class Student extends Person {
    public Student() {
        this.name = "学生";
    }
}

class Teacher extends Person {
    public Teacher() {
        this.name = "学生";
    }
}

8.类加载与内存分析

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

在这里插入图片描述

加载:
  将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象.（获取，不能主动创建）

链接:
  将Java类的二进制代码合并到JVM的运行状态之中的过程。
  1.验证: 确保加载的类信息符合JVM规范，没有安全方面的问题
  2.准备: 正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
  3.解析: 虚拟机常量池内的符号引用（常量名）替换为直接引用(地址)的过程。

初始化:
  1.执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。
  2.当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
  3.虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

9.什么时候会发生类的初始化

类的主动引用(一定会发生类的初始化)
  1.当虚拟机启动，先初始化main方法所在的类
  2.new一个类的对象
  3.调用类的静态成员(除了final常量)和静态方法
  4.使用java.lang.reflect包的方法对类进行反射调用
  5.当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用(不会发生类的初始化)
  1.当访问一个静态域时，只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量，不会导致子类初始化
  2.通过数组定义类引用，不会触发此类的初始化
  3.引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了)

10.类加载器的作用

类加载的作用:
  将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

类缓存:
  标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象

在这里插入图片描述

在这里插入图片描述

引导类加载器:
  用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。

扩展类加载器:
  负责jre/lib/ext目录下的jar包或-java.ext.dirs指定目录下的jar包装入工作库。

系统类加载器:
  负责java -classpath或-Djava.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。

invoke方法详解
要通过反射机制调用某个类的方法，主要用到了下面这个方法：

public Object invoke(Object obj,Object… args)
这个方法是 Method 类封装的实例方法。

import java.lang.reflect.Method;

public class Person {
    public static void main(String[] args) throws Exception {		
        Class<?> clazz = Class.forName("net.xsoftlab.baike.Person");
        // 调用Person类中的run方法
        Method method = clazz.getMethod("run");
        method.invoke(clazz.newInstance());
        // Java 反射机制 - 调用某个类的方法1.
        // 调用Person的Speak方法
        method = clazz.getMethod("Speak", int.class, String.class);
        method.invoke(clazz.newInstance(), 22, "小明");
        // Java 反射机制 - 调用某个类的方法2.
        // age -> 22. name -> 小明
    }
    
    public void run(){
        System.out.println("调用Person类的run方法");
    }
    
    public void Speak(int age, String name){
        System.out.println("调用Person类的Speak方法");
        System.out.println("age -> " + age + ". name -> " + name);
    }

}

程序运行结果：

在这里插入图片描述
刚刚aop注解中获取有使用到反射判断类型

 @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o) {
        Class<?> clazz = o.getClass();
        if (clazz.isArray()) {
            return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
        } else if (Collection.class.isAssignableFrom(clazz)) {
            Collection collection = (Collection) o;
            for (Object value : collection) {
                return value instanceof MultipartFile;
            }
        } else if (Map.class.isAssignableFrom(clazz)) {
            Map map = (Map) o;
            for (Object value : map.values()) {
                return value instanceof MultipartFile;
            }
        }
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
               || o instanceof BindingResult;
    }
影（瘾）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1162
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2302
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 902
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java进阶——注解和反射
万里顾一程的博客
03-26 5733
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1329
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
Java注解和反射
热门推荐
qq_50806424的博客
08-16 1万+
Java注解和反射 一、反射（Reflection） 在学习反射前我们先了解一下动态语言和静态语言 动态语言和静态语言 动态语言 ​ 在运行中可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他代码结构上的改变，主要的动态语言有JavaScript、Python、PHP、C# 静态语言 ​ 与动态语言相对的，在运行程序过程中代码结构不发生改变的语言叫做静态语言，如C、C++、Java。Java不是动态语言，但Java有一定的动态性，这种动态性我们可以用反
从springboot中的注解再次理解注解和反射
qq_41980102的博客
04-08 1401
从springboot注解再次理解注解和反射 为了看懂源码的注解和反射 1、自述 ​ 在日常的开发中，大家可能已经留意到注解的声影随处可见，特别是在看Springboot源码的时候，自动装配里面运用大量的注解，起初我看源码也是云里雾里的，现在我总结一下我浅薄的见解和理解吧。 2、注解的基础用法 2.1什么是注解？ 对于很多初次接触的开发者来说应该都有这个疑问？ Annontation 是Ja...
利用注解和反射自动生成Sql
ARSLYN的博客
05-15 827
一、注解是什么？ Annotation——注解，是Java中的一种代码辅助工具，其核心作用是用来标注类、方法、变量、参数以及包。我们可以通过反射机制来访问这些标注信息，然后将我们所需要的代码逻辑镶嵌在所标注的元素上，或者改造注解标注的元素来达到我们需要的效果。 这里要做一个区分，注解与注释不同，注释是作者在编辑java代码时对某一段代码或者某一个类、方法等做一个解释。一般用“//这是解释说明内容”、“/*这是解释说明内容/”等方式。注释中的内容是不会被编译进.class文件中的。而注解的内容是可以编译进代码
java注解和反射的应用
KKALL1314的博客
07-19 2164
前言： 注解和反射经常结合在一起使用，在很多框架的代码中都能看到他们结合使用的影子 所以要想成为一个架构师，想要编写自己的框架，一定要能熟练的使用注解和反射。 注解的概念 注解在我看来就是一个标签，用来标记所修饰的东西，而在程序中，用到这个东西时，可以通过获取他的注解，也就是标签，来进行个性化操作。可以简化初始化时的工作，而把原本初始化做的工作放到业务处理中，借助注解去做，这样极大的提高了编程的...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
Java中关于注解和反射机制的内容
11-04
Java中关于注解和反射机制的内容
Java使用注解和反射简化编程的方法示例
08-25
主要介绍了Java使用注解和反射简化编程的方法,结合实例形式分析了java使用注解和反射调用大量函数简化编程的相关操作技巧,需要的朋友可以参考下
注解和反射机制的学习笔记
03-05
注解和反射机制的学习笔记
为什么选择Python作为AI开发语言
AI心易行者
06-09 2073
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 352
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 507
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 577
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值