json数据写进数据库以及mybatisplus的增删改查

已于 2023-10-11 09:23:27 修改
阅读量902 收藏 1
点赞数
分类专栏： 开发基础 文章标签： json big data java mybatis spring boot
于 2021-08-31 10:18:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Natalia_Portman/article/details/120010329
版权

1.实体类举例（市区同理）

import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.CreatedDate;

import java.io.Serializable;
import java.util.Date;

/**
 * 省份名称表
 *
 * @author Natalia_Portman
 */
@Data
@TableName(value = "t_act_province")
public class Province implements Serializable {

    @TableId(type = IdType.ASSIGN_UUID,value = "ID")
    private String id;

   @TableField(value = "CODE")
   @ApiModelProperty(value = "省份编码")
    private String code;

   @TableField(value = "NAME")
   @ApiModelProperty(value = "省份名称")
    private String name;

    @TableField(value = "DELETE_FLAG", fill = FieldFill.INSERT)
    @ApiModelProperty(value = "删除状态 1-可用 2-删除")
    private String deleteFlag;

    @TableField(value = "CREATE_USER_ID", fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建人id")
    private String createUserId;

    @CreatedDate
    @TableField(value = "CREATE_TIME", fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(value = "UPDATE_USER_ID", fill = FieldFill.UPDATE)
    @ApiModelProperty(value = "修改人id")
    private String updateUserId;

    @TableField(value = "UPDATE_TIME", fill = FieldFill.UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;
}

2.mapper举例（可加注释@Component，因项目里配置过，所以我这里没加。市区同理）

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yss.accountmanager.entity.Province;

public interface ProvinceMapper extends BaseMapper<Province> {
}

3.server举例

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.yss.accountmanager.entity.AttachmentDO;
import com.yss.accountmanager.entity.City;
import com.yss.accountmanager.entity.Province;
import com.yss.accountmanager.entity.Town;
import com.yss.accountmanager.mapper.CityMapper;
import com.yss.accountmanager.mapper.ProvinceMapper;
import com.yss.accountmanager.mapper.TownMapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.security.PublicKey;
import java.util.Date;
import java.util.List;

/**
 * @author Natalia_Portman
 */
@Service
public class CityService {

    @Autowired
    private CityMapper cityMapper;
    @Autowired
    private TownMapper townMapper;
    @Autowired
    private ProvinceMapper provinceMapper;

    /**
     * 查询省份列表
     * @return
     */
    public List<Province> queryProvinceList(){
        return new LambdaQueryChainWrapper<>(provinceMapper).eq(Province::getDeleteFlag,1).list();
    }

    /**
     * 根据省份code查询城市列表
     * @param provinceCode
     * @return
     */
    public List<City> queryCityList(String provinceCode) {
        return new LambdaQueryChainWrapper<>(cityMapper).eq(City::getProvinceCode,provinceCode).list();
    }

    /**
     * 根据城市code查询区县列表
     * @param cityCode
     * @return
     */
    public List<Town> queryTownList(String cityCode){
        return new LambdaQueryChainWrapper<>(townMapper).eq(Town::getCityCode,cityCode).list();
    }

    /**
     * 添加省份列表
     * @param province
     * @return
     */
    public int addProvince(Province province){
        return provinceMapper.insert(province);
    }

    /**
     * 添加城市列表
     * @param city
     * @return
     */
    public int addCity(City city){
        return cityMapper.insert(city);
    }

    /**
     * 添加区县列表
     * @param town
     * @return
     */
    public int addTown(Town town){
        town.setCreateTime(new Date());
        return townMapper.insert(town);
    }

    /**
     * 修改省份
     * @param id
     * @param province
     * @return
     */
    public int updateProvinceById(String id,Province province){
        LambdaUpdateWrapper<Province> updateWrapper =new LambdaUpdateWrapper<>();
        updateWrapper.eq(Province::getId,id);

        return provinceMapper.update(province,updateWrapper);
    }

    public void updateProvinceById(Province province) {
        UpdateWrapper<Province> updateWrapper =new UpdateWrapper<>();
        if (StringUtils.isNotBlank(province.getId())) {
            updateWrapper.set("ID",province.getId());
        }

        if (StringUtils.isNotBlank(province.getName())) {
            updateWrapper.set("NAME",province.getName());
        }

        if (StringUtils.isNotBlank(province.getCode())) {
            updateWrapper.set("CODE",province.getCode());
        }
        provinceMapper.update(new Province(),updateWrapper);

    }

    public void updateCityById(City city) {
        UpdateWrapper<City> updateWrapper =new UpdateWrapper<>();
        if (StringUtils.isNotBlank(city.getId())) {
            updateWrapper.set("ID",city.getId());
        }
        if (StringUtils.isNotBlank(city.getCode())) {
            updateWrapper.set("CODE",city.getCode());
        }
        if (StringUtils.isNotBlank(city.getName())) {
            updateWrapper.set("NAME",city.getName());
        }
        if (null != city.getCreateTime()) {
            updateWrapper.set("CREATE_TIME",city.getCreateTime());
        }
        cityMapper.update(new City(),updateWrapper);
    }

    public void updateTownById(Town town) {
        UpdateWrapper<Town> updateWrapper =new UpdateWrapper<>();
        if(StringUtils.isNotBlank(town.getId())) {
            updateWrapper.set("ID",town.getId());
        }
        if (StringUtils.isNotBlank(town.getCode())) {
            updateWrapper.set("CODE",town.getCode());
        }
        if (StringUtils.isNotBlank(town.getName())) {
            updateWrapper.set("NAME",town.getName());
        }
        if (null != town.getCreateTime()) {
            updateWrapper.set("CREATE_TIME",town.getCreateTime());
        }
        townMapper.update(new Town(),updateWrapper);
    }

    /**
     * 根据用户id删除省份
     * @param id
     * @return
     */
    public int deleteProvinceById(String id){
        LambdaUpdateWrapper<Province> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(Province::getDeleteFlag,"2").eq(Province::getId,id);
        return this.provinceMapper.update(new Province(),updateWrapper);
    }

    /**
     * 根据用户id删除
     * @param id
     * @return
     */
    public int deleteCityById(String id){
        LambdaUpdateWrapper<City> updateWrapper =new LambdaUpdateWrapper<>();
        updateWrapper.set(City::getDeleteFlag,"2").eq(City::getId,id);
        return this.cityMapper.update(new City(),updateWrapper);
    }

    /**
     * 根据用户id删除区县列表数据
     * @param id
     * @return
     */
    public int deleteTownById(String id){
        LambdaUpdateWrapper<Town> updateWrapper =new LambdaUpdateWrapper<>();
        updateWrapper.set(Town::getDeleteFlag,"2").eq(Town::getId,id);
        return this.townMapper.update(new Town(),updateWrapper);
    }

}

4.controller 举例

import com.yss.accountmanager.entity.City;
import com.yss.accountmanager.entity.Province;
import com.yss.accountmanager.entity.Town;
import com.yss.accountmanager.service.CityService;
import com.yss.base.common.result.ObjectRestResponse;
import io.swagger.annotations.Api;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 *@author Natalia_Portman
 */
@Api(tags = "省市区县")
@RestController
public class CityController{

    @Autowired
    private CityService cityService;

    /**
     * 查询省份列表
     * @return
     */
    @GetMapping(value = "/province")
    public ObjectRestResponse<List<Province>> queryProvinceList(){
        return new ObjectRestResponse<List<Province>>()
                .rel(true)
                .data(cityService.queryProvinceList());
    }

    /**
     * 根据ProvinceCode查询城市列表
     * @param provinceCode
     * @return
     */
    @GetMapping(value = "/city")
    public ObjectRestResponse<List<City>> queryCityList(@RequestParam String provinceCode){
        return new ObjectRestResponse<List<City>>()
                .rel(true)
                .data(cityService.queryCityList(provinceCode));
    }

    /**
     * 根据CityCode查询区县列表
     * @param cityCode
     * @return
     */
    @GetMapping(value = "/town")
    public ObjectRestResponse<List<Town>> queryTownList(@RequestParam String cityCode){
        return new ObjectRestResponse<List<Town>>()
                .rel(true)
                .data(cityService.queryTownList(cityCode));
    }

    /**
     * 添加省列表
     * @param province
     * @return
     */
    @PostMapping(value = "/addProvince")
    public ObjectRestResponse<Integer> addProvinceList(@RequestBody Province province){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.addProvince(province));
    }

    /**
     * 添加城市列表
     * @param city
     * @return
     */
    @PostMapping(value = "/addCity")
    public ObjectRestResponse<Integer> addCityList(@RequestBody City city){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.addCity(city));
    }

    /**
     * 添加区县列表
     * @param town
     * @return
     */
    @PostMapping(value = "/addTown")
    public ObjectRestResponse<Integer> addTownList(@RequestBody Town town){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.addTown(town));
    }

