devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

@RequestAttribute,@RequestBody 注解,代码实现分页查询

作者：小蓝xlanll | 2024-03-25 13:16:03

赞

踩

requestattribute

@RequestAttribute,@RequestBody 注解,代码实现分页查询

1. @RequestAttribute注解

@RequestAttribute 获取request请求域中的数据

测试如下：

发起post请求

2、@RequestBody 注解

@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)；而最常用的使用请求体传参的无疑是POST请求了，所以使用@RequestBody接收数据时，一般都用POST方式进行提交。在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。

  1. 注：一个请求，只有一个RequestBody；一个请求，可以有多个RequestParam。
  2.  
  3. 注：当同时使用@RequestParam()和@RequestBody时，@RequestParam()指定的参数可以是普通元素、
  4.        数组、集合、对象等等(即:当，@RequestBody 与@RequestParam()可以同时使用时，原SpringMVC接收
  5.        参数的机制不变，只不过RequestBody 接收的是请求体里面的数据；而RequestParam接收的是key-value
  6.        里面的参数，所以它会被切面进行处理从而可以用普通元素、数组、集合、对象等接收)。
  7.        即：如果参数时放在请求体中，application/json传入后台的话，那么后台要用@RequestBody才能接收到；
  8.              如果不是放在请求体中的话，那么后台接收前台传过来的参数时，要用@RequestParam来接收，或
  9.              则形参前 什么也不写也能接收。
  10.  
  11. 注：如果参数前写了@RequestParam(xxx)，那么前端必须有对应的xxx名字才行(不管其是否有值，当然可以通
  12.        过设置该注解的required属性来调节是否必须传)，如果没有xxx名的话，那么请求会出错，报400。
  13.  
  14. 注：如果参数前不写@RequestParam(xxx)的话，那么就前端可以有可以没有对应的xxx名字才行，如果有xxx名
  15.        的话，那么就会自动匹配；没有的话，请求也能正确发送。
  16.        追注：这里与feign消费服务时不同；feign消费服务时，如果参数前什么也不写，那么会被默认是
  17.                   @RequestBody的。
  1. 后端@RequestBody注解对应的类在将HTTP的输入流(含请求体)装配到目标类(即：@RequestBody后面的类)时，会根据json字符串中的key来匹配对应实体类的属性，如果匹配一致且json中的该key对应的值符合(或可转换为)，这一条我会在下面详细分析，其他的都可简单略过，但是本文末的核心逻辑代码以及几个结论一定要看！ 实体类的对应属性的类型要求时,会调用实体类的setter方法将值赋给该属性。
  2.  
  3. json字符串中，如果value为""的话，后端对应属性如果是String类型的，那么接受到的就是""，如果是后端属性的类型是Integer、Double等类型，那么接收到的就是null。
  4.  
  5. json字符串中，如果value为null的话，后端对应收到的就是null。
  6.  
  7. 如果某个参数没有value的话，在传json字符串给后端时，要么干脆就不把该字段写到json字符串中；要么写value时， 必须有值，null  或""都行。千万不能有类似"stature":，这样的写法，如:

测试如下：

查看后端：

3.mybatis 中的注解的常用方法

