java mysql自定义查询需要的列

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量550 收藏
点赞数
文章标签： java mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bxp1321/article/details/131051216
版权

有时候不同的业务需要查询不同的数据，如果都全表查询，效率较低，网络传输量也比较大，所以可以采取自定义需要查询的字段的方式解决。

我们可以通过入参传入需要查询的字段和排序字段进行数据查询，然后返回数据信息

先建表枚举类

public enum TableEnum {
    ORDER_INFO("order_info"),
    DRIVER_ORDER_INFO("driver_order_info"),
    DRIVER_PASSENGER_RELATION("driver_passenger_relation");

    TableEnum(String tableName) {
        this.tableName = tableName;
    }

    String tableName;

    public String getTableName() {
        return tableName;
    }
}

表字段接口，面向接口变成，方便方法复用：

public interface BaseTableField {
    final static String FIELD_ALL = "_all";
    /**
     * 字段列表
     */
    final static Set<String> fieldSet = new HashSet<>();
    /**
     * 字段转换map，比如driverPhone可以读取 driverPhoneEncrypt
     */
    final static Map<String, String> fieldConvertMap = new HashMap<>();

    public String getFieldName();
    public TableEnum getTableEnum();
    public String getTableName();
}

表字段枚举类

/**
 * 订单字段信息  此处为示例，只写两个字段供参考
 */
public enum OrderInfoFieldEnum implements BaseTableField {
    /**
     * 所有字段,添加all后会返回所有字段信息，不推荐使用，还是使用明确的字段性能好，好排查问题
     */
    ALL(FIELD_ALL),
    /**
     * 订单id
     */
    ORDER_ID("order_id"),
    /**
     * userid
     */
    USER_ID("user_id")
    ;

    //获取所有字段信息，填充到map，用来判断字符是否存在
    static {
        for (OrderInfoFieldEnum item :
                OrderInfoFieldEnum.values()) {
            fieldSet.add(item.getFieldName());
        }
    }

    OrderInfoFieldEnum(String fieldName) {
        this.fieldName = fieldName;
    }

    String fieldName;

    public String getFieldName() {
        return fieldName;
    }

    @Override
    public TableEnum getTableEnum() {
        return TableEnum.ORDER_INFO;
    }

    @Override
    public String getTableName() {
        return TableEnum.ORDER_INFO.tableName;
    }
}

排序枚举类

public enum SortEnum {
    ASC("asc"),
    DESC("desc"),
    ;

    SortEnum(String sort) {
        this.sort = sort;
    }

    String sort;

    public String getSort() {
        return sort;
    }
}

结果过滤类，封装了需要的字段还有排序字段信息。此处用枚举类的主要目的是为了参数的合法化，想简单的话可以直接用字符串。

@Data
public class ResultFilter {
    @ApiModelProperty(value = "返回的字段，类型为Map<表名, Set<列明>>，有枚举类可以使用")
    Map<TableEnum, Set<String>> returnFieldMap;
    @ApiModelProperty(value = "排序字段，类型为Map<表名, Map<String, SortEnum>>，有枚举类可以使用")
    Map<TableEnum, Map<String, SortEnum>> sortFieldMap;
}

工具类，用来获取查询的字段还有排序字段信息，个别方法可能没用，可以后续自己扩展

public class ReturnFieldUtil {

    private static BaseResponse<String> getSelect(Set<String> set, BaseTableField baseTableField) {
        return getSelect(set, baseTableField, null);
    }

