七天晒网
七天晒网

Mybatis-Plus学习（Spring Boot项目）

今天依然很困 11.27
还有这么多(；д；) 我太难了
狗屎，我觉得今天也搞不完11.28
今晚摸鱼（大草）11.29
哦哦，好几天没看这个了，今天完成它12.2
打扰了，今天继续12.4




文章目录

  • 初识
  • 特性
  • Spring Boot
    • 导入依赖
    • 通用Mapper - CRUD接口
    • MP的默认主键策略
    • Select操作
    • 条件构造器
    • UPDATE&DELETE
    • 通用Service
    • 分页查询
    • 使用自定义SQL
  • 参考实战二（已修改部分代码）
    • 导入依赖
    • application.properties
    • Config配置（注解）
    • 启动类MapperScan
    • dao 接口

初识

Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
它已经封装好了一些crud方法，我们不需要再写xml了，直接调用这些方法就行，就类似于JPA。（话说JPA是啥(等把手头上的看完再去了解好了）

集成MyBatis-Plus非常的简单，只需要引入 starter 工程，并配置 mapper 扫描路径即可。
Mapper 继承BaseMapper接口后，无需编写 mapper.xml 文件，即可获得CRUD功能


特性

https://blog.csdn.net/magician_Code/article/details/102950173

  • 无侵入：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性
  • 依赖少：仅仅依赖 Mybatis 以及 Mybatis-Spring
  • 损耗小：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作
  • 预防Sql注入：内置Sql注入剥离器，有效预防Sql注入攻击
  • 通用CRUD操作：内置通用 Mapper、通用Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
  • 多种主键策略：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题 (?
  • 支持ActiveRecord：支持ActiveRecord 形式调用，实体类只需继承 Model 类即可实现基本 CRUD 操作 (?
  • 支持代码生成：采用代码或者 Maven插件可快速生成 Mapper 、 Model 、 Service 、 Controller层代码，支持模板引擎，更有超多自定义配置等您来使用（比 Mybatis 官方的 Generator 更加强大）
  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
  • 支持关键词自动转义：支持数据库关键词（order、key……）自动转义，还可自定义关键词
  • 内置分页插件：基于Mybatis物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询
  • 内置性能分析插件：可输出Sql语句以及其执行时间，建议开发测试时启用该功能，能有效解决慢查询
  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，预防误操作


Spring Boot

导入依赖

>
    >com.baomidou>
    >mybatis-plus-boot-starter>
    >3.2.0>
>

注：引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差异导致的问题。



通用Mapper - CRUD接口

前排提醒：为了方便看到MP操作数据库时使用的SQL语句，把mapper包或者项目日志级别logging.level配置为TRACE。

通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键， Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为 条件构造器
————————————————
版权声明：本文为CSDN博主「magic__Coder」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/magician_Code/article/details/102950173

DAO层的数据库操作接口通过继承通用Mappercom.baomidou.mybatisplus.core.mapper.BaseMapper来使用MP提供的CRUD能力，使得我们可以不用写SQL语句，更简便的操作数据库。
创建之前提到的两个DO类对应的DAO操作类：

public interface TeamMapper extends BaseMapper<Team> {
}

public interface PlayerMapper extends BaseMapper<Player> {
}

在Spring Boot启动类中使用@MapperScan配置Mapper包扫描。



MP的默认主键策略

值 描述
AUTO 数据库自增
INPUT 数据库自增
ID_WORKER 分布式全局唯一ID 长整型类型
UUID 32位UUID字符串
NONE 无状态
ID_WORKER_STR 分布式全局唯一ID 字符串类型

MP默认的主键策略是ID_WORKER，所以我们Insert操作生成的数据id为一串数字。要修改MP的主键策略，可以通过全局和局部的配置。

全局配置主键是MP配置项（MP配置大全）的一部分，通过在Spring Boot的配置文件中配置mybatis-plus.global-config.db-config.id-type即可。

局部配置则是通过一个成员变量注解@TableId来实现，以下是该注解的描述：

属性 类型 必须指定 默认值 描述
value String 否 " " 主键字段名
type Enum 否 IdType.NONE 主键类型

TableId注解除了声明Id策略的type外，还有一个名为value的属性，这个属性定义的是当我们的数据表实体的主键名。
在MP中，默认的数据库主键名为id，如果我们表实体主键不是起名为id，那么我们就需要配置这个属性。
我们可以看到，声明的DO类默认的Id策略是NONE，这个时候就受全局配置的影响。我们可以尝试把MP全局主键策略配置为AUTO，即自增长策略，注意，这时也需要数据表启用自增长策略。



Select操作

Select相关方法：

  • T selectById(Serializable id);// 根据 ID 查询
  • ListselectBatchIds(@Param(Constants.COLLECTION) Collection idList);// 根据 ID 查询
  • ListselectByMap(@Param(Constants.COLUMN_MAP) MapcolumnMap);// 查询（根据 columnMap 条件）
  • T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据entity 条件，查询一条记录
  • Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 Wrapper 条件，查询总记录数
  • List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据entity 条件，查询全部记录
  • List>selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据Wrapper 条件，查询全部记录
  • List selectObjs(@Param(Constants.WRAPPER)Wrapper queryWrapper);// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
  • IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据 entity 条件，查询全部记录（并翻页）
  • List item IPage> selectMapsPage(IPage page @Param(Constants.WRAPPER) Wrapper queryWrapper);// 根据Wrapper条件，查询全部记录（并翻页）

    • MP中的Select和Delete都提供了多种操作，总的来说可以分成根据Id操作、根据columnMap操作（Map设置表字段和值）和根据Wrapper操作（Wrapper是MP提供的条件构造器，可以实现很强大的功能）。
    上面最后两个是关于分页的查询，这部分将在本文后面进行讲解。
    根据Id和根据columnMap操作相对比较简单，实现的功能也相对有限，这里先看几个例子：

    @Test
public void testSelectById() {
    // 查找Id为1的球队
    Team team = teamMapper.selectById(1L);
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE id=?
    // Parameters: 1(Long)
    Assertions.assertNotNull(team);

    // 查找Id为1、2、3的球队
    List<Team> teamList = teamMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE id IN ( ? , ? , ? )
    // Parameters: 1(Long), 2(Long), 3(Long)
    Assertions.assertNotEquals(0, teamList.size());
}

@Test
public void testSelectByMap() {
    // 查找洛杉矶的球队
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("city", "Los Angeles");   // Key值为数据库列名
    List<Team> teamList = teamMapper.selectByMap(columnMap);
    // MP执行的SQL：
    // Preparing: SELECT id,city,name FROM team WHERE city = ?
    // Parameters: Los Angeles(String)
    Assertions.assertNotEquals(0, teamList.size());
}


    条件构造器

    MP关于条件构造器主要涉及到AbstractWrapper、QueryWrapper(LambdaQueryWrapper)和UpdateWrapper(LambdaUpdateWrapper)。

    • AbstractWrapper
      • QueryWrapper(LambdaQueryWrapper)和UpdateWrapper(LambdaUpdateWrapper)的父类，用于生成sql的where条件，entity属性也用于生成sql的where条件。
      • 注意：entity生成的where条件与使用各个api生成的where条件没有任何关联行为。
    • QueryWrapper
      • 继承自AbstractWrapper，自身的内部属性entity也用于生成where条件，LambdaQueryWrapper可以通过new QueryWrapper().lambda()方法获取。
    • UpdateWrapper
      • 继承自AbstractWrapper，自身的内部属性entity也用于生成where条件，LambdaUpdateWrapper可以通过new UpdateWrapper().lambda()方法获取。

    条件构造器包含了基本上所有的SQL操作，光看概念会有点抽象，接下来我们用一些实际的例子来近距离感受下条件构造器的强大功能。

    @SpringBootTest
class PlayerMapperTest {

    @Autowired
    private PlayerMapper playerMapper;

    /*
    1.球员姓名包含Kyle且号码小于40的球员
    name LIKE '%Kyle%' AND no < 40
     */
    @Test
    public void testQuery1() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle").lt("no", 40);

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND no < ?)
        // Parameters: %Kyle%(String), 40(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    2.球员姓名包含Kyle且号码大于等于0且小于等于20并且team_id不为空
    name LIKE '%Kyle%' AND no BETWEEN 20 AND 40 AND team_id IS NOT NULL
     */
    @Test
    public void testQuery2() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle")
                    .between("no", 0, 20)
                    .isNotNull("team_id");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND no BETWEEN ? AND ? AND team_id IS NOT NULL)
        // Parameters: %Kyle%(String), 0(Integer), 20(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    3.球员姓名以Anthony开头或者球员号码大于等于25，按照号码降序排序，号码相同按照team_id升序排序
    name LIKE 'Anthony%' OR no >= 25 ORDER BY no DESC, team_id ASC
     */
    @Test
    public void testQuery3() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.likeRight("name", "Anthony")   // 以 LIKE 'X%' 形式
                    .or().gt("no", 25)  // 调用 .or() 即可以 or 形式连接
                    .orderByDesc("no")
                    .orderByAsc("team_id");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? OR no > ?) ORDER BY no DESC , team_id ASC
        // Parameters: Anthony%(String), 25(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    4.球员姓名包含Anthony并且所属球队为Lakers
    name LIKE '%Anthony%' AND team_id IN (SELECT id FROM team WHERE name = 'Lakers')
     */
    @Test
    public void testQuery4() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Anthony")
                    .inSql("team_id", "SELECT id FROM team WHERE name = 'Lakers'"); // in 操作

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND team_id IN (SELECT id FROM team WHERE name = 'Lakers'))
        // Parameters: %Anthony%(String)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    5.球员姓名包含Kyle并且（球员号码小于40或者team_id不为空）
    name LIKE '%Kyle%' AND (no < 40 OR team_id IS NOT NULL)
     */
    @Test
    public void testQuery5() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "Kyle")
                    // .and(qw -> qw.lt("no", 40).or().isNotNull("team_id"))    // AND 嵌套
                    .nested(qw -> qw.lt("no", 40).or().isNotNull("team_id"));   // 正常嵌套 不带 AND 或者 OR

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? AND ( (no < ? OR team_id IS NOT NULL) ))
        // Parameters: %Kyle%(String), 40(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    6.球员姓名以Kyle开头或者（球员号码小于40并且号码大于0并且team_id不为空）
    name LIKE 'Kyle%' AND (no < 40 AND no > 0 AND team_id IS NOT NULL)
     */
    @Test
    public void testQuery6() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.likeRight("name", "Kyle")
                // .or(qw -> qw.lt("no", 40).gt("no", 0).isNotNull("team_id"))    // OR 嵌套
                .or().nested(qw -> qw.lt("no", 40).gt("no", 0).isNotNull("team_id"));   // 正常嵌套 不带 AND 或者 OR

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (name LIKE ? OR ( (no < ? AND no > ? AND team_id IS NOT NULL) ))
        // Parameters: Kyle%(String), 40(Integer), 0(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    7.（球衣号码小于40或team_id不为空）并且姓名以LeBron开头
    (no < 40 OR team_id IS NOT NULL) AND name LIKE 'LeBron%'
     */
    @Test
    public void testQuery7() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.nested(qw -> qw.lt("no", 40).or().isNotNull("team_id"))
                    .likeRight("name", "LeBron");

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (( (no < ? OR team_id IS NOT NULL) ) AND name LIKE ?)
        // Parameters: 40(Integer), LeBron%(String)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    8.球员号码为3, 13, 23, 33
    no in (3, 13, 23, 33)
     */
    @Test
    public void testQuery8() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.in("no", Arrays.asList(3, 13, 23, 33));

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (no IN (?,?,?,?))
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    9.limit
    LIMIT 1
     */
    @Test
    public void testQuery9() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.in("no", Arrays.asList(3, 13, 23, 33))
                    .last("limit 1");   // 无视优化规则直接拼接到 sql 的最后；只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,no,team_id,name FROM player WHERE (no IN (?,?,?,?)) limit 1
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    10.select
    SELECT id, name
    FROM player
     */
    @Test
    public void testQuery10() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.select(Player.class, i -> i.getColumn().equals("id")||i.getColumn().equals("name"))    // 投影操作，指定返回的列
                    //.select("id", "name")   // 投影操作，指定返回的列
                    .in("no", Arrays.asList(3, 13, 23, 33));

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT id,name FROM player WHERE (no IN (?,?,?,?))
        // Parameters: 3(Integer), 13(Integer), 23(Integer), 33(Integer)
        Assertions.assertNotEquals(0, playerList.size());
    }

    /*
    11.使用统计函数
    SELECT team_id, AVG(no) avg_no, MAX(no) max_no
    FROM player
    GROUP BY team_id
    HAVING SUM(no) < 500
     */
    @Test
    public void testQuery11() {
        QueryWrapper<Player> queryWrapper = new QueryWrapper<>();

        queryWrapper.select("team_id", "AVG(no) avg_no", "MAX(no) max_no")  // select 可以直接使用聚合函数并且起别名
                    .groupBy("team_id") // group by
                    .having("max_no < 500");   // 通过 sql 指定 having

        List<Player> playerList = playerMapper.selectList(queryWrapper);
        // MP执行的SQL：
        // Preparing: SELECT team_id,AVG(no) avg_no,MAX(no) max_no FROM player GROUP BY team_id HAVING SUM(no) < 500
        // Parameters:
        Assertions.assertNotEquals(0, playerList.size());
    }

}


    通用Mapper还提供了selectOne 、selectMaps等方法，大家可以自行设计应用场景来熟悉我们没有使用到的方法，调用方法都类似。

    另外，这里再介绍一个更优雅的查询方式，使用QueryChainWrapper进行操作，一步到位：

    @Test
