java：接口请求重试

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量2.5k 收藏 2
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a232884c/article/details/129768455
版权

java：接口请求重试

1 前言

接口请求重试的思路，采用循环 + try \ catch的方式，若接口请求失败或超时，则根据设置的重试次数再次发起请求重试。

2 使用

具体实现如下，若执行中抛出超时异常，则接口请求发起重试，最多执行次数为5次：

public String buildGetRequestWithRetry(String urlPath,
                              Map<String,Object> paramsMap,
                              Map<String,String> headerMap){
    /* 请求重试次数（包含原本do执行的1次） */
    int retryTimes = 5;
    final int finalRetryTimes = retryTimes;
    String result = null;

    label:{
        do{
            try{

                result = this.buildGetRequest(urlPath, paramsMap, headerMap);

                break label;

            }catch (CrawlerForJException crawlerForJException){

                if(isConnectTimeOut(crawlerForJException) ||
                        isReadTimeOut(crawlerForJException)){

                    retryTimes --;

                    if(retryTimes > 0){
                        LogUtils.warn(requestLogger,
                                "接口请求第{}次请求重试...",
                                (finalRetryTimes - retryTimes));
                    }

                    ThreadUtils.sleepByMilli(1000);

                }else{
                    throw crawlerForJException;
                }

            }
        }while(retryTimes > 0);

        ExcpUtils.throwExp("总执行" + finalRetryTimes + "次请求,请求依然失败.");
    }

    return result;
}

RequestHelper：

@Component
public class RequestHelper {

    @Autowired
    RequestUtils requestUtils;

    public String doRequestDispatch(String method,
                                  String urlPath,
                                  Map<String, Object> params,
                                  Map<String, String> headers){
        /* reqE不会为null，找不到只会抛出异常，避免switch(null)空指针异常 */
        RequestMethodEnum reqE = this.getRequestMEnumByMethod(method);

        switch (reqE){
            case GET:
                return requestUtils.buildGetRequestWithRetry(urlPath, params, headers);
            case POST:
                ExcpUtils.throwExp("post方法暂时不支持");
            default:
                ExcpUtils.throwExp("其他方法暂时不支持");
        }

        return null;
    }

    /* 暂时只支持使用RequestMethodEnum枚举中配置的 */
    public RequestMethodEnum getRequestMEnumByMethod(String method){
        RequestMethodEnum[] var1 = RequestMethodEnum.values();
        int var2 = var1.length;
        int var3 = 0;

        RequestMethodEnum reqM = null;
        label : {
            if(var2 > 0){
                do{
                    RequestMethodEnum requestM = var1[var3];
                    if(requestM.getName().equalsIgnoreCase(method)){
                        reqM = requestM;
                        break label;
                    }
                    var3++;
                }while(var3 < var2);
            }
            ExcpUtils.throwExp("没有找到匹配request请求方法："+method);
        }
        return reqM;
    }

}

RequestMethodEnum:

public enum  RequestMethodEnum {
    /*避免java.net.ProtocolException: Invalid HTTP method: get 以及
    java.net.ProtocolException: Invalid HTTP method: post异常,应该是GET和POST*/

    GET("GET","get请求","01"),
    POST("POST","post请求","02");

    private String name;
    private String description;
    private String code;

    RequestMethodEnum(String name,String description,String code){
        this.name = name;
        this.description = description;
        this.code = code;
    }

    /*根据code获取请求方式*/
    public static RequestMethodEnum getMethodByCode(String code){
        for (RequestMethodEnum value : RequestMethodEnum.values()) {
            if(value.getCode().equals(code)){
                return value;
            }
        }
        return null;
    }