mapper层

  1. package com.bcht.api.mapper;
  2.  
  3. import org.apache.ibatis.annotations.*;
  4. import org.apache.ibatis.type.JdbcType;
  5.  
  6. import java.util.List;
  7. import java.util.Map;
  8.  
  9. /**
  10.  * 接口注册
  11.  */
  12. @Mapper
  13. public interface TMsOuterInterfaceMapper {
  14.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "listSystem")
  15.     List<Map> listSystem(@Param("registerId") Integer registerId);
  16.  
  17.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "listIntefaceByRegisterId")
  18.     List<Map> listIntefaceByRegisterId(@Param("registerId") Integer registerId);
  19.  
  20.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "listParamsByInterfaceId")
  21.     List<Map> listParamsByInterfaceId(@Param("interfaceId") Integer interfaceId);
  22.  
  23.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "getParamNumById")
  24.     int getParamNumById(@Param("dirId") Integer dirId);
  25.  
  26.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "getDetailById")
  27.     List<Map> getDetailById(@Param("dirId") Integer dirId);
  28.  
  29.     @Results(value = {@Result(property = "interface_id", column = "interface_id", id = true, javaType = Integer.class, jdbcType = JdbcType.INTEGER)
  30.     })
  31.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "getIdByCode")
  32.     int getIdByCode(@Param("interfaceCode") String interfaceCode);
  33.  
  34.     @InsertProvider(type = TMsOuterInterfaceMapperProvider.class, method = "createInterface")
  35.     int createInterface(@Param("interface_name") String interface_name,
  36.                         @Param("interface_code") String interface_code,
  37.                         @Param("register_id") Integer register_id,
  38.                         @Param("run_status") String run_status,
  39.                         @Param("raw_url") String raw_url,
  40.                         @Param("req_method") String req_method,
  41.                         @Param("desc") String desc,
  42.                         @Param("create_user") String create_user,
  43.                         @Param("now") String now);
  44.  
  45.     @UpdateProvider(type = TMsOuterInterfaceMapperProvider.class, method = "updateInterface")
  46.     int updateInterface(@Param("interface_id") Integer interface_id,
  47.                         @Param("interface_name") String interface_name,
  48.                         @Param("interface_code") String interface_code,
  49.                         @Param("register_id") Integer register_id,
  50.                         @Param("run_status") String run_status,
  51.                         @Param("raw_url") String raw_url,
  52.                         @Param("req_method") String req_method,
  53.                         @Param("desc") String desc,
  54.                         @Param("update_user") String update_user,
  55.                         @Param("now") String now);
  56.  
  57.  
  58.     @UpdateProvider(type = TMsOuterInterfaceMapperProvider.class, method = "updateInterfaceStatus")
  59.     int updateInterfaceStatus(@Param("update_user") String update_user,
  60.                               @Param("run_status") String run_status,
  61.                               @Param("now") String now,
  62.                               @Param("interfaceId") Integer interfaceId);
  63.  
  64.     @UpdateProvider(type = TMsOuterInterfaceMapperProvider.class, method = "deleteInterface")
  65.     int deleteInterface(@Param("dirId") Integer dirId);
  66.  
  67.     @DeleteProvider(type = TMsOuterInterfaceMapperProvider.class, method = "deleteParams")
  68.     int deleteParams(@Param("interfaceId") Integer interfaceId);
  69.  
  70.     @Results(value = {@Result(property = "run_status", column = "run_status", javaType = String.class, jdbcType = JdbcType.VARCHAR)
  71.     })
  72.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "checkSystemStatus")
  73.     String checkSystemStatus(@Param("interfaceId") Integer interfaceId);
  74.  
  75.     @Results(value = {@Result(property = "interface_code", column = "interface_code", javaType = String.class, jdbcType = JdbcType.VARCHAR),
  76.             @Result(property = "interface_name", column = "interface_name", javaType = String.class, jdbcType = JdbcType.VARCHAR)
  77.     })
  78.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "checkRepeat")
  79.     List<Map> checkRepeat(@Param("interfaceId") Integer interfaceId);
  80.  
  81.  
  82.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "queryPageResultList")
  83.     List<Map> queryPageResultList(@Param("searchVal") String searchVal,
  84.                                   @Param("offset") Integer offset,
  85.                                   @Param("pageSize") Integer pageSize);
  86.  
  87.     @SelectProvider(type = TMsOuterInterfaceMapperProvider.class, method = "countResultList")
  88.     Integer countResultList(@Param("searchVal") String searchVal,
  89.                             @Param("offset") Integer offset,
  90.                             @Param("pageSize") Integer pageSize);
  91.  
  92. }