public void testQueryChain() {
    QueryChainWrapper<Player> queryChainWrapper = new QueryChainWrapper<>(playerMapper);
    List<Player> playerList = queryChainWrapper.eq("team_id", 1)
        .list();    // 其底层是调用了 BaseMapper.selectList
    Assertions.assertNotEquals(0, playerList.size());
    // MP执行的SQL：
    // Preparing: SELECT team_id,AVG(no) avg_no,MAX(no) max_no FROM player GROUP BY team_id HAVING max_no < 500
    // Parameters:
}

    之前还提到了LambdaQueryWrapper，使用方法跟QueryWrapper类似，而且LambdaQueryWrapper可以定制查询的列：

    @Test
public void testQueryLambda() {
    // 三种构建 LambdaQueryWrapper 的方法：
    //LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //LambdaQueryWrapper lambdaQueryWrapper = new QueryWrapper().lambda();
    LambdaQueryWrapper<Player> lambdaQueryWrapper = Wrappers.lambdaQuery();
    
    lambdaQueryWrapper.eq(Player::getTeamId, 1L);
    List<Player> playerList = playerMapper.selectList(lambdaQueryWrapper);
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    Assertions.assertNotEquals(0, playerList.size());

    LambdaQueryChainWrapper<Player> lambdaQueryChainWrapper = new LambdaQueryChainWrapper<>(playerMapper);
    playerList = lambdaQueryChainWrapper.eq(Player::getTeamId, 1L).list();
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    Assertions.assertNotEquals(0, playerList.size());
}

    不管是QueryWrapper还是LambdaQueryWrapper，除了上面提到的构造方法外，都有对应的传入一个entity的构造方法，这时候MP在构造WHERE时会把entity的非空属性以AND的形式直接添加，并且与条件构造器本身设置的条件不冲突。但是以entity的形式只是简单的用=条件，例如：

    @Test