    private static BaseResponse<String> getSelect(Set<String> set, BaseTableField baseTableField, String tableAlias) {
        if (StringUtils.isEmpty(tableAlias)) {
            tableAlias = "";
        } else {
            tableAlias = tableAlias + ".";
        }
        if (set.contains(BaseTableField.FIELD_ALL)) {
            return ResponseUtils.success(tableAlias + "*");
        }
        StringBuilder sb = new StringBuilder();
        for (String fieldName :
                set) {
            if (!baseTableField.fieldSet.contains(fieldName)) {
                return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), String.format("表：(%s)的字段：(%s)，不存在", baseTableField.getTableName(), fieldName));
            }
            if (baseTableField.fieldConvertMap.containsKey(fieldName)) {
                sb.append(",").append(tableAlias).append(baseTableField.fieldConvertMap.get(fieldName));
            } else {
                sb.append(",").append(tableAlias).append(fieldName);
            }
        }
        return ResponseUtils.success(sb.substring(1));
    }


    public static BaseResponse<String> getSort(Map<TableEnum, Map<String, SortEnum>> sortFieldMap, BaseTableField baseTableField) {
        return getSort(sortFieldMap, baseTableField, null);
    }

    public static BaseResponse<String> getSort(Map<TableEnum, Map<String, SortEnum>> sortFieldMap, BaseTableField baseTableField, String tableAlias) {
        Map<String, SortEnum> sortMap = sortFieldMap.get(baseTableField.getTableEnum());
        if (CollectionUtils.isEmpty(sortMap)) {
            return ResponseUtils.success();
        }
        if (StringUtils.isEmpty(tableAlias)) {
            tableAlias = "";

        } else {
            tableAlias = tableAlias + ".";
        }
        StringBuilder sb = new StringBuilder();
        for (String fieldName :
                sortMap.keySet()) {
            if (!baseTableField.fieldSet.contains(fieldName)) {
                return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), String.format("表：(%s)的字段：(%s)，不存在", baseTableField.getTableName(), fieldName));
            }
            if (sortMap.get(fieldName) == null) {
                return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), String.format("表：(%s)的字段：(%s)，排序值不能为空", baseTableField.getTableName(), fieldName));
            }
            if (baseTableField.fieldConvertMap.containsKey(fieldName)) {
                sb.append(",").append(tableAlias).append(baseTableField.fieldConvertMap.get(fieldName)).append(" ").append(sortMap.get(fieldName).getSort());
            } else {
                sb.append(",").append(tableAlias).append(fieldName).append(" ").append(sortMap.get(fieldName).getSort());
            }
        }
        return ResponseUtils.success(sb.substring(1));
    }

    public static BaseResponse<String> getSelect(Map<TableEnum, Set<String>> returnFieldMap, BaseTableField baseTableField, boolean required, String tableAlias, Set<String> needFieldSet) {
        Set<String> returnFieldSet = returnFieldMap.get(baseTableField.getTableEnum());
        //获取返回列信息
        if (CollectionUtils.isEmpty(returnFieldSet)) {
            if (required) {
                return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), String.format("返回字段returnFiledMap没有（%s)的字段信息", baseTableField.getTableName()));
            } else {
                return ResponseUtils.success();
            }
        }
        if (!CollectionUtils.isEmpty(needFieldSet)) {
            returnFieldSet.addAll(needFieldSet);
        }
        //生成返回字段sql
        return ReturnFieldUtil.getSelect(returnFieldSet, baseTableField, tableAlias);
    }

    public static BaseResponse<String> getSelect(Map<TableEnum, Set<String>> returnFieldMap, BaseTableField baseTableField, boolean required, String tableAlias) {
        return getSelect(returnFieldMap, baseTableField, required, tableAlias, null);
    }

    public static BaseResponse<String> getSelect(Map<TableEnum, Set<String>> returnFieldMap, BaseTableField baseTableField, boolean required) {
        return getSelect(returnFieldMap, baseTableField, required, null, null);
    }
}

请求示例

入参

@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
@ApiModel(value = "QueryCoustomOrderInfoByOrderId", description = "根据入参的字段查询订单信息")
public class QueryCoustomOrderInfoByOrderIdReq {
    @ApiModelProperty(value = "订单id", required = true)
    @NotNull(message = "orderId不能为空")
    Long orderId;
    @ApiModelProperty(value = "用户id")
    Long userId;
    @NotNull(message = "返回的字段信息不能为空")
    @ApiModelProperty(value = "返回的字段，排序字段信息，有枚举类可以使用")
    ResultFilter resultFilter;
}

