精华内容
下载资源
问答
  • Java通用接口响应封装

    万次阅读 2020-01-14 00:42:07
    Java接口响应封装 Web开发中,前后分离是个趋势,现在大部分公司研发部门已经在走前后分离的路子了,前后分离开发各司其职能够有效的提高工作效率和开发质量。 REST接口会返回各种各样的数据,如果对接口的格式不...

    Java接口响应封装类

    Web开发中,前后分离是个趋势,现在大部分公司研发部门已经在走前后分离的路子了,前后分离开发各司其职能够有效的提高工作效率和开发质量。

    REST接口会返回各种各样的数据,如果对接口的格式不加约束,很容易造成混乱。

    在实际项目中,一般会把结果放在一个封装类中,封装类中包含http状态值,状态消息,以及实际的数据。

    个人总结一下工作中用到的接口响应类。😃

    • 状态枚举,接口响应状态码、消息,统一在此枚举类中定义,方便阅读、修改。
    /**
     * 响应状态码枚举
     * @author liuyang
     * 2020-01-13
     */
    public enum CodeEnum {
    
        SUCCESS(0, "成功"),
        FAIL(1, "失败"),
        ;
    
        private final Integer code;
    
        private final String msg;
      // 省略枚举构造方法、get、set方法
    }
    
    • 数据响应基类,方便以后扩展子类,也可用于增、删、改相关接口响应。
    /**
     * 响应数据基类
     * @author liuyang
     * 2020-01-13
     */
    public class BaseResponse {
    
        /**
         * 状态码
         */
        private Integer code;
    
        /**
         * 响应消息
         */
        private String msg;
    
        protected BaseResponse() {}
    
        protected BaseResponse(CodeEnum code) {
            this.code = code.getCode();
            this.msg = code.getMsg();
        }
      // 省略get/set方法
    }
    
    • 响应数据体,继承自 BaseResponse 类,增加了 范型 属性,方便响应各种数据。
    /**
     * 响应数据体
     * @author liuyang
     * 2020-01-13
     */
    public class ResponseData<T> extends BaseResponse {
    
        /**
         * 数据
         */
        private T data;
    
        private ResponseData(CodeEnum code) {
            super(code);
        }
    
        private ResponseData(CodeEnum code, T data) {
            super(code);
            this.data = data;
        }
    
        /**
         * 对外开放基础响应体已供调用,可用于增、删、改接口操作
         */
        public static BaseResponse out(CodeEnum code) {
            return new BaseResponse(code);
        }
    
        /**
         * 对外开放数据响应体已供调用,可用于查询数据实用,引用了范型设计,支持各种数据类型
         */
        public static <T> ResponseData<T> out(CodeEnum code, T data) {
            return new ResponseData<>(code, data);
        }
      // 省略get/set方法
    }
    

    以上三个类足可以满足日常开发,顺带说一句,CodeEnum枚举类也可用于定义处于业务异常逻辑,比如:抛出用户不存在的异常,然后配合Spring MVC的 @ControllerAdvice注解,统一响应异常信息。(如果不明白,可在评论区说明,可以考虑再出一篇针对异常处理的文章)

    进入测试------------------------

    • 基础响应,此处模拟删除
    @GetMapping("/user/del/{userId}")
    public BaseResponse delUser(@PathVariable Integer userId) {
    	return ResponseData.out(CodeEnum.FAIL);
    }
    

    访问:localhost:8080/user/del/1

    响应:

    {
        "code": 1,
        "msg": "失败"
    }
    
    • 数据体响应,此处模拟用户列表
    @GetMapping("/user-info")
    public ResponseData<List<String>> userInfo() {
      List<String> list = new ArrayList<>();
      list.add(UUID.randomUUID().toString());
      list.add(UUID.randomUUID().toString());
      list.add(UUID.randomUUID().toString());
      list.add(UUID.randomUUID().toString());
      return ResponseData.out(CodeEnum.SUCCESS, list);
    }
    

    访问:localhost:8080/user-info

    响应:

    {
        "code": 0,
        "msg": "成功",
        "data": [
            "003252cf-3361-43c4-8fdc-b9091f83ea05",
            "6320cd96-ae04-4885-ac78-76241f19ac95",
            "34cdd394-97d4-4e7d-993f-e4688b86d0e0",
            "bd293a9e-465b-4796-b8fa-17fc37de9bf7"
        ]
    }
    

    以上,测试成功。

    PS:可在此基础上加入一些符合自己需要的属性,比如:响应时间戳、响应标识等等…

    展开全文
  • 利用AOP监控Java接口响应超时

    千次阅读 2018-10-11 20:47:06
     服务化接口是提供服务的,接口正确性、稳定性是最最重要的,在保证正确的同时需要尽量提高接口响应时间。  有的团队会有专门的工具来对系统响应时间、吞吐量做监控,但如果团队没有这种“待遇”就需要自己来做...

     

    为什么要监控

      服务化接口是提供服务的,接口正确性、稳定性是最最重要的,在保证正确的同时需要尽量提高接口响应时间。

      有的团队会有专门的工具来对系统响应时间、吞吐量做监控,但如果团队没有这种“待遇”就需要自己来做一些工具为自己的代码提供服务。

    自己动手,丰衣足食

      AOP + Annotation 简陋实现,能达到目的

      AOP : 使用环绕方式对接口拦截,在拦截接口前后记录时间最后计算用时

      Annotation : 自定义注解在接口上设置超时时间(timeout)和超时是否发送邮件选项(emailIfTimeout)

      通过对接口实际执行时间和配置的超时时间比较,系统可以计算出接口是否超时,此时可使用日志(或其他能通知到开发人员的方式)记录具体哪个接口、什么参数以及执行时间

      注解可以提供更多的选项,来为自己接口服务,比如支持注解到类上,批量为接口设置了默认超时时间、支持日志中显示的处理方法名称 等等...

    代码实施

    接口Annotation定义

    package opsteel.oupuzw.web.logistics.bean;
    
    import org.springframework.core.annotation.AliasFor;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 创建自定义注解输出接口耗时(@PrintCostTime)
     * create on 2018-08-08
     * @author Yesh
     */
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface PrintCostTime {
    
        /** 输出方法名称 **/
        @AliasFor("name")
        String name() default "";
    
        /**
         * 接口超时时间,单位毫秒.默认值100毫秒
         * @return 设置的超时时间
         */
        int timeout() default 100;
    
        /**
         * 注解上的打印参数
         * @return 输出的时候打印出来
         */
        String[] printArgs() default {};
    
        /**
         * 是否开启日志监控功能默认开
         * @return 返回ture需要发送邮件
         */
        boolean enablePrint() default true;
    
        /**
         * 是否允许打印在默认列表里的参数(默认 true)
         * @return
         */
        boolean enablePrintDefaultArgs() default true;
    
        /**
         * 当接口响应超时时,是否发送邮件.默认发送
         * @return 返回ture需要发送邮件
         */
        boolean emailIfTimeout() default true;
    }
    
    package opsteel.oupuzw.web.logistics.bean;
    
    import lombok.extern.log4j.Log4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * 日志AOP监控接口响应时长
     * create on 2018-08-08
     *
     * @author Yesh
     */
    @Component
    @Aspect
    @Log4j
    public class PrintCostTimeAspect {
    
        @Around("@annotation(opsteel.oupuzw.web.logistics.bean.PrintCostTime)")
        public Object aroundPrintCostTime(ProceedingJoinPoint pjp) throws Throwable {
            MethodSignature signature = (MethodSignature) pjp.getSignature(); //方法签名
            PrintCostTime printCostTime = signature.getMethod().getAnnotation(PrintCostTime.class);//从签名注解中获取注解内容配置项
            String methodCName = printCostTime.name();//方法中文名称[注解中获取 不填写 为""]
            String methodName = signature.getName();
            //        Class clazz = pjp.getTarget().getClass();  //取拦截的Class
            //RequestMapping requestMapping = signature.getMethod().getAnnotation(RequestMapping.class);//从这里可以获取 请求地址
            //方法名和参数值
            //String[] ArgsNames = signature.getParameterNames();
            //Object[] argsValue = pjp.getArgs();
            //参数打印目前没必要 result 中可以获取 返回的json值
    //        String argsLog = getArgsLog(printCostTime, ArgsNames, argsValue);
    
            long start = System.currentTimeMillis();  //开始时间
            Object[] args = pjp.getArgs(); //取拦截的Args
            Object result = pjp.proceed(args);  //运行被拦截的方法
            if (printCostTime.enablePrint()==false){ //若开关为 true 开启打印
                return result;
            }
    
            long end = System.currentTimeMillis();
            long diff = end - start;//计算耗时
    
            //若超过配置的阀值则打印耗时日志
            long thresholdInMs = printCostTime.timeout();
            if (diff >= thresholdInMs) {
                log.info(methodCName + ":[" + methodName + "]" + ",响应时间: " + diff + " ms");
                //发邮件发作即可
            }
            return result;
        }
    
    }
    

     

    @PrintCostTime(name = "XXX")

    在Controller注解上即可描述当前接口花费时间

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • java 打印请求接口响应时间

    千次阅读 2020-01-07 09:49:42
    long start = System.currentTimeMillis(); //访问接口 long end = System.currentTimeMillis(); System.out.println("耗时:" + (end - start) + "ms");
    long start = System.currentTimeMillis();
    //访问接口
    long end = System.currentTimeMillis();
    System.out.println("耗时:" + (end - start) + "ms");
    
    展开全文
  • java响应实体封装

    千次阅读 2020-06-11 10:24:49
    前后端分离的开发模式中,或者与第三方接口交互,需要规范接口响应,下面是我在开发中的封装的一组响应实体

    前后端分离的开发模式中,或者与第三方接口交互,需要规范接口响应,下面是我在开发中的封装的一组响应实体类

    • 响应实体父类, 父类中需要一个code,因为不管是响应消息还是数据,都要有code
    /**
     - @title 响应实体父类
     - @author gavin
     - @date 2020年6月10日
     */
    public class Response {
    	
    	private String code;
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    }
    
    • 信息响应实体类,继承Response类,并且需要添加一个msg属性,用于存储返回码描述
    /**
     * @title 消息响应实体类
     * @author gavin
     * @date 2020年6月10日
     */
    public class ResponseMsg extends Response {
    
    	private String msg;
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    }
    
    • 数据响应实体类,继承Response类,并且需要添加一个data属性,用来存储响应数据
    /**
     * @title 数据响应实体类
     * @author gavin
     * @date 2020年6月10日
     */
    public class ResponseData extends Response{
    
    	private Object data;
    
    	public Object getData() {
    		return data;
    	}
    
    	public void setData(Object data) {
    		this.data = data;
    	}
    }
    

    接下来就可以使用了,新建RspController测试一下响应错误信息和响应数据

    @RestController
    @RequestMapping("rsp")
    public class RspController {
    	
    	@GetMapping("msg")
    	public Response msg() {
    		ResponseMsg responseMsg = new ResponseMsg();
    		responseMsg.setCode("401");
    		responseMsg.setMsg("用户无权限");
    		return responseMsg;
    	}
    	
    	@GetMapping("data")
    	public Response data() {
    		ResponseData responseData = new ResponseData();
    		responseData.setCode("0");
    		Map<String,Object> map = new HashMap<String,Object>();
    		map.put("name", "张三");
    		map.put("age", 24);
    		responseData.setData(map);
    		return responseData;
    	}
    }
    

    启动项目,使用postman访问一下

    1. 访问/rsp/msg接口,postman收到响应如下
      在这里插入图片描述
    2. 访问/rsp/data接口,postman收到响应如下
      在这里插入图片描述

    开发中,返回码通常都是共用的,不需要每个接口都写一遍硬代码,我们可以对全局错误码封装一个枚举类

    public enum ResponseEnum {
    	
    	SUCCESS("0" , "ok"),
    	AUTH_DENIED("401","用户无权限");
    	
    	private String code;
    	private String msg;
    	
    	ResponseEnum(String code , String msg){
    		this.code = code;
    		this.msg = msg;
    	}
    	
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}	
    }
    

    有了全局返回码枚举类后,/rsp/msg接口中就不要写硬代码了,可以改成如下

    @GetMapping("msg")
    public Response msg() {
    	ResponseMsg responseMsg = new ResponseMsg();
    	responseMsg.setCode(ResponseEnum.AUTH_DENIED.getCode());
    	responseMsg.setMsg(ResponseEnum.AUTH_DENIED.getMsg());
    	return responseMsg;
    }
    

    虽然这样避免了多处使用硬代码的问题,但还是有些繁琐,我们还可以编写一个ResponseUtil类,来简化开发

    /**
     * @title 响应工具类
     * @author gavin
     * @date 2020年6月11日
     */
    public class ResponseUtil {
    	/**
    	 * @title 成功返回码
    	 * @author gavin
    	 * @date 2020年6月11日
    	 * @return
    	 */
    	public static Response success() {
    		ResponseMsg response = new ResponseMsg();
    		response.setCode(ResponseEnum.SUCCESS.getCode());
    		response.setMsg(ResponseEnum.SUCCESS.getMsg());
    		return response;
    	}
    	
    	
    	/**
    	 * @title 通用返回码
    	 * @author gavin
    	 * @date 2020年6月11日
    	 * @return
    	 */
    	public static Response rspMsg(String code , String msg) {
    		ResponseMsg response = new ResponseMsg();
    		response.setCode(code);
    		response.setMsg(msg);
    		return response;
    	}
    	
    	/**
    	 * @title 通用返回码
    	 * @author gavin
    	 * @date 2020年6月11日
    	 * @return
    	 */
    	public static Response rspMsg(ResponseEnum responseEnum) {
    		ResponseMsg response = new ResponseMsg();
    		response.setCode(responseEnum.getCode());
    		response.setMsg(responseEnum.getMsg());
    		return response;
    	}
    	
    	/**
    	 * @title 响应数据
    	 * @author gavin
    	 * @date 2020年6月11日
    	 * @param data
    	 * @return
    	 */
    	public static Response rspData(Object data) {
    		ResponseData response = new ResponseData();
    		response.setCode(ResponseEnum.SUCCESS.getCode());
    		response.setData(data);
    		return response;
    	}
    }
    

    ResponseUtil类中封装了4个方法,基本上够我们日常开发使用了,接下来我们可以用这个工具类来简化一下/rsp/msg接口和/rsp/data接口,代码如下

    @RestController
    @RequestMapping("rsp")
    public class RspController {
    	
    	@GetMapping("msg")
    	public Response msg() {
    		return ResponseUtil.rspMsg(ResponseEnum.AUTH_DENIED);
    	}
    	
    	@GetMapping("data")
    	public Response data() {
    		
    		Map<String,Object> map = new HashMap<String,Object>();
    		map.put("name", "张三");
    		map.put("age", 24);
    		
    		return ResponseUtil.rspData(map);
    	}
    }
    

    通过工具类简化后,基本上响应代码就只需要一行就可以了,大大简化了我们的代码。

    展开全文
  • Java 接口请求异步响应

    万次阅读 2018-01-08 17:38:56
    所以需要在接口请求过来时,就先响应,再去执行业务逻辑。 1.创建一个Controller用来接收接口请求 @RestController @RequestMapping("/test") public class Controller { private static Logger log = Logg
  • package com.trs.szdp.admin_manager.utils; import lombok.Data; /** * 用户返回统一接口 */ @Data public class RespBody { private String code; private Object body; private String message; ...
  • java9 响应式编程支持

    千次阅读 2019-02-01 14:52:57
    java9开始,官方支持了响应式编程规范,提供了顶级的响应式编程接口java11开始,官方提供了支持http2的、友好的http客户端java.net.http,该客户端就是jdk内部第一个基于响应式编程规范的实现。 响应式编程接口 ...
  • java按钮响应

    千次阅读 2013-11-08 13:31:34
    要让C的对象响应按钮btn的单击信号,需要让C实现ActionListener接口声明 public class C implements ActionListener C中要实现actionPerformed方法: public void actionPerformed(ActionEvent e) { //...
  • java响应请求下载文件的http接口

    千次阅读 2018-07-04 13:55:03
    工具代码: public static byte [] File2byte(File file){ byte [] buffer = null; 尝试{ FileInputStream fis = new FileInputStream(file); ByteArrayOutputStream bos = new ...
  • 文章目录Spring Boot统一REST API接口响应格式和异常处理前言定义统一的接口响应格式接口调用成功时返回统一的接口响应格式发生异常时返回统一的接口响应格式参考文档 Spring Boot统一REST API接口响应格式和异常...
  • java】内部向上转型为接口例子

    千次阅读 2016-04-11 14:51:08
    1.内部向上转型为接口可以完全...3.这种技巧经常被应用在swing编程中,可以在一个中做出不同的响应事件。 interface method{ int add(); } public class Main{ A a = new A(); B b = new B(); C c = new C()
  • java web开发(二) 接口开发

    万次阅读 多人点赞 2016-06-03 16:50:34
    java web开发(一) 环境搭建讲解了如何搭建一个Java Web项目,如果你还没了解,建议先浏览下!今天这篇文章主要讲解的就是接口开发,打算使用比较古老的或者说比较原始方法实现的接口。 一.数据库设计。 假设要做...
  • 2、实现相关事件监听接口 3、注册事件源的动作监听器 4、事件触发时的事件处理 相应的可以通过以下的集中方式来作出事件响应。 一、容器监听 效果:单击窗体中的三个按钮,实现相应的相应时间。 ...
  • java api 错误码设计,枚举错误码设计以及请求响应返回错误码的使用,源码及举例 错误码设计 错误码采用枚举实现,错误码从1001开始,主要是不想和http请求状态码重复比如200,404等。错误码数值怎么给,看自己项目需求...
  • JAVA 调用API接口 工具(get post )

    千次阅读 2019-06-20 14:23:35
    1.代码如下 package ... import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;...import java.io.PrintWriter;...import java.util.*...
  • Jmeter之Java接口调用

    千次阅读 2018-08-21 09:18:18
    通常用jmeter做http请求(或者其他类型)测试时,有时需要对请求的数据(或者响应的数据)进行特定的处理再进行请求,如加密、解密,需自己用java编写一些工具;或者需要对Java接口服务进行性能测试时,需要用到...
  • java设置接口访问超时,自动响应

    万次阅读 2018-08-31 09:56:14
    查了大量资料后发现,java早已经给我们提供了解决方案。jdk1.5自带的并发库中Future就能满足这个需求。Future中重要方法包括get()和cancel()。get()获取数据对象,如果数据没有加载,就会阻塞直到取到数据,而 ...
  • java接口用法:向上转型和接口回调

    千次阅读 2015-12-25 11:47:55
    java接口或抽象都可以使用向上转型,它们用的都是java运行时多态技术,或者叫运行期绑定技术。 下面是一个java接口向上转型的例子: interface People{ void peopleList(); } class Student implements P
  • Java接口测试java代码

    千次阅读 2017-04-15 16:38:02
    //1.新建一个客户端对象 CloseableHttpClient ...使用URLBuilder工具构造一个get类型的url,来设置协议的 URI url=new URIBuilder().setScheme("https")//设置接口使用的协议 .setHost("api.weixin.qq.com")//

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 354,127
精华内容 141,650
关键字:

java接口响应类

java 订阅