对用的实现类

  1. package com.bcht.api.mapper;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.apache.ibatis.jdbc.SQL;
  5.  
  6. import java.text.MessageFormat;
  7. import java.util.List;
  8. import java.util.Map;
  9.  
  10. public class TMsOuterInterfaceMapperProvider {
  11.  
  12.     private static final String TABLE_SYSTEM = "t_ms_outer_register";
  13.  
  14.     private static final String TABLE_INTERFACE = "t_ms_outer_interface";
  15.  
  16.     private static final String TABLE_PARAMS = "t_ms_outer_interface_params";
  17.  
  18.     public String listSystem(Map<String, Object> parameter) {
  19.         return new SQL() {{
  20.             SELECT(" * ");
  21.             FROM(TABLE_SYSTEM);
  22.             Object registerId = parameter.get("registerId");
  23.             if (registerId != null && StringUtils.isNotEmpty(registerId.toString())) {
  24.                 WHERE("register_id=#{registerId}");
  25.             }
  26.             WHERE(" run_status <> '0' ");
  27.  
  28.         }}.toString();
  29.     }
  30.  
  31.  
  32.     public String listIntefaceByRegisterId(Map<String, Object> parameter) {
  33.         return new SQL() {{
  34.             SELECT(" * ");
  35.             FROM(TABLE_INTERFACE);
  36.             Object registerId = parameter.get("registerId");
  37.             if (registerId != null && StringUtils.isNotEmpty(registerId.toString())) {
  38.                 WHERE("register_id=#{registerId}");
  39.             }
  40.             WHERE(" run_status <> '0' ");
  41.             ORDER_BY(" update_time desc ");
  42.  
  43.         }}.toString();
  44.     }
  45.  
  46.     public String listParamsByInterfaceId(Map<String, Object> parameter) {
  47.         return new SQL() {{
  48.             SELECT(" * ");
  49.             FROM(TABLE_PARAMS);
  50.             Object interfaceId = parameter.get("interfaceId");
  51.             if (interfaceId != null && StringUtils.isNotEmpty(interfaceId.toString())) {
  52.                 WHERE("interface_id=#{interfaceId}");
  53.             }
  54.  
  55.         }}.toString();
  56.     }
  57.  
  58.     public String getParamNumById(Map<String, Object> parameter) {
  59.         return new SQL() {{
  60.             SELECT(" count(1) cnt ");
  61.             FROM(TABLE_PARAMS);
  62.             WHERE("interface_id=#{dirId}");
  63.         }}.toString();
  64.     }
  65.  
  66.     public String getDetailById(Map<String, Object> parameter) {
  67.         return new SQL() {{
  68.             SELECT(" * ");
  69.             FROM(TABLE_INTERFACE);
  70.             WHERE("interface_id=#{dirId}");
  71.             WHERE(" run_status <> '0' ");
  72.         }}.toString();
  73.     }
  74.  
  75.  
  76.     public String getIdByCode(Map<String, Object> parameter) {
  77.         return new SQL() {
  78.             {
  79.                 SELECT(" interface_id ");
  80.                 FROM(TABLE_INTERFACE);
  81.                 WHERE("`interface_code`=#{interfaceCode}");
  82.                 WHERE(" run_status <> '0' ");
  83.             }
  84.         }.toString();
  85.     }
  86.  
  87.  
  88.     public String createInterface(Map<String, Object> parameter) {
  89.         return new SQL() {{
  90.             INSERT_INTO(TABLE_INTERFACE);
  91.             VALUES("`interface_name`", "#{interface_name}");
  92.             VALUES("`interface_code`", "#{interface_code}");
  93.             VALUES("`register_id`", "#{register_id}");
  94.             VALUES("`run_status`", "#{run_status}");
  95.             VALUES("`raw_url`", "#{raw_url}");
  96.             VALUES("`req_method`", "#{req_method}");
  97.             VALUES("`desc`", "#{desc}");
  98.             VALUES("`create_user`", "#{create_user}");
  99.             VALUES("`create_time`", "#{now}");
  100.         }}.toString();
  101.  
  102.     }
  103.  
  104.  
  105.     public String updateInterface(Map<String, Object> parameter) {
  106.         return new SQL() {{
  107.             UPDATE(TABLE_INTERFACE);
  108.             SET("`interface_name` = #{interface_name}");
  109.             SET("`interface_code` = #{interface_code}");
  110.             SET("`register_id` = #{register_id}");
  111.             SET("`run_status` = #{run_status}");
  112.             SET("`raw_url` = #{raw_url}");
  113.             SET("`req_method` = #{req_method}");
  114.             SET("`desc` = #{desc}");
  115.             SET("`update_user` = #{update_user}");
  116.             SET("`update_time` = #{now}");
  117.             WHERE("`interface_id` = #{interface_id}");
  118.         }}.toString();
  119.  
  120.     }
  121.  
  122.     public String updateInterfaceStatus(Map<String, Object> parameter) {
  123.         return new SQL() {{
  124.             UPDATE(TABLE_INTERFACE);
  125.             SET("`run_status` = #{run_status}");
  126.             SET("`update_user` = #{update_user}");
  127.             SET("`update_time` = #{now}");
  128.             WHERE("`interface_id` = #{interfaceId}");
  129.         }}.toString();
  130.  
  131.     }
  132.  
  133.     public String deleteInterface(Map<String, Object> parameter) {
  134.         return new SQL() {{
  135.             UPDATE(TABLE_INTERFACE);
  136.             SET("`run_status` = '0' ");
  137.             WHERE("`interface_id`=#{dirId}");
  138.         }}.toString();
  139.     }
  140.  
  141.     public String deleteParams(Map<String, Object> parameter) {
  142.         return new SQL() {{
  143.             DELETE_FROM(TABLE_PARAMS);
  144.             Object interfaceId = parameter.get("interfaceId");
  145.             if (interfaceId != null && StringUtils.isNotEmpty(interfaceId.toString())) {
  146.                 WHERE(" interface_id = #{interfaceId} ");
  147.             }
  148.         }}.toString();
  149.     }
  150.  
  151.  
  152.     public String checkSystemStatus(Map<String, Object> parameter) {
  153.         return new SQL() {{
  154.             SELECT(" b.run_status ");
  155.             FROM(TABLE_INTERFACE + " a ");
  156.             LEFT_OUTER_JOIN(TABLE_SYSTEM + " b on a.register_id = b.register_id ");
  157.             Object interfaceId = parameter.get("interfaceId");
  158.             if (interfaceId != null && StringUtils.isNotEmpty(interfaceId.toString())) {
  159.                 WHERE(" a.interface_id = #{interfaceId} ");
  160.             }
  161.         }}.toString();
  162.     }
  163.  
  164.     public String checkRepeat(Map<String, Object> parameter) {
  165.         return new SQL() {{
  166.             SELECT(" interface_code,interface_name ");
  167.             FROM(TABLE_INTERFACE);
  168.             Object interfaceId = parameter.get("interfaceId");
  169.             if (interfaceId != null && StringUtils.isNotEmpty(interfaceId.toString())) {
  170.                 WHERE(" interface_id <> #{interfaceId} ");
  171.             }
  172.             WHERE(" run_status <> '0' ");
  173.             GROUP_BY(" interface_code,interface_name ");
  174.         }}.toString();
  175.     }
  176.  
  177.  
  178.     public String queryPageResultList(Map<String, Object> parameter) {
  179.         return new SQL() {{
  180.             SELECT(" a.*,b.register_name ");
  181.             FROM(TABLE_INTERFACE + " a ");
  182.             LEFT_OUTER_JOIN(TABLE_SYSTEM + " b on a.register_id = b.register_id ");
  183.             Object searchVal = parameter.get("searchVal");
  184.             if (searchVal != null && StringUtils.isNotEmpty(searchVal.toString())) {
  185.                 WHERE(" a.interface_name like concat('%', '" + parameter.get("searchVal").toString() + "', '%')");
  186.             }
  187.             WHERE(" a.run_status <> '0' ");
  188.             ORDER_BY(" a.update_time desc limit #{offset},#{pageSize} ");
  189.  
  190.         }}.toString();
  191.     }
  192.  
  193.     public String countResultList(Map<String, Object> parameter) {
  194.         return new SQL() {{
  195.             SELECT(" count(1) ");
  196.             FROM(TABLE_INTERFACE);
  197.             Object searchVal = parameter.get("searchVal");
  198.             if (searchVal != null && StringUtils.isNotEmpty(searchVal.toString())) {
  199.                 WHERE("interface_name like concat('%', '" + parameter.get("searchVal").toString() + "', '%')");
  200.             }
  201.             WHERE(" run_status <> '0' ");
  202.             ORDER_BY(" update_time desc limit #{offset},#{pageSize} ");
  203.         }}.toString();
  204.     }
  205.  
  206. }