出参

@ApiModel(value = "OrderInfoResp", description = "订单信息")
@Data
@ToString(callSuper = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class OrderInfoResp {
    private Long orderId;
    private Long userId;
}

控制层 

public BaseResponse<OrderInfoResp> queryCoustomOrderInfoByOrderId(@RequestBody @Valid QueryCoustomOrderInfoByOrderIdReq req){
        return orderInfoService.queryCoustomOrderInfoByOrderId(req);
    }

服务

@Override
    public BaseResponse<OrderInfoResp> queryCoustomOrderInfoByOrderId(QueryCoustomOrderInfoByOrderIdReq req) {
        if (CollectionUtils.isEmpty(req.getResultFilter().getReturnFieldMap())) {
            return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), "返回字段不能为空");
        }
        //生成返回字段sql
        BaseResponse<String> returnFieldsResponse = ReturnFieldUtil.getSelect(req.getResultFilter().getReturnFieldMap(), OrderInfoFieldEnum.ALL,true);
        if (!ResponseUtils.isBodyOk(returnFieldsResponse)) {
            return ResponseUtils.fail(returnFieldsResponse.getCode(), returnFieldsResponse.getMessage());
        }
        String returnFields = returnFieldsResponse.getData();
        OrderInfo orderInfo = orderInfoMapper.queryCoustomOrderInfoByOrderId(returnFields, req);
        
        if (orderInfo == null) {
            return ResponseUtils.success();
        }
        OrderInfoResp orderInfoResp = new OrderInfoResp();
        BeanUtils.copyProperties(orderInfo, orderInfoResp);
        return ResponseUtils.success(orderInfoResp);
    }

调用示例

Map<TableEnum, Set<String>> returnFieldMap=new HashMap<>();
        Set<String> set=new HashSet<>();
        set.add(OrderInfoFieldEnum.ORDER_ID.getFieldName());
        set.add(OrderInfoFieldEnum.USER_ID.getFieldName());
        returnFieldMap.put(TableEnum.ORDER_INFO,set);
        QueryCoustomOrderInfoByOrderIdReq req=new QueryCoustomOrderInfoByOrderIdReq();
        req.setOrderId(1L);
        ResultFilter returnFieldReq=new ResultFilter();
        returnFieldReq.setReturnFieldMap(returnFieldMap);
        req.setResultFilter(returnFieldReq);
        Map<TableEnum, Map<String, SortEnum>> sortFieldMap=new HashMap<>();
        Map<String, SortEnum> sortMap=new HashMap<>();
        sortMap.put(OrderInfoFieldEnum.ORDER_ID.getFieldName(),SortEnum.ASC);
        sortFieldMap.put(TableEnum.ORDER_INFO,sortMap);
        returnFieldReq.setSortFieldMap(sortFieldMap);
        try {
            MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders
                            .post("/orderhtap/order/queryCoustomOrderInfoByOrderId")
                            .contentType(MediaType.APPLICATION_JSON)
                            //传json参数
                            .content(JSON.toJSONBytes(req))
                    )
                    .andExpect(MockMvcResultMatchers.status().isOk())
                    .andDo(MockMvcResultHandlers.print())
                    .andReturn();
            BaseResponse baseResponse = JSON.parseObject(mvcResult.getResponse().getContentAsString(), BaseResponse.class);
            Assert.assertEquals(OrderHtapResultEnum.SUCCESS.getCode(), baseResponse.getCode());
        } catch (Exception e) {
            e.printStackTrace();
        }

此示例是个单表查询示例。还可以实现多表关联查询示例。

多表查询示例

入参