public void testQueryEntity() {
    Player player = new Player();
    player.setName("James");

    QueryWrapper<Player> queryWrapper = new QueryWrapper<>(player);
    queryWrapper.eq("team_id", 1L);
    List<Player> playerList = playerMapper.selectList(queryWrapper);
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE name=? AND (team_id = ?)
    // Parameters: James(String), 1(Long)
    Assertions.assertNotEquals(0, playerList.size());
}

    这段单元测试会失败，因为playerList.size()为0，这是由于查询条件name使用了=，如果我们希望name以LIKE的形式来构建查询，那么我们可以在name属性上设置@TableField(condition = SqlCondition.LIKE)，这时单元测试就跟我们预想的一样了。



    UPDATE&DELETE

    Mybatis-Plus学习（Spring Boot项目）_第1张图片
    Mybatis-Plus学习（Spring Boot项目）_第2张图片
    Mybatis-Plus学习（Spring Boot项目）_第3张图片



    通用Service

    MP的另一大特色是框架为我们提供了通用Service，使得我们只需关注系统业务。

    • 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 、remove 删除、list 查询集合 、page 分页 前缀命名方式区分 Mapper 层避免混淆。
    • 泛型 T 为任意实体对象 建议如果存在自定义通用 Service方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
      对象 Wrapper 为 条件构造器

    通用Service的操作跟通用Mapper类似，区别是按照Service层规范把DAO层的insert、select、delete改成了save、get\list和remove。

    现在我们也创建Service层的接口和实现类：

    public interface TeamService extends IService<Team> {
}