    /**
     * 根据id删除省份列表
     * @param id
     * @return
     */
    @PostMapping(value = "/deleteProvinceById")
    public ObjectRestResponse<Integer> deleteProvinceById(@RequestParam("id") String id){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.deleteProvinceById(id));
    }

    /**
     * 根据id删除城市列表
     * @param id
     * @return
     */
    @PostMapping(value = "/deleteCityById")
    public ObjectRestResponse<Integer> deleteCityById(@RequestParam("id") String id){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.deleteCityById(id));
    }

    /**
     * 根据id删除区县列表
     * @param id
     * @return
     */
    public ObjectRestResponse<Integer> deleteTownById(@RequestParam("id") String id){
        return new ObjectRestResponse<Integer>()
                .rel(true)
                .data(cityService.deleteTownById(id));
    }

}

6 entry举例

import lombok.Data;

import java.util.List;

@Data
public class Entry {
    private String code;
    private String name;
    private List<Entry> children;
}

7 test举例

import com.alibaba.fastjson.JSONObject;
import com.yss.accountmanager.entity.City;
import com.yss.accountmanager.entity.Entry;
import com.yss.accountmanager.entity.Province;
import com.yss.accountmanager.entity.Town;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.*;
import java.util.List;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest( webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Sql {

    @Autowired
    CityService cityService;

    @Test
    public void test1() throws IOException {
        FileInputStream inputStream = new FileInputStream("D:\\data.json");
        InputStreamReader reader = new InputStreamReader(inputStream, "UTF-8");

        int r;
        StringBuilder sb = new StringBuilder();
        while ((r = reader.read()) != -1) {
            sb.append((char) r);
        }
        List<Entry> list = JSONObject.parseArray(sb.toString(), Entry.class);

        for (Entry entry : list) {
            //省 入库
            Province province = new Province();
            province.setCode(entry.getCode());
            province.setName(entry.getName());
            cityService.addProvince(province);

            //市
            List<Entry> children = entry.getChildren();
            for (Entry child : children) {
                //市
                City city = new City();
                city.setCode(child.getCode());
                city.setName(child.getName());
                city.setProvinceCode(province.getCode());
                cityService.addCity(city);
                //县或区
                List<Entry> children1 = child.getChildren();
                for (Entry entry1 : children1) {
                    Town town =new Town();
                    town.setCode(entry1.getCode());
                    town.setName(entry1.getName());
                    town.setCityCode(city.getCode());
                    cityService.addTown(town);
                }
            }
        }
        System.out.println();
    }
}
Natalia_Portman
关注
专栏目录
MybatisPlus注解实现数据以json格式持久化到数据库
weixin_49528281的博客
08-01 401
在与数据库表映射的POJO类属性上添加@TableField(value="xxxx",typeHandler='JacksonTypeHandler.class'");如果是使用xml,resultMap标签中,对该字段指定。
MySql中json类型数据的查询以及在MyBatis-Plus中的使用
m0_73311735的博客
09-15 1万+
INSERT INTO `ctts_dev`.`json_test`(`id`, `roles`, `project`) VALUES (1, '[{"id": 10001, "name": "管理员"}, {"id": 10002, "name": "开发"}, {"id": 10003, "name": "测试"}]', '{"id": 11111, "name": "项目1"}');如果是字符串，一个箭头返回的结果是带双引号的（只针对字符串），两个箭头是不带的。"name": "测试1111",
SpringBoot_mybatis-plus使用json字段
Myron_007的博客
11-01 5832
在springboot项目开发中,一般使用关系型数据库作为主库存储数据,有时候业务场景需要在既有的表结构上,扩展自定义业务信息. 这种场景下一般使用json类型存储。本文总结springboot项目中,借助mybatis-plus操作json实践方案JSON类型相对于传统的关系型结构，其具有数据本身对结构描述、动态扩展和嵌套等特性，能够更加自由地表示和存储数据。
Springboot+Mybatis-plus查询带有json格式数据列表，以及将json格式的数据插入数据库
qq_44179134的博客
08-08 1793
代替，二者只能选择其中的一个。最近学习过程中遇到一个需要将订单数据存入数据库需求，项目是使用SpringBoot+MyBatis框架，数据库是MySQL,订单数据格式如下：{ all_price: 32 beizhu: "暂无" store_id: "1" goods: [ {goods_id: 2,goods_name: "辣椒炒肉",goods_num: 2}, {goods_i..._springboot mybatis json字段。7.application文件。3.Service层。
mybatis查询修改mysql的json字段
占星安啦的博客
02-02 1343
mysql5.7版本之后支持json字段类型，推荐mysql8版本，适用于属性不确定的个性化字段，比如:身份信息{“职业”,“学生”,“兴趣”:“打乒乓球”,“特长”:“跳高，书法”};图片信息{“日期”:“2023-12-12 22:12”,“尺寸”:“215*720”,“拍摄地”:“xxx”,“作者”:“xxx”};标签信息：[“历史”,“军事”,“都市”,“科幻”]。这部分信息每条数据差异较大，固定字段会大量冗余，使用json有较高的扩展性和自由度。
mybatis plus中json格式实战
focus-unchanged-thing
10-21 1268
1.自定义sql的话，TypeHandler是不生效的，需要通过ResultMap声明下转换器才行。2.增加字段发现确实是可以的，删除字段就报错，所以这也符合游戏的目标也就是不能删和改字段名字。但是QueryWrapper就可以，不知道这算不算bug。可见，业务层可以愉快的使用Entiy了。
使用mybatis-plus实现对数据库的增删改查
weixin_44948424的博客
07-29 218
使用mybatis-plus实现对数据库的增删改查。
Mybatis对数据的增删改查
古城的博客
11-04 608
创建sql的映射文件 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.demo.mybatispro.mapper.AdminMapper"> namespace某一
Springboot+MybatisPlus高效实现增删改查
程序员干货站
04-26 3142
前言 Mybatis-Plus基于mybatis做了增强，大大简化了单表CRUD操作，而且Mybatis-Plus是无侵入性的，不会影响现有项目，Mybatis-Plus提供了代码生成器，可以根据数据库表一键生成对应的service、mapper、xml文件，service和mapper提供了丰富的CRUD操作方法，xml文件也是非常简洁。 目前最新版本是3.4.1版本。 看一下框架结构图： 接下去我们就以该版本来讲解下Mybati-Plus的各种用法。 本文分为以下几个部分讲解： 引入Mybatis
Springboot+Redis+MybatisPlus实现页面缓存增删改查
xcj2437的博客
11-29 718
Springboot+Redis+MybatisPlus实现页面缓存增删改查
springboot+mybatis-plus+mysql+微信小程序实现简单的增删改查.zip
05-23
5. **API 设计**：后端通过设计清晰的RESTful API，使得微信小程序能够进行数据的增删改查操作。通常，这会包括如GET /users（获取所有用户）、POST /users（新建用户）、PUT /users/{id}（更新用户）和DELETE /...
Vue与后端链接并且实现增删改查(操作数据库)
热门推荐
qq_45377275的博客
08-28 1万+
1 后端准备 1.1 代码结构 1.2 pom.xml文件（配置文件） <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.or.
IDEA SpringBoot-Mybatis-plus 实现增删改查(CRUD)
「 虚幻私塾」
04-22 1746
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 上一篇: IDEA SpringBoot-Mybatis实现增删改查(CRUD) 下一篇:Intellij IDEA 高效使用教程 (插件,实用技巧) 最好用的idea
利用MyBatis-Plus灵活处理JSON字段：技巧与最佳实践
最新发布
weixin_53840353的博客
04-22 4456
在MP中操作JSON字段，首先需要在你的实体类中定义相应字段。通常，我们可以将JSON字段类型定义为String或者一个对应的Java类。// JSON类型字段// 省略其他属性和方法此处使用JsonNode类型来表示JSON字段，这是因为它可以容纳任意形式的JSON数据。接下来，你需要在你的MyBatis-Plus配置中注册你的。这样，MP就可以知道如何处理数据库中的JSON字段。
MyBatisPlus-JSON处理器
MMF博客园
01-18 713
MyBatisPlus-JSON处理器
Mybatis数据库存储json格式数据，实体类如何写同时如何完成json格式新增修改
Jie_SheYang的博客
09-26 1475
首先我们需要一个JackTypehandler完成Json的序列化和反序列化，这里我是对Double字段类型完成的序列化。实体类我们多一个实体类来映射前端传来的json格式的Key。然后在mapperXml文件这样写，这里是对修改的映射。前端我们就废话少说，直接上代码吧。
深入理解 MyBatis-Plus 中的 JSON 处理器及案例演示
jakelihua
07-31 1740
介绍：在现代应用开发中，经常会使用 JSON 格式存储和传输数据。为了便捷地处理数据库中的 JSON 字段，MyBatis-Plus 提供了强大的 JSON 处理器。本文将详细讲解 MyBatis-Plus 中的 JSON 处理器的用法，并结合一个具体案例进行演示和说明。
Mybatis-Puls MySQL存入json格式数据
qq_44021541的博客
08-12 1682
MySQL存入JSON
MybatisPlus插入关键字字段、插入\查询类型为json类型的字段
qq_36972185的博客
07-12 4038
MybatisPlus插入关键字字段 @TableField(value = "`key`") private String key; MybatisPlus插入类型为json类型的字段 @TableField(typeHandler = FastjsonTypeHandler.class) private JSONObject operateContent; 参考：mybatis-plus 实体 json 处理 Mybatis插入实体类字段为关键字解决方案 ...
JSON操作示例：增删改查
"该资源提供了一个关于JSON操作的示例，包括如何进行增、删、改、查。通过示例代码展示了如何创建JSON对象、将字符串转换为JSON、将JSON转换回字符串，以及如何解析JSON数据和修改JSON对象的结构。" 在编程中，JSON...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值