public class QueryDriverCompleteOrder2Req {
    /**
     * 司机Id.
     */
    @ApiModelProperty(value = "司机Id.", required = true)
    @NotNull(message = "司机Id不能为空")
    private Long driverId;
    /**
     * 状态.
     */
    @ApiModelProperty(value = "状态.", required = true)
    @NotNull(message = "状态不能为空")
    private List<Integer> statusList;
    /**
     * 结束时间开始时间.
     */
    @ApiModelProperty(value = "结束时间开始时间", required = true)
    @NotNull(message = "结束时间开始时间不能为空")
    private Long timeEndStart;
    /**
     * 结束时间结束时间.
     */
    @ApiModelProperty(value = "结束时间结束时间", required = true)
    @NotNull(message = "结束时间结束时间不能为空")
    private Long timeEndEnd;

    @NotNull(message = "返回的字段信息不能为空")
    @ApiModelProperty(value = "返回的字段，排序字段信息，有枚举类可以使用")
    ResultFilter resultFilter;
}

出参

public class QueryDriverCompleteOrder2Resp extends DriverOrderInfoDto {
    DriverPassengerRelationDto driverPassengerRelation;
}

控制层 

    @ApiOperation(value = "查询一定时间内司机完单数量", notes = "查询一定时间内司机完单数量", httpMethod = "POST")
    @PostMapping(value = "/queryDriverCompleteOrder2")
    public BaseResponse<List<QueryDriverCompleteOrder2Resp>> queryDriverCompleteOrder2(@RequestBody @Valid QueryDriverCompleteOrder2Req req) {
        return driverOrderInfoService.queryDriverCompleteOrder2(req);
    }

服务层

@Override
    public BaseResponse<List<QueryDriverCompleteOrder2Resp>> queryDriverCompleteOrder2(QueryDriverCompleteOrder2Req req) {
        if (CollectionUtils.isEmpty(req.getResultFilter().getReturnFieldMap())) {
            return ResponseUtils.fail(OrderHtapResultEnum.PARAM_ERROR.getCode(), "返回字段不能为空");
        }

        //获取driverOrderInfo返回列信息
        BaseResponse<String> returnFieldsResponseDriverOrderInfo = ReturnFieldUtil.getSelect(req.getResultFilter().getReturnFieldMap(), DriverOrderInfoFieldEnum.ALL, true, "doi", Sets.newHashSet(DriverOrderInfoFieldEnum.ORDER_ID.getFieldName()));
        if (!ResponseUtils.isBodyOk(returnFieldsResponseDriverOrderInfo)) {
            return ResponseUtils.fail(returnFieldsResponseDriverOrderInfo.getCode(), returnFieldsResponseDriverOrderInfo.getMessage());
        }
        String returnFieldsDriverOrderInfo = returnFieldsResponseDriverOrderInfo.getData();

        //获取driverPassengerRelation返回列信息
        BaseResponse<String> returnFieldsResponseDriverPassengerRelation = ReturnFieldUtil.getSelect(req.getResultFilter().getReturnFieldMap(), DriverPassengerRelationFieldEnum.ALL, false, null, Sets.newHashSet(DriverPassengerRelationFieldEnum.ORDER_ID.getFieldName()));
        if (!ResponseUtils.isBodyOk(returnFieldsResponseDriverPassengerRelation)) {
            return ResponseUtils.fail(returnFieldsResponseDriverPassengerRelation.getCode(), returnFieldsResponseDriverPassengerRelation.getMessage());
        }
        String returnFieldsDriverPassengerRelation = returnFieldsResponseDriverPassengerRelation.getData();

        //获取排序字段信息
        BaseResponse<String> sortResponse = getQueryDriverCompleteOrder2Sort(req.getResultFilter().getSortFieldMap());
        if (!ResponseUtils.isBodyOk(sortResponse)) {
            return ResponseUtils.fail(sortResponse.getCode(), sortResponse.getMessage());
        }
        String sort = sortResponse.getData();
        List<DriverOrderInfo> driverOrderInfoList = driverOrderInfoMapper.queryDriverCompleteOrder2(req, returnFieldsDriverOrderInfo, sort);
        if (CollectionUtils.isEmpty(driverOrderInfoList)) {
            return ResponseUtils.success();
        }
        List<QueryDriverCompleteOrder2Resp> queryDriverCompleteOrder2RespList = new ArrayList<>(driverOrderInfoList.size());
        List<Long> orderIdList = new ArrayList<>(driverOrderInfoList.size());
        Map<Long, QueryDriverCompleteOrder2Resp> queryDriverCompleteOrder2RespMap = new HashMap<>(driverOrderInfoList.size());
        for (DriverOrderInfo driverOrderInfo :
                driverOrderInfoList) {
            QueryDriverCompleteOrder2Resp queryDriverCompleteOrder2Resp = new QueryDriverCompleteOrder2Resp();
            BeanUtils.copyProperties(driverOrderInfo, queryDriverCompleteOrder2Resp);
            queryDriverCompleteOrder2RespList.add(queryDriverCompleteOrder2Resp);
            queryDriverCompleteOrder2RespMap.put(queryDriverCompleteOrder2Resp.getOrderId(), queryDriverCompleteOrder2Resp);
            orderIdList.add(queryDriverCompleteOrder2Resp.getOrderId());
        }
        if (StringUtils.isEmpty(returnFieldsDriverPassengerRelation)) {
            return ResponseUtils.success(queryDriverCompleteOrder2RespList);
        }
        List<DriverPassengerRelation> driverPassengerRelationList = driverPassengerRelationMapper.queryDriverCompleteOrderRelation2(orderIdList, req.getDriverId(), returnFieldsDriverPassengerRelation);
        for (DriverPassengerRelation driverPassengerRelation :
                driverPassengerRelationList) {
            DriverPassengerRelationDto driverPassengerRelationDto = new DriverPassengerRelationDto();
            BeanUtils.copyProperties(driverPassengerRelation, driverPassengerRelationDto);
            queryDriverCompleteOrder2RespMap.get(driverPassengerRelationDto.getOrderId()).setDriverPassengerRelation(driverPassengerRelationDto);
        }
        return ResponseUtils.success(queryDriverCompleteOrder2RespList);
    }