@Service
@Transactional
public class TeamServiceImpl extends ServiceImpl<TeamMapper, Team> implements TeamService {
}

public interface PlayerService extends IService<Player> {
}

@Service
@Transactional
public class PlayerServiceImpl extends ServiceImpl<PlayerMapper, Player> implements PlayerService {
}

    使用通用Service非常简单，声明接口时继承IService就可以拥有MP提供的通用Service的能力；实现类除了实现接口外还需要继承MP的ServiceImpl类，并传入通用Mapper和对应的DO对象。

    下面我们直接通过几个例子来使用MP的通用Service：

    @SpringBootTest
class TeamServiceTest {

    @Autowired
    TeamService teamService;

    @Test
    public void testSave() {
        Team team = new Team();
        team.setName("Nuggets");
        team.setCity("Denver");
        boolean result = teamService.save(team);
        Assertions.assertTrue(result);

        Team team1 = new Team();
        team1.setName("Grizzlies");
        team1.setCity("Memphis");
        Team team2 = new Team();
        team2.setName("NETS");
        team2.setCity("Brooklyn");
        Team team3 = new Team();
        team3.setName("Thunder");
        team3.setCity("Oklahoma");
        result = teamService.saveBatch(Arrays.asList(team1, team2, team3));
        Assertions.assertTrue(result);
    }

    @Test
    public void testSelect() {
        Team team = teamService.getOne(Wrappers.<Team>query().eq("id", 1L), false);
        Assertions.assertNotNull(team);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE (id = ?)
        // Parameters: 1(Long)

        List<Team> teamList = teamService.list(Wrappers.<Team>query().le("id", 5L));
        Assertions.assertNotEquals(0, teamList.size());
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE (id <= ?)
        // Parameters: 5(Long)
    }

    @Test
    public void testUpdate() {
        Team team = new Team();
        team.setId(1L);
        team.setName("Laker");
        boolean result = teamService.saveOrUpdate(team);    // saveOrUpdate 会先执行 SELECT BY Id 操作，如果找到有记录则进行 UPDATE 操作，否则进行 INSERT 操作
        Assertions.assertTrue(result);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE id=?
        // Parameters: 1(Long)
        // Preparing: UPDATE team SET name=? WHERE id=?
        // Parameters: Laker(String), 1(Long)

        team = new Team();
        team.setId(100L);
        team.setName("Blazers");
        team.setCity("Portland");
        result = teamService.saveOrUpdate(team);
        Assertions.assertTrue(result);
        // MP执行的SQL：
        // Preparing: SELECT id,city,name FROM team WHERE id=?
        // Parameters: 100(Long)
        // Preparing: INSERT INTO team ( id, city, name ) VALUES ( ?, ?, ? )
        // Parameters: 100(Long), Portland(String), Blazers(String)

        teamService.update(Wrappers.<Team>update().eq("id", 1L).set("name", "Lakers"));
        // MP执行的SQL：
        // Preparing: UPDATE team SET name=? WHERE (id = ?)
        // Parameters: Lakers(String), 1(Long)
    }

}

    我们可以看到，通用Service和通用Mapper操作方式基本保持一致，需要注意的是，通用Service的save和update操作返回值是boolean类型。另外，我们还可以用链式操作以更优雅的方式进行操作：

    @Test
public void testChain() {
    List<Team> teamList = teamService.query().select("id", "name").le("id", 5L).list();
    Assertions.assertNotEquals(0, teamList.size());
    // MP执行的SQL：
    // Preparing: SELECT id,name FROM team WHERE (id <= ?)
    // Parameters: 5(Long)
}

    分页查询

    在实际项目中用得最多也比较重要的业务应该就是分页操作了，MP对分页操作也做了插件支持。

    在Spring Boot项目中使用MP的分页功能也非常简单，只需要在容器中注入PaginationInterceptor对象即可。这里以@Configuration配置：

    @EnableTransactionManagement