4、通过pageNum和pageSize 实现分页查询

通过页数和每页有多少数据量，求得偏移量，然后通过 limit 偏移量，数量。求得查询的数据，然后做展示就行了、

代码如下：

Controller层：

  1. /**
  2.      * 分页查询
  3.      *
  4.      * @param loginUser
  5.      * @param searchVal
  6.      * @param pageNo
  7.      * @param pageSize
  8.      * @return
  9.      */
  10.     @GetMapping("/list-paging")
  11.     public Result listPaging(@RequestAttribute(value = Constants.SESSION_USER) User loginUser,
  12.                              @RequestParam(value = "searchVal", required = false) String searchVal,
  13.                              @RequestParam("pageNo") Integer pageNo,
  14.                              @RequestParam("pageSize") Integer pageSize) {
  15.         return tMsOuterInterfaceService.queryPageList(loginUser.getId(), searchVal, pageNo, pageSize);
  16.     }

Service层：

  1. /**
  2.      * 分页查询
  3.      *
  4.      * @param userId
  5.      * @param searchVal
  6.      * @param pageNo
  7.      * @param pageSize
  8.      * @return
  9.      */
  10.     public Result queryPageList(Integer userId, String searchVal, int pageNo, int pageSize) {
  11.         Result result = new Result();
  12.         Integer offset = (pageNo - 1) * pageSize;
  13.         List<Map> list = tMsOuterInterfaceMapper.queryPageResultList(searchVal, offset, pageSize);
  14.         if (list.size() > 0) {
  15.             for (Map map : list) {
  16.                 String run_statusName = "";
  17.                 String req_method = "";
  18.                 String position = "";
  19.                 String type = "";
  20.                 String is_required = "";
  21.                 switch (map.get("run_status").toString()) {
  22.                     case "0":
  23.                         run_statusName = TABLE_RUN_DELETED.getName();
  24.                         break;
  25.                     case "1":
  26.                         run_statusName = TABLE_RUN_ENABLED.getName();
  27.                         break;
  28.                     case "2":
  29.                         run_statusName = TABLE_RUN_DISABLED.getName();
  30.                         break;
  31.                 }
  32.                 switch (map.get("req_method").toString()) {
  33.                     case "1":
  34.                         req_method = HTTP_GET.getName();
  35.                         break;
  36.                     case "2":
  37.                         req_method = HTTP_POST.getName();
  38.                         break;
  39.                 }
  40.                 Integer interfaceId = (Integer) map.get("interface_id");
  41.                 List<Map> paramList = tMsOuterInterfaceMapper.listParamsByInterfaceId(interfaceId);
  42.                 for (Map param : paramList) {
  43.                     switch (param.get("position").toString()) {
  44.                         case "0":
  45.                             position = POSITION_HEADER.getName();
  46.                             break;
  47.                         case "1":
  48.                             position = POSITION_QUERY.getName();
  49.                             break;
  50.                         case "2":
  51.                             position = POSITION_BODY.getName();
  52.                             break;
  53.                     }
  54.                     switch (param.get("type").toString()) {
  55.                         case "1":
  56.                             type = TYPE_CONST.getName();
  57.                             break;
  58.                         case "2":
  59.                             type = TYPE_DATE.getName();
  60.                             break;
  61.                     }
  62.                     switch (param.get("is_required").toString()) {
  63.                         case "0":
  64.                             is_required = IS_REQUIRED_FALSE.getName();
  65.                             break;
  66.                         case "1":
  67.                             is_required = IS_REQUIRED_TRUE.getName();
  68.                             break;
  69.                     }
  70.                     param.put("positionName", position);
  71.                     param.put("typeName", type);
  72.                     param.put("is_requiredName", is_required);
  73.  
  74.                 }
  75.                 map.put("param", paramList);
  76.                 map.put("run_statusName", run_statusName);
  77.                 map.put("req_methodName", req_method);
  78.             }
  79.         }
  80.         result.setData(list);
  81.         Map<String, Object> mapData = new HashMap<>();
  82.         Integer total = tMsOuterInterfaceMapper.countResultList(searchVal, offset, pageSize);
  83.         mapData.put("total", total);
  84.         result.setDataMap(mapData);
  85.         putMsg(result, Status.SUCCESS);
  86.         return result;
  87.     }

Mapper层：

  1. public String countResultList(Map<String, Object> parameter) {
  2.         return new SQL() {{
  3.             SELECT(" count(1) ");
  4.             FROM(TABLE_INTERFACE);
  5.             Object searchVal = parameter.get("searchVal");
  6.             if (searchVal != null && StringUtils.isNotEmpty(searchVal.toString())) {
  7.                 WHERE("interface_name like concat('%', '" + parameter.get("searchVal").toString() + "', '%')");
  8.             }
  9.             WHERE(" run_status <> '0' ");
  10.             ORDER_BY(" update_time desc limit #{offset},#{pageSize} ");
  11.         }}.toString();
  12.     }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/310110
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号