调用示例

 @Test
    public void testQueryDriverCompleteOrder2() {
        QueryDriverCompleteOrder2Req req = new QueryDriverCompleteOrder2Req();
        req.setDriverId(7001552L);
        req.setTimeEndStart(1676454895L);
        req.setTimeEndEnd(1676454895L);
        req.setStatusList(Lists.newArrayList(9,8));

        ResultFilter returnFieldReq=new ResultFilter();

        Map<TableEnum,Set<String>>returnFieldMap=new HashMap<>();
        Set<String> setDriverOrderInfo=new HashSet<>();
        setDriverOrderInfo.add(DriverOrderInfoFieldEnum.ORDER_ID.getFieldName());
        setDriverOrderInfo.add(DriverOrderInfoFieldEnum.DRIVER_PHONE_ENCRYPT.getFieldName());
        setDriverOrderInfo.add(DriverOrderInfoFieldEnum.DRIVER_PHONE.getFieldName());
        returnFieldMap.put(TableEnum.DRIVER_ORDER_INFO,setDriverOrderInfo);

        Set<String> setDriverPassengerRelation=new HashSet<>();
        setDriverPassengerRelation.add(DriverPassengerRelationFieldEnum.TIME_END.getFieldName());
        setDriverPassengerRelation.add(DriverPassengerRelationFieldEnum.ORDER_ID.getFieldName());
        setDriverPassengerRelation.add(DriverPassengerRelationFieldEnum.PASSENGER_ORDER_ID.getFieldName());
        setDriverPassengerRelation.add(DriverPassengerRelationFieldEnum.DRIVER_ID.getFieldName());
        setDriverPassengerRelation.add(DriverPassengerRelationFieldEnum.CHARGE_DRIVER_DISCOUNTED_BASIC_AMOUNT.getFieldName());
        returnFieldMap.put(TableEnum.DRIVER_PASSENGER_RELATION,setDriverPassengerRelation);

        returnFieldReq.setReturnFieldMap(returnFieldMap);


        Map<TableEnum, Map<String, SortEnum>> sortFieldMap=new HashMap<>();
        Map<String, SortEnum> sortMap=new HashMap<>();
        sortMap.put(DriverPassengerRelationFieldEnum.TIME_END.getFieldName(),SortEnum.ASC);
        sortFieldMap.put(TableEnum.DRIVER_PASSENGER_RELATION,sortMap);
        returnFieldReq.setSortFieldMap(sortFieldMap);

        req.setResultFilter(returnFieldReq);
        try {
            MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders
                            .post("/orderhtap/driverorder/queryDriverCompleteOrder2")
                            .contentType(MediaType.APPLICATION_JSON)
                            //传json参数
                            .content(JSON.toJSONBytes(req))
                    )
                    .andExpect(MockMvcResultMatchers.status().isOk())
                    .andDo(MockMvcResultHandlers.print())
                    .andReturn();
            BaseResponse baseResponse=JSON.parseObject(mvcResult.getResponse().getContentAsString(),BaseResponse.class);
            Assert.assertEquals(OrderHtapResultEnum.SUCCESS.getCode(),baseResponse.getCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

bxp1321
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
自定义查询 java_JAVA自定义查询策略
weixin_30952479的博客
02-13 756
packagecom.qy.code.generator.query;importjava.util.ArrayList;importjava.util.List;importcom.qy.code.generator.constant.OperatorConstants;importcom.qy.code.generator.utils.CodeArrayUtils;/*** 描述：查询类*@a...
mysql自定义一列数据_mysql自定义列
weixin_39689819的博客
01-18 1201
selectc.cnas'省',c.cn_cityas'市',SUM(CASEt.placeIdwhen1thent.numelse0end)as'餐饮',SUM(CASEt.placeIdwhen2thent.numelse0end)as'咖啡厅',SUM(CASEt.placeIdwhen3thent.numelse0...
Java实现表单的自定义字段功能(动态管理不同类型的字段数据)
热门推荐
languageStudent的博客
02-18 1万+
需求描述 在业务项目中有些表数据存的内容不固定，我们可以预留字段。如果后期还要扩展，可能需要增加字段来保存数据，在维护时会很麻烦不易于维护 现在我们可以使用自定义字段，可以由我们在线上管理临时添加的字段并保存在数据内 完成后的功能 在页面可以直接添加字段，配置数据类型。 添加完成后，即可在数据列表中设置自定字段的数据。 优点 无需再处理后台逻辑 线上直接完成 灵活、扩展性强 可同时扩展多个表 演示地址 用户单列表（自定义字段测试） 表设计 1：自定义字段模板表 type:配置用来扩展不同的数据
Java开源协同办公项目：数据中心，自定义查询语句使用教程
liyi_hz2008的博客
07-20 529
O2OA提供的数据管理中心，可以让用户通过配置的形式完成对数据的汇总，统计和数据分组展现，查询和搜索数据形成列表数据展现。也支持用户配置独立的数据表来适应特殊的业务的数据存储需求。本文主要介绍如何在O2OA中开发和配置自定义数据查询语句JPQL及对应的视图。 Statement 查询语句是建立在数据表基数上的查询语句配置。配置查询语句后，在应用中可调用执行。 对系统表，目前支持流程平台的待办、已办、待阅、已阅、流程实例、已完成流程实例和阅读的查询操作；还支持内容管理平台的文档查询操作。 对自建表，支
java快速自定义查询实现
04-21
通过一些简单的配置，实现java快速自定义定义查询。需要源代码交流的朋友，可以加我ＱＱ：157938324
MyBatis的各种查询功能
m0_52334927的博客
04-10 577
1、查询一个实体类对象 mapper.java文件代码 /** * 根据用户id查询用户信息 * @param id * @return */ User getUserById(@Param("id") int id); mapper.xml文件代码 <!--User getUserById(@Param("id") int id);--> <select id="getUserById" resultType="User"> select * from t_u
MySQL 数据库 查询定义参数【模糊查询】
君逍遥o
12-05 636
MySQL 数据库 查询定义参数【模糊查询】
java 有选择的查询_求助!!java怎样实现数据库 选择列属性的select查询？？
weixin_42613572的博客
02-27 228
该楼层疑似违规已被系统折叠隐藏此楼查看此楼3.类SelectStatement代表整个select语句，包含select，from，where和orderby等子句。1.类SelectInstruction表示select子句中的一个单一部分，选定列并指定显示时该列的名字。一个完整的select子句用一个SelectInstruction对象数组表示。2.类OrderInstruction代表...
自定义java-mysql开发规则
03-06
自定义java_mysql开发规则，比较适合java后端新手
mysql时间类型对应的java类型1
08-08
在Java中，虽然没有直接对应的类型，但通常可以使用`java.sql.Date`或者自定义类型来处理。 在Java中，我们可以通过以下方式在这些时间类型之间进行转换： - **从Java到MySQL**： - `java.util.Date`（Java的日期...
mysql 自定义函数1
06-07
mysql自定义函数 在MySQL数据库中，可以通过创建自定义函数来扩展数据库的功能，以便更方便和灵活地处理数据。以下是创建MySQL自定义函数的基本步骤：
jdbc java mongodb mysql 相互同步
01-13
要使用JDBC，我们需要引入对应的数据库驱动，例如`mysql-connector-java`，并编写如下的Java代码来建立连接： ```java Class.forName("com.mysql.jdbc.Driver"); Connection conn = DriverManager.getConnection(...
java练习项目 可以自定义更改代码
10-06
这是一个基于Java语言的计算机学生大作业项目，旨在提供一个实践平台，让学生能够应用他们的编程技能，特别是对于Java编程和相关技术的理解。该项目使用了Maven作为构建工具，确保了依赖管理的便捷性，同时利用MySQL...
Mysql查询添加自定义列
mrtwenty的博客
10-07 7219
最近在做的一个项目里面，有两个订单表，一个是线上订单表 online_order，一个是线下订单表 offline_order , 在前端展示的时候，需要将这两个表的数据放到一起作为列表展示出来，所以使用 UNION ALL 来实现。 (SELECT id,real_price,member_id,created_at FROM z_takeout_order WHERE 1 ORDER B...
Java实现自定义列
Sang
06-26 3433
在日常开发中查询列表，展示查询字段比如5个字段，其他扩展字段放入自定义列中，由用户勾选展示哪些字段，不展示哪些字段，实现方案如下： 1.定义数据模型： CREATE TABLE `t_user_index_custom_row` ( `created_by` varchar(15) NOT NULL COMMENT '创建人', `create_time` timestamp NUL...
mysql字段的细节（查询自定义的字段[意义：行列转置]；UNION ALL；case-when）
m0_66468899的博客
09-06 187
（跟java的switch-case一样啦，如果...就...（也可以作为if使用））
elasticsearch在Java中查询指定列的方法
翎野君的博客
11-08 269
背景 ES在查询时如果数量太多，而每行记录包含的字段很多，那就会导致超出ES的查询上线，默认是100MB，但是很多场景下我们只需要返回特定的字段即可，那么如何操作呢。 主要代码 @Autowired private RestHighLevelClient client; public List<Map<String,Object>> search(String ...
golang 接口
m0_70982551的博客
07-24 965
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 519
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java实现MySQL数据库分页查询总结
Java分页是数据库操作中常用的一种技术，特别是在处理大量数据时，为了提高用户体验和系统性能，通常需要对查询结果进行分页展示。本总结将探讨Java中如何实现分页，特别是结合MySQL数据库的分页方法。 首先，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值