• 关于MybatisPlus使用的部分经验

    mybatis plus是我国程序员对mybatis框架的一个近国人开发习惯的改版，使用起来风格特殊，大部分的CRUD接口都需要自己尝试测试之后才能熟悉它的作用，使用起来的好处也很明显，相比于mybatis框架而言，它的dao层与service层对CRUD代码量进行了进一步的减少，使得我们在开发过程中只需要对controller层与特殊的核心业务进行大精力开发，常规业务它都给我们内置了。

    关于这个框架的常规CRUD接口，大家可以查看官方文档，讲解的比较详细：CRUD 接口 | MyBatis-PlusMyBatis-Plus 官方文档https://www.baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

     我通过一个登录的controller层代码对mybatis plus进行经验分享：

    下面先看代码：

    1. @Slf4j
    2. @RestController
    3. @RequestMapping("/User")
    4. public class UserController {
    5.     @Autowired
    6.     private UserService userService;
    7.     @Autowired
    8.     private RequestUtils requestUtils;
    9.     @Autowired
    10.     private AppinfoService appinfoService;
    11.  
    12.     /**
    13.      * 用户采用微信登录
    14.      *
    15.      * @return 登录成功返回响应对象
    16.      */
    17.     @GetMapping("/wechatLogin")
    18.     @ResponseBody
    19.     public R WeChatLogin(@RequestParam("code") String code, @RequestParam("userName") String userName) {
    20.         try {
    21.         /*1.优化点：如果可以让第一次登录的openId存储在小程序本地内存中，只需在前端判断是否这个openId为空，
    22.         如果不为空，直接传到后端查数据库，避免了每一次都要访问一次微信登录网址的时间消耗。*/
    23.             QueryChainWrapper query = appinfoService.query();
    24.             Appinfo appinfo = query.list().get(0);
    25.             String weChatOPenId = requestUtils.getWeChatOPenId(appinfo.getAppId(), appinfo.getAppSecrtet(), code);
    26.  
    27.             QueryWrapper wrapper = new QueryWrapper<>();
    28.             wrapper.ge("WeChatId", weChatOPenId);
    29.             int count = (int) userService.count(wrapper);
    30.  
    31.             if (count == 1) {
    32.                 UpdateWrapper updateWrapper = new UpdateWrapper<>();
    33.                 updateWrapper.eq("WeChatId", weChatOPenId);
    34.                 User user = new User();
    35.                 user.setUserName(userName);
    36.                 boolean update = userService.update(user, updateWrapper);
    37.                 if (update) return R.success("登陆成功！");
    38.                 else throw new Exception("更新用户名异常！");
    39.             } else {
    40.                 User user = new User();
    41.                 user.setWeChatId(weChatOPenId);
    42.                 user.setUserName(userName);
    43.                 user.setUserAccount(weChatOPenId);
    44.                 boolean save = userService.save(user);
    45.                 if (save) return R.success("登录成功！");
    46.                 else throw new Exception("新用户openId插入数据库异常！");
    47.             }
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.             return R.error("微信登录异常！");
    51.         }
    52.     }
    53.  
    54. }
      55.  

      涉及到微信小程序中后台获取openId的方法，我把代码先放这里：
       

      1. @Component
      2. public class RequestUtils {
      3.     /**
      4.      * 获取微信小程序openid
      5.      *
      6.      * @param AppId     小程序Id
      7.      * @param AppSecret 小程序密钥
      8.      * @param code      小程序wx.login接口返回的临时的临时状态码
      9.      * @return openid
      10.      */
      11.     public  String getWeChatOPenId(String AppId, String AppSecret, String code) {
      12.         try {
      13.             /*1.拼接微信登录获取openId所需要访问的URL*/
      14.             StringBuilder URL = new StringBuilder(WeChatConfig.loginUrl).append("?appId=").append(AppId).
      15.                     append("&secret=").append(AppSecret).append("&js_code=").append(code).
      16.                     append("&grant_type=authorization_code");
      17.             /*2.创建http连接的客户端对象*/
      18.             BasicHttpClientConnectionManager connectionManager;
      19.             connectionManager = new BasicHttpClientConnectionManager(
      20.                     RegistryBuilder.create().
      21.                             register("http", PlainConnectionSocketFactory.getSocketFactory())
      22.                             .register("https", SSLConnectionSocketFactory.getSocketFactory())
      23.                             .build(), null, null, null
      24.             );
      25.             CloseableHttpClient httpClient = HttpClientBuilder.create().
      26.                     setConnectionManager(connectionManager)
      27.                     .build();
      28.             HttpGet httpGet = new HttpGet(URL.toString());
      29.             /*3.执行访问一次请求获取响应体内容*/
      30.             HttpResponse httpResponse = httpClient.execute(httpGet);
      31.             HttpEntity entity = httpResponse.getEntity();
      32.             String s = EntityUtils.toString(entity, "UTF-8");
      33.             JSONObject jsonObject = new JSONObject(s);
      34.             /*4.从响应体中拿到openId并返回*/
      35.             return jsonObject.get("openid").toString();
      36.         } catch (Exception e) {
      37.             System.out.println("---------小程序获取微信登录openId异常--------");
      38.             e.printStackTrace();
      39.         }
      40.         /*出现异常即返回null*/
      41.         return null;
      42.     }
      43.  
      44. }
       

      下面我们来逐步看登录的代码：
       

      1、获取小程序关键信息调用getWeChatOpenId方法获取openId。
       

      1. QueryChainWrapper query = appinfoService.query();
      2. Appinfo appinfo = query.list().get(0);
      3. String weChatOPenId = requestUtils.getWeChatOPenId(appinfo.getAppId(),appinfo.getAppSecrtet(), code);
       

      这里使用到了service层从IService继承来的方法query();
       

      我们看下query的源码：
       

      1.   default QueryChainWrapper query() {
      2.         return ChainWrappers.queryChain(this.getBaseMapper());
      3.     }
       

      它的返回值类型是QueryChainWrapper，我们去看看这个类型的源码：
       

      1. public class QueryChainWrapper 
      2. extends AbstractChainWrapper, QueryWrapper> 
      3. implements ChainQuery, Query, T, String> 
       

      它继承了AbstractChainWrapper父类，实现了ChainQuery接口，我们来看看这个接口的方法：
       

      1. public interface ChainQuery extends ChainWrapper {
      2.     default List list() {
      3.         return this.getBaseMapper().selectList(this.getWrapper());
      4.     }
      5.  
      6.     default T one() {
      7.         return this.getBaseMapper().selectOne(this.getWrapper());
      8.     }
      9.  
      10.     default Optional oneOpt() {
      11.         return Optional.ofNullable(this.one());
      12.     }
      13.  
      14.     default Long count() {
      15.         return SqlHelper.retCount(this.getBaseMapper().selectCount(this.getWrapper()));
      16.     }
      17.  
      18.     default boolean exists() {
      19.         return this.count() > 0L;
      20.     }
      21.  
      22.     default extends IPage> E page(E page) {
      23.         return this.getBaseMapper().selectPage(page, this.getWrapper());
      24.     }
      25. }
       

      这里不难发现，我们的query.list();方法就是从这里得来的，显然就是从BaseMapper这个通用的类里得来的方法，这么看其实这些CRUD接口方法不过是从底层的BaseMapper拓展出来的。
       

      这里是IService可调用关于查询的方法
       

      1. // 根据 ID 查询
      2. T getById(Serializable id);
      3. // 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
      4. T getOne(Wrapper queryWrapper);
      5. // 根据 Wrapper，查询一条记录
      6. T getOne(Wrapper queryWrapper, boolean throwEx);
      7. // 根据 Wrapper，查询一条记录
      8. Map getMap(Wrapper queryWrapper);
      9. // 根据 Wrapper，查询一条记录
      10.  V getObj(Wrapper queryWrapper, Functionsuper Object, V> mapper);
      11.  
      12.  
      13. // 查询所有
      14. List list();
      15. // 查询列表
      16. List list(Wrapper queryWrapper);
      17. // 查询（根据ID 批量查询）
      18. Collection listByIds(Collection idList);
      19. // 查询（根据 columnMap 条件）
      20. Collection listByMap(Map columnMap);
      21. // 查询所有列表
      22. List> listMaps();
      23. // 查询列表
      24. List> listMaps(Wrapper queryWrapper);
      25. // 查询全部记录
      26. List listObjs();
      27. // 查询全部记录
      28.  List listObjs(Functionsuper Object, V> mapper);
      29. // 根据 Wrapper 条件，查询全部记录
      30. List listObjs(Wrapper queryWrapper);
      31. // 根据 Wrapper 条件，查询全部记录
      32.  List listObjs(Wrapper queryWrapper, Functionsuper Object, V> mapper);
      33.  
      34. // 无条件分页查询
      35. IPage page(IPage page);
      36. // 条件分页查询
      37. IPage page(IPage page, Wrapper queryWrapper);
      38. // 无条件分页查询
      39. IPage> pageMaps(IPage page);
      40. // 条件分页查询
      41. IPage> pageMaps(IPage page, Wrapper queryWrapper);
      42.  
      43.  
      44. // 查询总记录数
      45. int count();
      46. // 根据 Wrapper 条件，查询总记录数
      47. int count(Wrapper queryWrapper);
      48.  
        49.  

        2、查询数据库是否存在主键WeChatId等于该登录用户openId的记录。
         

        1.  QueryWrapper wrapper = new QueryWrapper<>();
        2.  wrapper.ge("WeChatId", weChatOPenId);
        3.  int count = (int) userService.count(wrapper);
         

        这里涉及到我们自行创建的实例wrapper，也即是常说的条件构造器。看一下它的源码：
         

        1. public class QueryWrapper 
        2. extends AbstractWrapper> 
        3. implements Query, T, String> 
         

        继承了统一类型，看一下AbstractWrapper的源码：
         

        1.     public  Children allEq(boolean condition, Map params, boolean null2IsNull) {
        2.         if (condition && CollectionUtils.isNotEmpty(params)) {
        3.             params.forEach((k, v) -> {
        4.                 if (StringUtils.checkValNotNull(v)) {
        5.                     this.eq(k, v);
        6.                 } else if (null2IsNull) {
        7.                     this.isNull(k);
        8.                 }
        9.  
        10.             });
        11.         }
        12.  
        13.         return this.typedThis;
        14.     }
        15.     public  Children allEq(boolean condition, BiPredicate filter, Map params, boolean null2IsNull) {
        16.         if (condition && CollectionUtils.isNotEmpty(params)) {
        17.             params.forEach((k, v) -> {
        18.                 if (filter.test(k, v)) {
        19.                     if (StringUtils.checkValNotNull(v)) {
        20.                         this.eq(k, v);
        21.                     } else if (null2IsNull) {
        22.                         this.isNull(k);
        23.                     }
        24.                 }
        25.  
        26.             });
        27.         }
        28.  
        29.         return this.typedThis;
        30.     }
        31.     public Children eq(boolean condition, R column, Object val) {
        32.         return this.addCondition(condition, column, SqlKeyword.EQ, val);
        33.     }
        34.     public Children ne(boolean condition, R column, Object val) {
        35.         return this.addCondition(condition, column, SqlKeyword.NE, val);
        36.     }
        37.     public Children gt(boolean condition, R column, Object val) {
        38.         return this.addCondition(condition, column, SqlKeyword.GT, val);
        39.     }
        40.     public Children ge(boolean condition, R column, Object val) {
        41.         return this.addCondition(condition, column, SqlKeyword.GE, val);
        42.     }
        43.     public Children lt(boolean condition, R column, Object val) {
        44.         return this.addCondition(condition, column, SqlKeyword.LT, val);
        45.     }
        46.     public Children le(boolean condition, R column, Object val) {
        47.         return this.addCondition(condition, column, SqlKeyword.LE, val);
        48.     }
        49.     public Children like(boolean condition, R column, Object val) {
        50.         return this.likeValue(condition, SqlKeyword.LIKE, column, val, SqlLike.DEFAULT);
        51.     }
        52.     public Children notLike(boolean condition, R column, Object val) {
        53.         return this.likeValue(condition, SqlKeyword.NOT_LIKE, column, val, SqlLike.DEFAULT);
        54.     }
        55.     public Children likeLeft(boolean condition, R column, Object val) {
        56.         return this.likeValue(condition, SqlKeyword.LIKE, column, val, SqlLike.LEFT);
        57.     }
        58.     public Children likeRight(boolean condition, R column, Object val) {
        59.         return this.likeValue(condition, SqlKeyword.LIKE, column, val, SqlLike.RIGHT);
        60.     }
        61.     public Children between(boolean condition, R column, Object val1, Object val2) {
        62.         return this.maybeDo(condition, () -> {
        63.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.BETWEEN, () -> {
        64.                 return this.formatParam((String)null, val1);
        65.             }, SqlKeyword.AND, () -> {
        66.                 return this.formatParam((String)null, val2);
        67.             });
        68.         });
        69.     }
        70.     public Children notBetween(boolean condition, R column, Object val1, Object val2) {
        71.         return this.maybeDo(condition, () -> {
        72.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.NOT_BETWEEN, () -> {
        73.                 return this.formatParam((String)null, val1);
        74.             }, SqlKeyword.AND, () -> {
        75.                 return this.formatParam((String)null, val2);
        76.             });
        77.         });
        78.     }
        79.     public Children and(boolean condition, Consumer consumer) {
        80.         return this.and(condition).addNestedCondition(condition, consumer);
        81.     }
        82.     public Children or(boolean condition, Consumer consumer) {
        83.         return this.or(condition).addNestedCondition(condition, consumer);
        84.     }
        85.     public Children nested(boolean condition, Consumer consumer) {
        86.         return this.addNestedCondition(condition, consumer);
        87.     }
        88.     public Children not(boolean condition, Consumer consumer) {
        89.         return this.not(condition).addNestedCondition(condition, consumer);
        90.     }
        91.     public Children or(boolean condition) {
        92.         return this.maybeDo(condition, () -> {
        93.             this.appendSqlSegments(SqlKeyword.OR);
        94.         });
        95.     }
        96.     public Children apply(boolean condition, String applySql, Object... values) {
        97.         return this.maybeDo(condition, () -> {
        98.             this.appendSqlSegments(WrapperKeyword.APPLY, () -> {
        99.                 return this.formatSqlMaybeWithParam(applySql, (String)null, values);
        100.             });
        101.         });
        102.     }
        103.     public Children last(boolean condition, String lastSql) {
        104.         if (condition) {
        105.             this.lastSql.setStringValue(" " + lastSql);
        106.         }
        107.  
        108.         return this.typedThis;
        109.     }
        110.     public Children comment(boolean condition, String comment) {
        111.         if (condition) {
        112.             this.sqlComment.setStringValue(comment);
        113.         }
        114.  
        115.         return this.typedThis;
        116.     }
        117.     public Children first(boolean condition, String firstSql) {
        118.         if (condition) {
        119.             this.sqlFirst.setStringValue(firstSql);
        120.         }
        121.  
        122.         return this.typedThis;
        123.     }
        124.     public Children exists(boolean condition, String existsSql, Object... values) {
        125.         return this.maybeDo(condition, () -> {
        126.             this.appendSqlSegments(SqlKeyword.EXISTS, () -> {
        127.                 return String.format("(%s)", this.formatSqlMaybeWithParam(existsSql, (String)null, values));
        128.             });
        129.         });
        130.     }
        131.     public Children notExists(boolean condition, String existsSql, Object... values) {
        132.         return this.not(condition).exists(condition, existsSql, values);
        133.     }
        134.     public Children isNull(boolean condition, R column) {
        135.         return this.maybeDo(condition, () -> {
        136.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.IS_NULL);
        137.         });
        138.     }
        139.     public Children isNotNull(boolean condition, R column) {
        140.         return this.maybeDo(condition, () -> {
        141.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.IS_NOT_NULL);
        142.         });
        143.     }
        144.     public Children in(boolean condition, R column, Collection coll) {
        145.         return this.maybeDo(condition, () -> {
        146.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.IN, this.inExpression(coll));
        147.         });
        148.     }
        149.     public Children in(boolean condition, R column, Object... values) {
        150.         return this.maybeDo(condition, () -> {
        151.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.IN, this.inExpression(values));
        152.         });
        153.     }
        154.     public Children notIn(boolean condition, R column, Collection coll) {
        155.         return this.maybeDo(condition, () -> {
        156.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.NOT_IN, this.inExpression(coll));
        157.         });
        158.     }
        159.     public Children notIn(boolean condition, R column, Object... values) {
        160.         return this.maybeDo(condition, () -> {
        161.             this.appendSqlSegments(this.columnToSqlSegment(column), SqlKeyword.NOT_IN, this.inExpression(values));
        162.         });
        163.     }
         

        不难发现里面有很多与linux的脚本程序的逻辑代码eq之类的两个字母代表逻辑关系。这些都是数据库常用的比较方法。
         

        3、如果用户登录过，需要实时更新用户的微信昵称。
         

        1.  UpdateWrapper updateWrapper = new UpdateWrapper<>();
        2.  updateWrapper.eq("WeChatId", weChatOPenId);
        3.  User user = new User();
        4.  user.setUserName(userName);
        5.  boolean update = userService.update(user, updateWrapper);
        6.  if (update) return R.success("登陆成功！");
        7.  else throw new Exception("更新用户名异常！");
         

        这里需要注意的是wrapper条件构造器给的是比较，也就是sql语句中where的作用，实际上的user.setUserName(userName);决定的是set的作用（这里说的是update 表名 set 属性 = value  where 属性 = value 中的关键字）。
         

        4、如果用户没有登录过，就可以将唯一标识与相关信息插入数据库
         

        1. User user = new User();
        2. user.setWeChatId(weChatOPenId);
        3. user.setUserName(userName);
        4. user.setUserAccount(weChatOPenId);
        5. boolean save = userService.save(user);
        6. if (save) return R.success("登录成功！");
        7. else throw new Exception("新用户openId插入数据库异常！");
         

        这个就很简单的逻辑了，大家自行查看mybatisplus的CRUD接口描述也可以弄清楚的。
         

        至于微信登录后台发请求获取openId的方法，大家可以看我写的这两篇文章：
         

        http://t.csdn.cn/vklXHhttp://t.csdn.cn/vklXHhttp://t.csdn.cn/SA2xQhttp://t.csdn.cn/SA2xQ
        
                
                    
                

                
      49. 

                    相关阅读:
        
                    
c++知识点之 --输入输出                            
        
视频号视频提取小程序，快速下载视频号视频                            
        
sqoop连接MYSQL报错处理                            
        
python机器学习之梯度下降法                            
        
【集合】如果初始化HashMap，传一个17的值，它会怎么处理？                            
        
学者观察 | 数字经济中长期发展中的区块链影响力——清华大学柴跃廷                            
        
mkv转mp4，大家都在用的方法                            
        
Python教程：csv如何保存字典数据                            
        
12 克莱姆法则的几何解释                            
        
Chapter0.1：拉普拉斯变换                            
        
                            
                
        50. 
                
      50. 
                    原文地址：https://blog.csdn.net/m0_59588838/article/details/126310548
                
        51.