@Configuration
public class MyBatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        return paginationInterceptor;
    }
}

    有了这个配置，就可以在项目中使用MP的分页插件了。其中通用Mapper和通用Service都提供了分页查询的相关功能，我们以通用Service为例使用MP的分页功能。

    首先我们来看一下分页功能最重要的一个接口IPage，这里直接上源码：

    public interface IPage<T> extends Serializable {

    /**
     * 降序字段数组
     *
     * @return order by desc 的字段数组
     * @see #orders()
     */
    @Deprecated
    default String[] descs() {
        return null;
    }

    /**
     * 升序字段数组
     *
     * @return order by asc 的字段数组
     * @see #orders()
     */
    @Deprecated
    default String[] ascs() {
        return null;
    }

    /**
     * 获取排序信息，排序的字段和正反序
     *
     * @return 排序信息
     */
    List<OrderItem> orders();

    /**
     * KEY/VALUE 条件
     *
     * @return ignore
     */
    default Map<Object, Object> condition() {
        return null;
    }

    /**
     * 自动优化 COUNT SQL【 默认：true 】
     *
     * @return true 是 / false 否
     */
    default boolean optimizeCountSql() {
        return true;
    }

    /**
     * 进行 count 查询 【 默认: true 】
     *
     * @return true 是 / false 否
     */
    default boolean isSearchCount() {
        return true;
    }

    /**
     * 计算当前分页偏移量
     */
    default long offset() {
        return getCurrent() > 0 ? (getCurrent() - 1) * getSize() : 0;
    }

    /**
     * 当前分页总页数
     */
    default long getPages() {
        if (getSize() == 0) {
            return 0L;
        }
        long pages = getTotal() / getSize();
        if (getTotal() % getSize() != 0) {
            pages++;
        }
        return pages;
    }

    /**
     * 内部什么也不干
     * 
    只是为了 json 反序列化时不报错
    
     */    
    default IPage<T> setPages(long pages) {
        // to do nothing
        return this;
    }

    /**
     * 分页记录列表
     *
     * @return 分页对象记录列表
     */
    List<T> getRecords();

    /**
     * 设置分页记录列表
     */
    IPage<T> setRecords(List<T> records);

    /**
     * 当前满足条件总行数
     *
     * @return 总条数
     */
    long getTotal();

    /**
     * 设置当前满足条件总行数
     */
    IPage<T> setTotal(long total);

    /**
     * 当前分页总页数
     *
     * @return 总页数
     */
    long getSize();

    /**
     * 设置当前分页总页数
     */
    IPage<T> setSize(long size);

    /**
     * 当前页，默认 1
     *
     * @return 当前页
     */
    long getCurrent();

    /**
     * 设置当前页
     */
    IPage<T> setCurrent(long current);

    /**
     * IPage 的泛型转换
     *
     * @param mapper 转换函数
     * @param     转换后的泛型
     * @return 转换泛型后的 IPage
     */
    @SuppressWarnings("unchecked")
    default <R> IPage<R> convert(Function<? super T, ? extends R> mapper) {
        List<R> collect = this.getRecords().stream().map(mapper).collect(toList());
        return ((IPage<R>) this).setRecords(collect);
    }
}

    其中对我们比较重要的属性有current（当前页数）、size（每页记录数）、pages（总页数）、total(总记录数)和records（分页数据）。

    MP为我们提供了一个简单IPage实现：Page类。下面是一个简单的分页查询例子：

    @Test
public void testPage() {
    // 设置分页条件
    Page<Player> page = new Page<>();
    page.setCurrent(1);
    page.setSize(5);
    playerService.page(page, Wrappers.<Player>query().eq("team_id", 1L));
    // MP执行的SQL：
    // Preparing: SELECT COUNT(1) FROM player WHERE (team_id = ?)
    // Parameters: 1(Long)
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?) LIMIT ?,?
    // Parameters: 1(Long), 0(Long), 5(Long)

    //page.getPages();  // 总页数
    //page.getTotal();  // 总记录数
    // 分页结果保存在 page 的 records 属性中
    Assertions.assertNotEquals(0, page.getRecords().size());

    page.setSearchCount(false);    // 是否需要查询总记录数，这里设置不需要
    playerService.page(page, Wrappers.<Player>query().eq("team_id", 1L));
    // MP执行的SQL：
    // Preparing: SELECT id,no,team_id,name FROM player WHERE (team_id = ?) LIMIT ?,?
    // Parameters: 1(Long), 0(Long), 5(Long)
    Assertions.assertNotEquals(0, page.getRecords().size());
}

    这里有一点需要注意，就是当业务对表的总记录数不关心的时候，可以通过Page.setSearchCount(false)方法来避免执行SELECT COUNT(1)操作。

    很多时候我们的分页查询的业务会非常复杂，通过条件构造器也可能不能实现我们的需求，这时候就需要我们自己写SQL了，这不正是MyBatis的强项吗。好在MP对MyBatis原有的特性完全支持，使得我们可以自定义SQL。接下来我们重点讲解MP自定义SQL。

    使用自定义SQL

    普通操作（CURD）自定义SQL的MP打开方式：
    在Mapper中添加一个名为"ew"（MP规定，可以用Constants.WRAPPER这个值为"ew"的常量）的Wrapper类型参数：

    @Select("SELECT * FROM team ${ew.customSqlSegment}")    // Wrapper.customSqlSegment为自定义SQL的内容