    public String getName() {
        return name;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

RequestUtils：

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;
import com.xiaoxu.crawler.enums.request.RequestMethodEnum;
import com.xiaoxu.crawler.excp.CrawlerForJException;
import org.apache.commons.collections4.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.text.MessageFormat;
import java.util.*;

/**
 * @author xiaoxu
 * @date 2022-11-06 15:29
 * crawlerJ:com.xiaoxu.crawler.utils.RequestUtils
 */
@Component
public class RequestUtils {

    private static final String UTF8 = "utf-8";

    private static final String AndSet = "&";

    private static final String CommaSet = ",";

    private static final String EqualSet = "=";

    private static final String QuestionMark = "?";

    private static final String ConnectTimeOutMsg = "connect timed out";

    private static final String ReadTimeOutMsg = "read timed out";

    private static final Logger requestLogger =
            LoggerFactory.getLogger(RequestUtils.class);

    /**
     * @param urlPath GET请求接口路径
     * @param paramsMap GET请求传参，可为空
     * @param headerMap 请求头，可为空
     * @return GET请求接口返回值（InputStream）
     */
    /* get接口请求 */
    public InputStream buildGetRequestInputStream(String urlPath,
                                    Map<String,Object> paramsMap,
                                    Map<String,String> headerMap){
        /* query String 的请求方式 */
        return buildAndGetResultInputStream(RequestMethodEnum.GET.getName(),
                urlPath,
                buildParamsStr(paramsMap),
                headerMap);
    }

    public String buildGetRequestWithRetry(String urlPath,
                                  Map<String,Object> paramsMap,
                                  Map<String,String> headerMap){
        /* 请求重试次数（包含原本do执行的1次） */
        int retryTimes = 5;
        final int finalRetryTimes = retryTimes;
        String result = null;

        label:{
            do{
                try{

                    result = this.buildGetRequest(urlPath, paramsMap, headerMap);

                    break label;

                }catch (CrawlerForJException crawlerForJException){

                    if(isConnectTimeOut(crawlerForJException) ||
                            isReadTimeOut(crawlerForJException)){

                        retryTimes --;

                        if(retryTimes > 0){
                            LogUtils.warn(requestLogger,
                                    "接口请求第{}次请求重试...",
                                    (finalRetryTimes - retryTimes));
                        }

                        ThreadUtils.sleepByMilli(1000);

                    }else{
                        throw crawlerForJException;
                    }

                }
            }while(retryTimes > 0);

            ExcpUtils.throwExp("总执行" + finalRetryTimes + "次请求,请求依然失败.");
        }

        return result;
    }

    private boolean isConnectTimeOut(Throwable th) {
        return null != th
                && th.getMessage().toLowerCase(Locale.ROOT).contains(ConnectTimeOutMsg);
    }

    private boolean isReadTimeOut(Throwable th) {
        return null != th
                && th.getMessage().toLowerCase(Locale.ROOT).contains(ReadTimeOutMsg);
    }

    /**
     * @param urlPath GET接口请求路径
     * @param paramsMap GET接口请求参数
     * @param headerMap 请求头
     * @return 响应结果（String）
     */
    public String buildGetRequest(String urlPath,
                                        Map<String,Object> paramsMap,
                                        Map<String,String> headerMap){
        return buildAndGetResult(RequestMethodEnum.GET.getName(),
                urlPath,
                buildParamsStr(paramsMap),
                headerMap);
    }

    /**
     * @param method 请求方式：GET、POST
     * @param urlPath 请求路径
     * @param data 请求数据
     * @param headerMap 请求头（根据接口情况传入）
     * @return
     */
    @SuppressWarnings(value = "all")
    protected static InputStream buildAndGetResultInputStream(@NonNull String method,
                                                @NonNull String urlPath,
                                                String data,
                                                Map<String,String> headerMap){

        StringBuilder str = new StringBuilder();
        InputStream in = null;
        FileOutputStream out = null;
        HttpURLConnection connection = null;

        try {

            if(!StringUtils.hasLength(method)){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的method不能为空:{0}",method));
            }

            if(!StringUtils.hasLength(urlPath)){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的urlPath不能为空:{0}",urlPath));
            }

            if(!method.equals(RequestMethodEnum.GET.getName())&&!method.equals(RequestMethodEnum.POST.getName())){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的method只能为GET或POST:{0}",method));
            }

            /*处理data,如果data为null，转换成""，否则data.getBytes会抛出空指针异常*/
            data = Optional.ofNullable(data).orElse("");
            data = data.replaceAll(" ","");

            if("get".equals(method.toLowerCase(Locale.ROOT))){
                /*get请求需要拼接路径（无参数，data应该是""，有参数则拼接）*/
                urlPath += data;
            }

            LogUtils.info(requestLogger, method+"请求获取stream的url:{}", urlPath);

            URL url;

            url = new URL(urlPath);
            connection = (HttpURLConnection) url.openConnection();

            if(!MapUtils.isEmpty(headerMap)){
                /*设置请求头的属性,比如：Cookie,Token等等
                System.out.println("key:"+k+";"+"value:"+v);*/
                headerMap.forEach(connection::setRequestProperty);
            }

            /*设置请求方式*/
            connection.setRequestMethod(method);
            connection.setRequestProperty("User-Agent", "Mozilla/4.76");

            /*设置超时时间*/
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(2000);

            /*post不同于get，get只需要将请求参数拼接到url中，而post请求的是正文*/
            if("post".equals(method.toLowerCase(Locale.ROOT))){
                /*post请求不能使用缓存*/
                connection.setUseCaches(false);

                /*post参数不是放在URL字符串里，而是http请求的正文
                post:http正文内，因此需要设为true*/
                connection.setDoOutput(true);

                /*connection获取输出的流，write写入post请求的参数：格式：key=value&key1=value1
                (当post请求是Content-Type：x-www-form-urlencoded（表单提交时使用）)
                post请求参数为JSON格式：当请求头设置了"Content-Type","application/json;charset=UTF-8"时使用*/
                OutputStream outputStream = connection.getOutputStream();

                /*String的getBytes,字符串转字节*/
                byte[] postBytes = data.getBytes(StandardCharsets.UTF_8);
                outputStream.write(postBytes);
            }

            /*获取URLConnection对象对应的输入流*/
            in = connection.getInputStream();

        } catch (IOException e) {

            throw new CrawlerForJException("buildRequest获取stream发生IO异常:"+e.getMessage(),e.getCause());

        } catch (Throwable th){

            throw new CrawlerForJException("buildRequest获取stream发生未知异常:"+th.getClass().getName()+th.getMessage(),
                th.getCause());

        } finally {

            /*关闭连接*/
            Optional.ofNullable(connection).ifPresent(HttpURLConnection::disconnect);

        }
        return in;
    }

    protected static String buildAndGetResult(@NonNull String method,
                                              @NonNull String urlPath,
                                              String data,
                                              Map<String,String> headerMap){
        StringBuilder str = new StringBuilder();
        InputStream in = null;
        HttpURLConnection connection = null;

        try {
            if(!StringUtils.hasLength(method)){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的method不能为空:{0}",method));
            }

            if(!StringUtils.hasLength(urlPath)){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的urlPath不能为空:{0}",urlPath));
            }

            if(!method.equals(RequestMethodEnum.GET.getName())&&!method.equals(RequestMethodEnum.POST.getName())){
                ExcpUtils.throwExp(
                        MessageFormat.format("buildRequest方法的method只能为GET或POST:{0}",method));
            }

            /*处理data,如果data为null，转换成""，否则data.getBytes会抛出空指针异常*/
            data = Optional.ofNullable(data).orElse("");
            data = data.replaceAll(" ","");

            if("get".equals(method.toLowerCase(Locale.ROOT))){
                /* get请求需要拼接路径（无参数，data应该是""，有参数则拼接） */
                urlPath += data;
            }

            LogUtils.info(requestLogger, method+"请求的url:{}", urlPath);

            URL url;

            url = new URL(urlPath);
            connection = (HttpURLConnection) url.openConnection();

            if(!MapUtils.isEmpty(headerMap)){
                /*
                * 设置请求头的属性,比如：Cookie,Token等等;
                * System.out.println("key:"+k+";"+"value:"+v);
                * */
                headerMap.forEach(connection::setRequestProperty);
            }

            /* 设置请求方式 */
            connection.setRequestMethod(method);
            connection.setRequestProperty("User-Agent", "Mozilla/4.76");

            /* 设置超时时间 */
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(2000);

            /* post不同于get，get只需要将请求参数拼接到url中，而post请求的是正文 */
            if("post".equals(method.toLowerCase(Locale.ROOT))){
                /* post请求不能使用缓存 */
                connection.setUseCaches(false);

                /*
                * post参数不是放在URL字符串里，而是http请求的正文
                * post:http正文内，因此需要设为true
                *  */
                connection.setDoOutput(true);

                /*
                * connection获取输出的流，write写入post请求的参数：格式：key=value&key1=value1
                * (当post请求是Content-Type：x-www-form-urlencoded（表单提交时使用）)
                * post请求参数为JSON格式：当请求头设置了"Content-Type","application/json;charset=UTF-8"时使用
                * */
                OutputStream outputStream = connection.getOutputStream();

                /* String的getBytes,字符串转字节 */
                byte[] postBytes = data.getBytes(StandardCharsets.UTF_8);
                outputStream.write(postBytes);
            }

            /* 获取URLConnection对象对应的输入流 */
            in = connection.getInputStream();

            /* 将接口请求的接口打印出来 */
            BufferedReader b = new BufferedReader(new InputStreamReader(in));
            String s;

            while((s = b.readLine()) != null){
                str.append(s);
            }

        } catch (IOException e) {

            throw new CrawlerForJException("buildRequest发生IO异常:"+e.getMessage(), e.getCause());

        } catch (Throwable th){

            throw new CrawlerForJException("buildRequest发生未知异常:"+th.getClass().getName() + ":[" + th.getMessage() + "]",
                    th.getCause());

        } finally {

            /*关闭连接*/
            Optional.ofNullable(connection).ifPresent(HttpURLConnection::disconnect);

            /*关闭流*/
            closeIn(in, "请求接口, 关闭输入流失败:{}");

        }

        return str.toString();
    }

    private static void closeIn(InputStream stream, String message) {

        if(stream != null){
            try {
                stream.close();
            } catch (IOException e) {
                LogUtils.info(requestLogger, message, e.getMessage());
            }
        }

    }

    private static void closeOut(OutputStream stream, String message) {

        if(stream != null){
            try {
                stream.close();
            } catch (IOException e) {
                LogUtils.info(requestLogger, message, e.getMessage());
            }
        }

    }


    /* 构建get请求的参数url，类似：?key=value&key1=value1 (query String)*/
    @SuppressWarnings(value = "all")
    public static String buildParamsStr(Map<String,Object> paramsMap){

        paramsMap = Optional.ofNullable(paramsMap).orElse(new HashMap<>());
        StringBuilder s = new StringBuilder();
        StringBuilder temp = new StringBuilder();

        try{

            for(Map.Entry<String,Object> m: paramsMap.entrySet()) {
                StringBuilder rep = new StringBuilder();

                if (m.getValue() instanceof List) {
                    Iterator<?> iter =((List<?>) m.getValue()).iterator();

                    while(iter.hasNext()){
                        String s1 = String.valueOf(iter.next());

                        if(rep.length() == 0){
                            rep.append(getEncode(m.getKey())).append(EqualSet).append(getEncode(s1));
                        }else{
                            rep.append(getEncode(CommaSet)).append(getEncode(s1));
                        }
                    }

                }else if(m.getValue() instanceof String ||
                        m.getValue() instanceof Long ||
                        m.getValue() instanceof Integer){

                    rep.append(getEncode(m.getKey())).append(EqualSet).append(getEncode(String.valueOf(m.getValue())));

                }else{

                    throw new CrawlerForJException("get请求参数存在value为非String，或非List，非Integer，非Long的数据");

                }

                if(temp.length() == 0){
                    temp.append(rep);
                }
                temp.append(AndSet).append(rep);
            }
        }catch (CrawlerForJException | UnsupportedEncodingException c){
            throw new CrawlerForJException(c);
        }catch (Exception e){
            throw new CrawlerForJException("未知异常：" + e.getMessage());
        }

        if (temp.length() != 0) {
            s.append(QuestionMark).append(temp);
        }
        return s.toString();
    }

    /* urlEncoded,get请求 query String使用 */
    private static String getEncode(String val) throws UnsupportedEncodingException {
        return URLEncoder.encode(Optional.ofNullable(val).orElse(""), UTF8);
    }

    /*
    * 构建post请求参数，类似：key = value & key1 = value1
    * 当post请求是Content-Type：x-www-form-urlencoded（表单提交时使用）
    * */
    public static String buildPayloadStr(Map<String,Object> payloadMap){

        StringBuilder s = new StringBuilder();
        payloadMap = Optional.ofNullable(payloadMap).orElse(Maps.newHashMap());

        for(Map.Entry<String,Object> m: payloadMap.entrySet()){
            if(s.length() == 0){
                s.append(m.getKey()).append(EqualSet).append(m.getValue());
            }else{
                s.append(AndSet).append(m.getKey()).append(EqualSet).append(m.getValue());
            }
        }

        return s.toString();
    }

    /*
    * 构建post请求2:json字符串格式，
    * 当请求头设置了"Content-Type","application/json;charset=UTF-8"时使用
    * */
    public static String buildJsonPayloadStr(Map<String,Object> payloadMap){

        String jsonData;
        /*允许为空*/
        payloadMap = Optional.ofNullable(payloadMap).orElse(Maps.newHashMap());

        try {
            jsonData = JSON.toJSONString(payloadMap);
        } catch (Exception e) {
            throw new CrawlerForJException("application-jsonData转换异常: "+e.getClass().getName()+"; "+e.getMessage());
        }

        return jsonData;
    }

}

ThreadUtils：

public class ThreadUtils {

    public static void sleepByMilli(long milliSeconds){

        if(milliSeconds <= 0)
            return;

        try {
            Thread.sleep(milliSeconds);
        } catch (InterruptedException ignored) {
            /* 忽略人为中止异常 */
        }

    }

}
小徐也要努力鸭
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java调用接口失败后重试
lin_Lobster_的博客
03-01 4418
java调用接口失败后重试，spring-retry重试策略。
java调用接口失败重试,httpclient接口测试中重试控制器设置
weixin_30111277的博客
03-16 1237
本人在使用httpclient做接口测试的过程中，之前并没有考虑到请求失败自动重试的情况，但有时又需要在发生某些错误的时候重试，比如超时，比如响应频繁被拒绝等等，在看过官方的示例后，自己写了一个自动重试的控制器。分享代码，供大家参考。下面是获取控制器的方法：/*** 获取重试控制器** @return*/private static HttpRequestRetryHandler getHttpR...
Java 调用Http请求重试机制
记录工作开发中遇到的技术难点，方便自己查看，也希望可以帮助到他人...
11-16 452
Java 调用Http请求重试机制
聊聊接口重试机制的几种解决方案
热门推荐
Venus's Blog
11-06 1万+
接口请求重试机制是保证系统稳定性和容错能力的重要手段之一。当接口请求发生失败或暂时性错误时,通过重试机制可以提高请求的成功率。本文将详细介绍接口请求重试机制的几种常见方法。// 可在此处自定义重试逻辑});Spring Retry 为接口请求重试提供了完善和易用的解决方案,可以灵活控制各种重试参数,适用于复杂系统的容错要求。使用自定义的重试工具类来实现接口请求的重试机制,提高代码的复用性和可维护性。提供重试方法,参数包括请求函数、重试策略等在重试方法内部执行循环请求。
【Java】已解决java.net.ProtocolException异常
屿小夏.的知识博客
06-21 713
在Java的网络编程中，java.net.ProtocolException异常通常表示在网络通信过程中，客户端或服务器违反了某种协议规则。在这个修正后的示例中，我们使用了POST请求方法，并正确设置了请求体内容类型。如果请求需要包含请求体，就应该使用POST、PUT等允许包含请求体的请求方法。在这个示例中，我们尝试在GET请求中包含请求体，这是不符合HTTP协议规范的，因此可能会导致ProtocolException。为了修复上述错误，我们需要根据HTTP协议规范来正确设置请求方法和处理请求体。
Java接口请求失败重试机制
llp1990311的博客
05-06 6956
一、SpringRetry 1、引入maven依赖 <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency> <dependency> &l
java：接口请求超时的情况
m0_38127564的博客
02-19 7596
java：接口请求超时的情况
java接口异常重试机制实现（guava-retrying方式）
xieedeni的博客
04-26 4162
java重试机制实现guava-retrying
接口请求重试策略：保障稳定性的必杀技
todoitbo的博客
10-31 1222
Spring retry；接口重试机制实现
Java基于Guava Retrying实现重试功能
08-18
Java基于Guava Retrying实现重试功能是指在Java编程中使用Guava-Retrying库来实现重试功能，以便在执行任务过程中遇到失败或异常时能够自动重试，确保任务的可靠性和稳定性。下面是该知识点的详细说明： 1. Guava-...
Java接口自动化测试框架设计之Get请求方法和测试详解
08-25
通过这样的步骤，我们可以构建一个简单的Java接口自动化测试框架，支持GET请求的测试。随着需求的增加，可以逐步扩展框架，添加POST、PUT、DELETE等其他HTTP方法的支持，以及参数处理、断言、报告生成等功能，使其...
Java编程Retry重试机制实例详解
08-28
Java编程中的Retry重试机制是一种常见的 fault-tolerant 机制，用于处理远程调用或网络请求失败的情况。该机制可以在出现异常或错误时，自动重试执行操作，以提高系统的可用性和稳定性。在本文中，我们将详细介绍...
RestTemplate请求失败自动重试机制.docx
06-26
"RestTemplate请求失败自动重试机制"就是一个解决这个问题的策略。在上一节中，我们学习了如何自定义RestTemplate的异常处理，但那并不适用于自动重试。本节我们将探讨如何利用Spring Retry库来实现RestTemplate的...
HttpRequestsWrapper:使通过java发送Http请求更容易
06-07
8. **重试机制**：在某些网络不稳定的情况下，`HttpRequestsWrapper`可能会包含自动重试的功能，以便在网络恢复后继续尝试请求。 9. **线程安全**：由于HTTP请求可能在多线程环境中执行，`HttpRequestsWrapper`需要...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 197
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 614
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 530
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 572
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值