List<Team> findMP(@Param(Constants.WRAPPER) Wrapper<Team> wrapper);

    调用时传入一个条件构造器即可，但需要注意的是，MP的这种自定义SQL的方式只能添加到WHERE条件，但WHERE中的判断逻辑可以省略（如AND或OR的拼接，都交给了Wrapper实现），而且WHERE关键字也不需要我们特地指定。然后通过以下方式调用：

    @Test
public void testCustomFindMP() {
    List<Team> teamList = teamMapper.findMP(Wrappers.<Team>query().le("id", 5L));
    // MP执行的SQL：
    // Preparing: SELECT * FROM team WHERE (id <= ?)
    // Parameters: 5(Long)
    Assertions.assertNotEquals(0, teamList.size());
}

    分页查询的自定义SQL也非常简单，在Mapper中定义分页查询（Page参数必须是第一个参数）：

    @Select("SELECT * FROM player ${ew.customSqlSegment}")
IPage<Player> pageCustomMP(Page page, @Param(Constants.WRAPPER) Wrapper<Player> wrapper);

    调用方式也是我们非常熟悉的方式：

    @Test
public void testPageCustomMP() {
    IPage<Player> playerIPage = playerMapper.pageCustomMP(new Page(1, 5), Wrappers.<Player>query().le("id", 5L));
    // MP执行的SQL：
    // Preparing: SELECT COUNT(1) FROM player WHERE (id <= ?)
    // Parameters: 5(Long)
    // Preparing: SELECT * FROM player WHERE (id <= ?) LIMIT ?,?
    // Parameters: 5(Long), 0(Long), 5(Long)
    Assertions.assertNotEquals(0, playerIPage.getRecords().size());
}



    参考实战二（已修改部分代码）

    https://blog.csdn.net/weixin_42752859/article/details/86703947

    导入依赖

     		>
            >com.baomidou>
            >mybatisplus-spring-boot-starter>
            >1.0.5>
        >

        >
            >com.baomidou>
            >mybatis-plus>
            >2.3>
        >

    application.properties

    server.port=8080

#mysql
spring.datasource.url=jdbc:mysql://localhost:3306/wssll?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#mybatis-plus
mybatis-plus.mapper-locations=classpath:mybatis/mapper/*Dao.xml   #在该xml中只写自定义的sql，如果没有特殊sql这行可以注了
mybatis-plus.type-aliases-package=io.ssss.wsssall.dal.dao

    Config配置（注解）

    @Configuration
public class MybatisConfig {
    @Bean
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(1000);
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
    // 配置数据源
    @Bean(name="dataSource")
    @ConfigurationProperties(prefix="spring.datasource")
    public DataSource dataSource(){
        return new DruidDataSource();
    }
    // 配置事物管理器
    @Bean(name="transactionManager")
    public DataSourceTransactionManager transactionManager(){
        return new DataSourceTransactionManager(dataSource());
    }

}

    启动类MapperScan

    @SpringBootApplication
@MapperScan("io.mssnk.wsssall.dal.dao")  //具体到dao的包
public class We1Application {

    public static void main(String[] args) {
        SpringApplication.run(We1Application.class, args);
    }

}

    dao 接口

    @Repository
public interface CartDao extends BaseMapper<Cart> {//BaseMapper是插件提供的一个通用接口，有很多方法
   Integer getMax();//这个是我自定义的一个方法，BaseMapper中没有的
}
``
7. Service调用并测试
}

    @Override
public Cart getById(Long id){
	return cartDao.selectById(id);  //这个是BaseMapper通用方法，id可以是Long,也可以是Integer
}

@Override
public List<Cart> findAll(Cart cart) {

	EntityWrapper<Cart> tWrapper = new  EntityWrapper<>() ;//
	//条件查询1,直接entity
	tWrapper.setEntity(cart);//可以接受一个domian对象作为查询条件
	//条件查询2，指定属性
	//tWrapper.eq("count",1).eq("status",0);//也可以自定义查询属性
	return cartDao.selectList(tWrapper);//这也是BaseMapper的通用方法，
}

@Override
public Integer getMax() {
	return cartDao.getMax();//这是我自定义的方法，需要在*Dao.xml中写具体sql实现

    如果没有复杂sql，直接用mybatis plus就可以省去xml的配置，免得各种报错，而且数据库表字段修改了，不再修改xml中的数据了！
    另外，另外plus支持的条件查询，不仅有eq，还有gt，lt，这是很多自动生成sql插件不具备的

    你可能感兴趣的:(Java)

    • 移动端城市区县二级联动选择功能实现包 good2know
      本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
    • 深入解析JVM工作原理：从字节码到机器指令的全过程
      一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
    • JVM 内存模型深度解析：原子性、可见性与有序性的实现 练习时长两年半的程序员小胡 JVM深度剖析：从面试考点到生产实践jvmjava内存模型
      在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
    • Java | 多线程经典问题 - 售票 Ada54
      一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
    • SpringMVC的执行流程
      1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
    • JAVA接口机结构解析 秃狼 SpringBoot八股文Javajava学习
      什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
    • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得 风平浪静如码
      前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
    • 图论算法经典题目解析：DFS、BFS与拓扑排序实战 周童學 数据结构与算法深度优先算法图论
      图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
    • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge 本本本添哥 002-进阶开发能力java
      一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
    • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五) bug菌¹ Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
      本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    • Java 队列 tryxr java开发语言队列
      队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
    • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
      在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
    • 代码随想录算法训练营第三十五天
      01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
    • 微信公众号回调java_处理微信公众号消息回调 weixin_39607620 微信公众号回调java
      1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
    • 学C++的五大惊人好处
      为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
    • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】 Tony666688888 javawindows开发语言
      针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
    • 用代码生成艺术字：设计个性化海报的秘密
      本文围绕“用代码生成艺术字：设计个性化海报的秘密”展开，先概述代码生成艺术字在海报设计中的独特价值，接着介绍常用的代码工具（如HTML、CSS、JavaScript等），详细阐述从构思到实现的完整流程，包括字体样式设计、动态效果添加等，还分享了提升艺术字质感的技巧及实际案例。最后总结代码生成艺术字的优势，为设计师提供打造个性化海报的实用指南，助力提升海报设计的独特性与吸引力，符合搜索引擎SEO标准
    • java实习生40多天有感 别拿爱情当饭吃
      从5月15日开始，我开始第一步步入社会，我今年大三，在一家上市互联网公司做一名实习生，主要做java后端开发。开始的时候，觉得公司的环境挺不错的，不过因为公司在CBD，所以隔壁的午饭和晚饭都要20+RMB，而且还吃不饱，这让我感觉挺郁闷的。一到下午，我就会犯困（因为饿）。因此，我又不得不买一些干粮在公司屯着。关于技术，有一个比较大的项目在需求调研当中，我们做实习生，就是辅助项目经理，测试功能，并且
    • 大学生入门：初识方法及其易踩坑的点
      在java学习过程中，我们不难发现有很多重复使用的功能代码块，每次使用如果都要重新写一遍，岂不是很麻烦，就算是“cv”大法，感觉也不是很方便，那么，有什么办法可以解决这个问题呢？方法！java中，一段可重用的，用于执行特定功能的代码块叫做方法，它可以接收参数、返回结果，并且可以被多次使用。一、方法的基本结构[修饰符]返回值类型方法名([参数列表])[throws异常类型]{//方法体}[throw
    • [Ljava.lang.Object; cannot be cast to [Ljava.lang.String; 这些不会的
      解释：这个错误是很常见的错误，错误的提示已经很清楚了就是java的Object数组不能转换成为String[]数组，这就说明你要转换的数组它本身是Object类型的数组，但是你却非要把它转换为String类的数组，这当然是错误的。示例：[java]viewplaincopypackagecom.dada;importjava.util.ArrayList;importjava.util.List;
    • HikariCP调试日志深度解析：生产环境故障排查完全指南
      HikariCP调试日志深度解析：生产环境故障排查完全指南更新时间：2025年7月4日|作者：资深架构师|适用版本：HikariCP5.x+|难度等级：中高级前言在生产环境中，数据库连接池往往是系统性能的关键瓶颈。HikariCP作为当前最流行的Java连接池，其调试日志包含了丰富的运行时信息，能够帮助我们快速定位和解决各种连接池相关问题。本文将深入解析HikariCP的日志体系，提供一套完整的故
    • 大学社团管理系统（11831） codercode2022 javaspringbootspringechartsspringcloudsentineljava-rocketmq
      有需要的同学，源代码和配套文档领取，加文章最下方的名片哦一、项目演示项目演示视频二、资料介绍完整源代码（前后端源代码+SQL脚本）配套文档（LW+PPT+开题报告）远程调试控屏包运行三、技术介绍Java语言SSM框架SpringBoot框架Vue框架JSP页面Mysql数据库IDEA/Eclipse开发四、项目截图有需要的同学，源代码和配套文档领取，加文章最下方的名片哦!
    • 今年校招竞争真激烈 12_05
      程序员满大街，都要找不到工作了。即使人工智能满大街，我也后悔当初没学机器学习，后悔当初没学Java。C++真难找工作。难道毕了业就失业吗？好担心！
    • 【免费下载】 Aspose for Java：解锁无水印、无限制的文档处理能力 房征劲Kendall
      AsposeforJava：解锁无水印、无限制的文档处理能力【下载地址】AsposeforJava-去除水印和数量限制AsposeforJava-去除水印和数量限制Aspose是一个著名的文档处理库，专为Java应用程序设计，支持多种文档格式的操作，如Word、Excel、PDF等项目地址:https://gitcode.com/open-source-toolkit/56c82项目介绍在现代企业
    • 微服务日志追踪，Skywalking接入TraceId功能 Victor刘 微服务skywalkingjava
      文章目录一、借助skywalking追加traceIdlogbacklog4j2效果二、让skywalking显示日志内容版本差异logback配置文件log4j2配置文件一、借助skywalking追加traceId背景：在微服务或多副本中难以观察一个链路的日志，需要通过唯一traceId标识来查找，下面介绍Skywalking-traceId在Java中的配置方法。介绍两种java日志的配置方
    • 【Java Web实战】从零到一打造企业级网上购书网站系统 | 完整开发实录（三） 笙囧同学 java前端状态模式
      核心功能设计用户管理系统用户管理是整个系统的基础，我设计了完整的用户生命周期管理：用户注册流程验证失败验证通过验证失败验证通过用户名已存在用户名可用失败成功用户访问注册页面填写注册信息前端表单验证显示错误提示提交到后端后端数据验证返回错误信息用户名唯一性检查提示用户名重复密码加密处理保存用户信息保存成功?显示系统错误注册成功跳转登录页面登录认证机制深度解析我实现了一套企业级的多层次安全认证机制：认
    • Java：数据结构-ArrayList和顺序表（2） blammmp java数据结构开发语言
      一ArrayList的使用1.ArrayList的构造方法第一种（指定容量的构造方法）创建一个空的ArrayList，指定容量为initialCapacity。publicArrayList(intinitialCapacity){if(initialCapacity>0){this.elementData=newObject[initialCapacity];}elseif(initialCap
    • CMS垃圾回收器和G1垃圾回收器区别_g1cms垃圾回收器区别 2401_89191885 jvm
      该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例；加载该类的ClassLoader已经被回收；该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。3.常见的垃圾回收算法1、Mark-Sweep（标记-清除算法）：（1）思想：标记清除算法分为两个阶段，标记阶段和清除阶段。标记阶段任务是标记出所有需要回收的对象，清除阶段就是清除被标
    • 每日面试题15：如何解决堆溢出？ ℡余晖^ 每日面试题python开发语言
      在Java应用运行过程中，"java.lang.OutOfMemoryError:Javaheapspace"是最常见的错误之一。无论是高并发的电商大促场景，还是持续运行的后台服务，堆内存溢出都可能导致服务不可用、数据丢失，甚至引发系统崩溃。本文将结合实际排查经验，系统讲解堆溢出的底层逻辑、应急处理流程及长效预防策略。一、堆溢出的本质：内存分配的"收支失衡"Java堆是JVM管理的内存区域，用于存
    • 记录自己第n次面试(n＞3) Warren98 Java面试python职场和发展java开发语言服务器linux
      1.Spring Boot可执行JAR的内存分配答：“在Spring Boot可执行JAR中，JVM的内存通常分为两大块：堆（Heap）和栈（Stack）。堆内存：存放对象实例和数组，通过-Xms（初始）和-Xmx（最大）控制。比如java-Xms512m-Xmx1024m-jarapp.jar，表示启动时给512 MB堆，最大可以到1 024 MB。栈内存：每个线程有独立的栈帧，用来保存方法调用
    • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIPHPandroidlinux
      ╔-----------------------------------╗┆                           
    • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net.net mvc
      在.net mvc5中，在执行某一操作的时候，出现了如下错误：       各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  &
    • Java 对象大小的计算 e200702084 java
                                Java对象的大小 如何计算一个对象的大小呢？    
    • Mybatis Spring 171815164 mybatis
      ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
    • JVM 不稳定参数 g21121 jvm
              -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    • 用户自动登录网站 永夜-极光 用户
      1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie            每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    • centos7 安装后失去win7的引导记录 程序员是怎么炼成的 操作系统
      1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
      Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    • JavaEE开源快速开发平台G4Studio_V3.2发布了 無為子 AOPoraclemysqljavaeeG4Studio
        我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。   访问G4Studio网站 http://www.g4it.org   G4Studio_V3.2版本变更日志 功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
    • Oracle常用的单行函数应用技巧总结 百合不是茶 日期函数转换函数(核心)数字函数通用函数(核心)字符函数
      单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
    • Mockito异常测试实例 bijian1013 java单元测试mockito
      Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
    • GA与量子恒道统计 Bill_chen JavaScript浏览器百度Google防火墙
      前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：   为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    • 【Linux命令三】Top命令 bit1129 linux命令
      Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果：     top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
    • spring四种依赖注入方式 白糖_ spring
        平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    • angular.injector boyitech AngularJSAngularJS API
      angular.injector   描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.   使用方法: angular.injector(modules, [strictDi])   参数详解: Param Type Details mod
    • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
      public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
    • 使用Struts2.2.1配置 Chen.H apachespringWebxmlstruts
      Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
    • [职业与教育]青春之歌 comsci 教育
             每个人都有自己的青春之歌............但是我要说的却不是青春...        大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的....   &nbs
    • oracle连接(join)中使用using关键字 daizj JOINoraclesqlusing
      在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
    • NIO示例 daysinsun nio
      NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
    • C语言学习homework1 dcj3sjt126com chomework
      0、 课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x);   sizeof(int);   # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
    • select in order by , mysql排序 dcj3sjt126com mysql
      If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
    • 页面校验-新建项目 fanxiaolong 页面校验
      $(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
    • Ehcache（02）——ehcache.xml简介 234390216 ehcacheehcache.xml简介
      ehcache.xml简介          ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    • junit 4.11中三个新功能 jackyrong java
      junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
    • 国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windowsPHPunixMicrosoftperl
      Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的 这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    • 位运算、异或的实际应用 wenjinglian 位运算
      一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。       二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。       三． 位操作与空间压缩，针对筛素数进行空间压缩。    &n
    • weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
      好吧，weblogic的问题确实……   问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    • tomcat7性能调优（01） toknowme tomcat7
          Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1"                useBodyEncodingForURI="t
    • PO VO DAO DTO BO TO概念与区别 xp9802 javaDAO设计模式bean领域模型
      O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持