MyBatis之动态sql

Kissship2023-08-25 10:38

目录

一、MyBatis动态sql

[1.1 是什么](#1.1 是什么)

[1.2 作用](#1.2 作用)

[1.3 优点](#1.3 优点)

[1.4 特殊标签](#1.4 特殊标签)

[1.5 代码演示](#1.5 代码演示)

[二、#和的区别](#和的区别)

2.1 #使用

[2.2 $使用](#2.2 $使用)

[2.3 综合](#2.3 综合)

[2.4 代码演示](#2.4 代码演示)

三、resultType与resultMap的区别

[3.1 关于resultType](#3.1 关于resultType)

[3.2 关于resultMap](#3.2 关于resultMap)

[3.3 两者区别](#3.3 两者区别)

[3.4 代码演示](#3.4 代码演示)

一、MyBatis动态sql

1.1 是什么

是一种在SQL语句中根据不同条件动态拼接SQL的方式。通过使用动态SQL，可以根据不同的条件生成不同的SQL语句，从而实现灵活的查询和更新操作。动态SQL可以使用if、choose、when、otherwise等标签来实现条件判断和循环操作，同时还可以使用foreach标签来实现对集合类型参数的遍历操作。这样可以避免在代码中使用大量的字符串拼接，提高代码的可读性和维护性。

1.2 作用

Mybatis的动态SQL具有以下作用：

  • 1&. 灵活的条件查询：通过动态SQL，可以根据不同的条件生成不同的SQL语句，实现灵活的条件查询。可以根据用户输入的不同条件动态拼接SQL，从而实现动态的查询操作。

  • 2&. 动态更新操作：通过动态SQL，可以根据不同的条件生成不同的更新SQL语句，实现动态的更新操作。可以根据不同的业务需求动态拼接更新语句，从而实现灵活的数据更新。

  • 3&. 避免SQL注入：通过使用动态SQL，可以使用预编译的方式来拼接SQL语句，避免了直接拼接字符串的方式，从而有效防止SQL注入攻击。

  • 4&. 提高代码可读性和维护性：通过使用动态SQL的标签和语法，可以将复杂的SQL语句拆分为多个小块，提高了代码的可读性和维护性。可以根据不同的条件使用不同的标签和语法，使代码更加清晰易懂。

  • 总之，动态SQL是Mybatis的重要特性之一，可以帮助开发者灵活地拼接SQL语句，实现动态的查询和更新操作，提高代码的可读性和维护性。
    动态SQL在扩展方面有以下几个方面的作用：

  • 1#. 支持多表关联查询：通过动态SQL，可以根据不同的条件动态拼接多表关联查询的SQL语句。可以根据业务需求动态选择关联的表和关联条件，从而实现复杂的多表查询操作。

  • 2#. 支持分页查询：通过动态SQL，可以根据不同的条件动态拼接分页查询的SQL语句。可以根据分页参数动态计算查询结果的起始位置和数量，并将其拼接到SQL语句中，实现分页查询操作。

  • 3#. 支持动态排序：通过动态SQL，可以根据不同的条件动态拼接排序查询的SQL语句。可以根据排序参数动态选择排序字段和排序方式，并将其拼接到SQL语句中，实现动态排序查询操作。

  • 4#. 支持动态字段选择：通过动态SQL，可以根据不同的条件动态拼接字段选择的SQL语句。可以根据字段选择参数动态选择需要查询的字段，并将其拼接到SQL语句中，实现动态字段选择查询操作。

  • 5#. 支持动态更新字段：通过动态SQL，可以根据不同的条件动态拼接更新字段的SQL语句。可以根据更新参数动态选择需要更新的字段，并将其拼接到SQL语句中，实现动态更新字段操作。

总之，动态SQL在扩展方面可以根据不同的条件动态拼接SQL语句，满足复杂的查询和更新需求。通过动态SQL，可以灵活地处理多表关联查询、分页查询、动态排序、动态字段选择和动态更新字段等扩展操作，提高了系统的灵活性和可扩展性。

1.3 优点

Mybatis的动态SQL具有以下优点：

  • -1. 灵活性：动态SQL可以根据不同的条件生成不同的SQL语句，实现灵活的查询和更新操作。可以根据不同的业务需求动态拼接SQL，从而满足不同的查询和更新需求。
  • -2. 可读性：通过使用动态SQL的标签和语法，可以将复杂的SQL语句拆分为多个小块，提高了代码的可读性。可以根据不同的条件使用不同的标签和语法，使代码更加清晰易懂。
  • -3. 维护性：使用动态SQL可以将SQL语句的拼接逻辑与业务逻辑分离，使代码更易于维护。可以根据需要修改或添加条件，而不需要修改大段的SQL语句，减少了代码的维护成本。
  • -4. 防止SQL注入：通过使用动态SQL，可以使用预编译的方式来拼接SQL语句，避免了直接拼接字符串的方式，从而有效防止SQL注入攻击。
  • -5. 性能优化：动态SQL可以根据不同的条件生成不同的SQL语句，可以根据业务需求进行优化。可以根据查询条件动态选择索引，从而提高查询效率。

总之，动态SQL是Mybatis的强大特性之一，具有灵活性、可读性、维护性、安全性和性能优化等优点，能够帮助开发者更好地处理复杂的查询和更新需求，提高代码质量和开发效率。

1.4 特殊标签

Mybatis的动态SQL是一种在SQL语句中根据不同条件动态生成不同SQL片段的技术。它通过使用Mybatis提供的一些特殊标签和语法，可以根据不同的条件动态拼接SQL语句，从而实现灵活的查询和更新操作。
Mybatis提供了以下几种常用的动态SQL标签和语法：

    1. if标签：if标签可以根据条件判断是否包含某段SQL语句。可以在if标签中使用OGNL表达式来判断条件，如果条件满足，则包含if标签中的SQL语句。
    1. choose、when、otherwise标签：choose标签类似于Java中的switch语句，可以根据不同的条件选择不同的SQL语句执行。可以在choose标签中使用when标签定义多个条件分支，当条件满足时，执行对应的SQL语句；可以使用otherwise标签定义默认的SQL语句。
    1. trim标签：trim标签可以根据不同的条件动态拼接SQL语句的开头或结尾部分。可以使用trim标签来去除或添加不需要的SQL关键字，从而实现灵活的SQL拼接。
    1. foreach标签：foreach标签可以遍历集合或数组，并根据集合中的元素动态生成SQL语句。可以使用foreach标签来实现批量插入或批量更新操作。
    1. set标签：set标签可以根据不同的条件动态生成更新操作中的set语句。可以使用set标签来根据更新参数动态选择需要更新的字段，并将其拼接到SQL语句中。
  • 通过使用这些动态SQL标签和语法，可以根据不同的条件动态生成不同的SQL语句，从而实现灵活的查询和更新操作。动态SQL使得Mybatis可以根据不同的业务需求动态拼接SQL语句，提高了代码的可读性、维护性和扩展性。

1.5 代码演示

根据我们自动生成的xml，接口，实体进行增加代码进行动态SQL的演示操作，如下：

Book：

java 复制代码 
package com.Kissship.model;
 
public class Book {
    private Integer bid;
 
    private String bname;
 
    private Float price;
 
    public Book(Integer bid, String bname, Float price) {
        this.bid = bid;
        this.bname = bname;
        this.price = price;
    }
 
    public Book() {
        super();
    }
 
    public Integer getBid() {
        return bid;
    }
 
    public void setBid(Integer bid) {
        this.bid = bid;
    }
 
    public String getBname() {
        return bname;
    }
 
    public void setBname(String bname) {
        this.bname = bname;
    }
 
    public Float getPrice() {
        return price;
    }
 
    public void setPrice(Float price) {
        this.price = price;
    }
 
    @Override
    public String toString() {
        return "Book{" +
                "bid=" + bid +
                ", bname='" + bname + '\'' +
                ", price=" + price +
                '}';
    }
}

BookMapper：

java 复制代码 
package com.Kissship.mapper;
 
import com.Kissship.model.Book;
import org.apache.ibatis.annotations.Param;
 
import java.util.List;
 
public interface BookMapper {
    int deleteByPrimaryKey(Integer bid);
 
    int insert(Book record);
 
    int insertSelective(Book record);
 
    Book selectByPrimaryKey(Integer bid);
 
    int updateByPrimaryKeySelective(Book record);
 
    int updateByPrimaryKey(Book record);
 
 
    //增加根据多个ID(bid)查询多个数据的方法
    List<Book> selectByBll(@Param("bids") List bids);
 
 
 
 
}

BookMapper.xml：

XML 复制代码 
<?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.Kissship.mapper.BookMapper" >
  <resultMap id="BaseResultMap" type="com.Kissship.model.Book" >
    <constructor >
      <idArg column="bid" jdbcType="INTEGER" javaType="java.lang.Integer" />
      <arg column="bname" jdbcType="VARCHAR" javaType="java.lang.String" />
      <arg column="price" jdbcType="REAL" javaType="java.lang.Float" />
    </constructor>
  </resultMap>
  <sql id="Base_Column_List" >
    bid, bname, price
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select 
    <include refid="Base_Column_List" />
    from t_mvc_book
    where bid = #{bid,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
    delete from t_mvc_book
    where bid = #{bid,jdbcType=INTEGER}
  </delete>
  <insert id="insert" parameterType="com.Kissship.model.Book" >
    insert into t_mvc_book (bid, bname, price
      )
    values (#{bid,jdbcType=INTEGER}, #{bname,jdbcType=VARCHAR}, #{price,jdbcType=REAL}
      )
  </insert>
  <insert id="insertSelective" parameterType="com.Kissship.model.Book" >
    insert into t_mvc_book
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="bid != null" >
        bid,
      </if>
      <if test="bname != null" >
        bname,
      </if>
      <if test="price != null" >
        price,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="bid != null" >
        #{bid,jdbcType=INTEGER},
      </if>
      <if test="bname != null" >
        #{bname,jdbcType=VARCHAR},
      </if>
      <if test="price != null" >
        #{price,jdbcType=REAL},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.Kissship.model.Book" >
    update t_mvc_book
    <set >
      <if test="bname != null" >
        bname = #{bname,jdbcType=VARCHAR},
      </if>
      <if test="price != null" >
        price = #{price,jdbcType=REAL},
      </if>
    </set>
    where bid = #{bid,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.Kissship.model.Book" >
    update t_mvc_book
    set bname = #{bname,jdbcType=VARCHAR},
      price = #{price,jdbcType=REAL}
    where bid = #{bid,jdbcType=INTEGER}
  </update>
 
<!-- 根据多个bid(编号)进行查询出多个Book(对象)，bids参数需要是一个List<Integer> 集合-->
  <select id="selectByBll" resultType="com.Kissship.model.Book" parameterType="java.util.List" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
    where bid in
    <foreach collection="bids" item="bid" open="(" close=")" separator=",">
      #{bid}
    </foreach>
  </select>
 
 
</mapper>

其中的动态SQL可以根据自己的需要进行编写 :

<select id="selectByBll" resultType="com.Kissship.model.Book" parameterType="java.util.List" >

select

<include refid="Base_Column_List" />

from t_mvc_book

where bid in

<foreach collection="bids" item="bid" open="(" close=")" separator=",">

#{bid}

</foreach>

</select>

然后再将以下代码增加到增加编写的接口中，

java 复制代码 
//    封装方法
    List<Book> selectByBll(List bids);

接着在实现类中增加以下代码：

java 复制代码 
//    方法实现
    @Override
    public List<Book> selectByBll(List bids) {
        return bookMapper.selectByBll(bids);
    }

最后我们就可以在Demo测试类中进行方法调用测试

在Demo中增加以下代码进行测试 :

java 复制代码 
    @Test
    public void Bll(){
        List<Integer> bids = Arrays.asList(new Integer[]{41,42,43,45,47});
             //jdk1.8的新特性写法  
      bookBiz.selectByBll(bids).forEach(System.out::println);
//        for (Book book: bookBiz.selectByBll(bids)) {
//            System.out.println(book);
//        }
    }

其中方法调用的输出代码是jdk 1.8的新特性，提倡大家可以去探索，有很大收获。

输出的结果：

二、#和$的区别

2.1 #使用

（1）#占位符语法

  • #占位符会将传入的参数值自动进行预编译处理，可以防止SQL注入攻击。
  • 使用#占位符时，Mybatis会将参数值以安全的方式替换到SQL语句中，使用JDBC的预编译语句来执行SQL查询。
  • #占位符在生成SQL语句时会对参数值进行类型处理，将参数值转换为对应的JDBC类型。
  • #占位符可以防止SQL注入攻击，但是无法实现动态拼接SQL片段。

（2）优点

#占位符语法在使用动态SQL时具有以下优点：

    1. 防止SQL注入攻击：#占位符语法会将传入的参数值进行预编译处理，将参数值转换为对应的JDBC类型。这样可以防止恶意输入对SQL语句造成的安全威胁，提高了系统的安全性。
    1. 参数值类型处理：#占位符语法会对参数值进行类型处理，将参数值转换为对应的JDBC类型。这样可以避免在SQL语句中手动进行类型转换的麻烦，提高了开发效率。
    1. 可读性和可维护性：使用#占位符语法可以使SQL语句更加清晰和可读，因为参数值被封装在占位符中，不会直接出现在SQL语句中。这样可以方便后续的维护和修改，减少出错的可能性。
    1. 兼容性：#占位符语法是Mybatis的特有语法，相对于$占位符语法更具有兼容性。如果项目需要切换到其他ORM框架，使用#占位符语法可以减少代码的修改量。

综上所述，#占位符语法具有防止SQL注入攻击、参数值类型处理、可读性和可维护性、兼容性等优点。因此，在项目中使用动态SQL时，推荐使用#占位符语法。

2.2 $使用

（1）$占位符语法

  • $占位符会直接将传入的参数值替换到SQL语句中，不进行预编译处理。
  • 使用$占位符时，Mybatis会将参数值直接替换到SQL语句中，生成最终的SQL语句。
  • $占位符在生成SQL语句时不会对参数值进行类型处理，参数值会直接拼接到SQL语句中，可能存在安全风险。
  • $占位符可以实现动态拼接SQL片段，但是可能存在SQL注入攻击的风险。

（2）$优点

$占位符语法在使用动态SQL时具有以下优点：

  1. 动态拼接SQL片段：$占位符语法允许在SQL语句中直接使用参数值，可以方便地进行动态拼接SQL片段。这样可以在某些特殊情况下，更灵活地构建SQL语句。
  2. 字段名动态替换：$占位符语法可以用于动态替换字段名。这在某些场景下非常有用，比如需要根据用户的选择动态查询不同的字段。
  3. SQL语句灵活性：$占位符语法允许在SQL语句中使用任意有效的SQL表达式。这样可以在SQL语句中进行一些复杂的计算、字符串拼接等操作。

2.3 综合

综上所述，$占位符语法在某些特殊情况下具有灵活性和动态拼接SQL的优势，但需要注意SQL注入攻击的风险，并且可能会降低SQL语句的可读性和可维护性。 因此，在使用动态SQL时，#占位符语法**具有防止SQL注入攻击、参数值类型处理、可读性和可维护性、兼容性等优点。**因此，在项目中使用动态SQL时，推荐使用#占位符语法。只有在特殊情况下，需要动态拼接SQL片段或动态替换字段名时，才考虑使用占位符语法，并且需要确保参数值的安全性。

2.4 代码演示

在自动生成的 BookMapper.xml 配置文件中增加以下代码

java 复制代码 
  <select id="like01" resultType="com.Kissship.model.Book" parameterType="java.lang.String" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
    where bname like #{bname}
  </select>
 
  <select id="like02" resultType="com.Kissship.model.Book" parameterType="java.lang.String" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
    where bname like  '${bname}'
  </select>
 
  <select id="like03" resultType="com.Kissship.model.Book" parameterType="java.lang.String" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
    where bname like concat('%',#{bname},'%')
  </select>

自己在配置文件中根据自己需求来进行编写动态SQL

注意 :

这里如果使用占位符语法的话需要在{bname}的左右增加单引号 列如: '${bname}'

这已是$占位符语法的一个小缺陷，在我们日常使用中一般使用的是第三种方法( like03 )
在自动生成的 BookMapper 接口中增加以下代码

java 复制代码 
    //增加模糊查询的方法
    List<Book> like01(@Param("bname") String bname);
 
    List<Book> like02(@Param("bname") String bname);
 
    List<Book> like03(@Param("bname") String bname);

编写动态SQL后进行封装方法， 在自己创建的接口中增加以下代码：

java 复制代码 
    List<Book> like01(String bname);
 
    List<Book> like02(String bname);
 
    List<Book> like03(String bname);

在自己创建的实现类中增加以下代码：

java 复制代码 
    @Override
    public List<Book> like01(String bname) {
        return bookMapper.like01(bname);
    }
 
    @Override
    public List<Book> like02(String bname) {
        return bookMapper.like02(bname);
    }
 
    @Override
    public List<Book> like03(String bname) {
        return bookMapper.like03(bname);
    }

在测试类( Demo )中增加以下代码并且进行一一调用测试

java 复制代码 
    @Test
    public void like01(){
        bookBiz.like01("%斗破%").forEach(System.out::println);
    }
    @Test
    public void like02(){
        bookBiz.like02("%斗破%").forEach(System.out::println);
    }
    @Test
    public void like03(){
        bookBiz.like03("%斗破%").forEach(System.out::println);
    }

like01的方法测试结果，如下：

like02的方法测试结果，如下：

like03的方法测试结果，如下：

三、resultType与resultMap的区别

3.1 关于resultType

在Mybatis的动态SQL中，resultType和resultMap都是用于指定查询结果的类型或映射关系的配置项。
resultType： resultType用于指定查询结果的类型，可以是Java基本类型、Java对象类型或自定义的Java类。当使用resultType时，Mybatis会根据查询结果的列名和Java对象的属性名进行自动映射。例如，如果查询结果的列名为"username"，Java对象中有对应的属性"userName"，则Mybatis会自动将查询结果映射到Java对象中。

示例：

java 复制代码 
<select id="getUser" resultType="com.example.User">
  SELECT id, username, email FROM user WHERE id = #{id}
</select>

在上述示例中，resultType指定了查询结果的类型为com.example.User类，Mybatis会根据查询结果的列名和User类的属性名进行自动映射。

3.2 关于resultMap

resultMap： resultMap用于自定义查询结果的映射关系，可以通过指定映射关系来实现更灵活的结果映射。resultMap需要在映射文件中进行配置，通过定义<resultMap>标签来指定映射关系。在<resultMap>标签中，可以使用<id>、<result>、<association>等标签来定义主键、普通列和关联对象之间的映射关系。

示例：

java 复制代码 
<resultMap id="userResultMap" type="com.example.User">
  <id property="id" column="user_id"/>
  <result property="username" column="user_name"/>
  <result property="email" column="user_email"/>
</resultMap>
 
<select id="getUser" resultMap="userResultMap">
  SELECT id as user_id, username as user_name, email as user_email FROM user WHERE id = #{id}
</select>

在上述示例中，resultMap指定了自定义的映射关系userResultMap，通过<resultMap>标签中的<id>和<result>标签来定义查询结果列和User类属性之间的映射关系。

3.3 两者区别

  • resultType用于简单的结果映射，适用于查询结果列与Java对象属性名一致的情况，自动进行映射。
  • resultMap用于复杂的结果映射，适用于查询结果列与Java对象属性名不一致或需要自定义映射关系的情况，需要手动定义映射关系

总结：

resultType适用于简单的结果映射，可以自动进行映射；

resultMap适用于复杂的结果映射，需要手动定义映射关系。

根据具体的需求和情况，选择合适的配置项来实现查询结果的映射。

3.4 代码演示

resultType的使用场景：

  • 当查询结果与Java对象的属性名一致，并且查询结果较为简单时，可以使用resultType。这样可以简化配置，避免过多的映射配置。
  • 当查询结果只包含少量列，并且不需要进行复杂的映射操作时，也可以使用resultType。
  • resultMap的使用场景：
  • 当查询结果与Java对象的属性名不一致，或者查询结果需要进行复杂的映射操作时，可以使用resultMap。通过自定义映射关系，可以灵活地将查询结果映射到Java对象中。
  • 当查询结果包含多个关联对象，需要进行关联查询和关联映射时，也可以使用resultMap。通过<association>、<collection>等标签，可以定义关联对象之间的映射关系。

综上所述，resultType适用于简单的结果映射，而resultMap适用于复杂的结果映射。在实际项目中，根据查询结果的复杂度和需求的灵活性，选择合适的配置项来进行结果映射。如果查询结果较为简单且与Java对象属性名一致，可以使用resultType；如果查询结果复杂或需要进行自定义映射操作，可以使用resultMap。
在自动生成的 BookMapper.xml 配置文件中增加以下代码， 如下：

java 复制代码 
  <select id="BookList01" resultType="com.Kissship.model.Book" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
  </select>
 
  <select id="BookList02" resultMap="BaseResultMap" >
    select
    <include refid="Base_Column_List" />
    from t_mvc_book
  </select>

在自动生成的 BookMapper 接口中增加以下代码，如下：

java 复制代码 
   List<Book> BookList01();
 
   List<Book> BookList02();

在自己创建的接口 BookBiz 中增加以下代码，如下：

java 复制代码 
    List<Book>  BookList01();
    List<Book>  BookList02();

在自己创建的实现类 BookBizImpl 中增加以下代码，如下：

java 复制代码 
    @Override
    public List<Book> BookList01() {
        return bookMapper.BookList01();
    }
 
    @Override
    public List<Book> BookList02() {
        return bookMapper.BookList02();
    }

在测试类 Demo 中 增加以下代码，如下：

java 复制代码 
    @Test
    public  void List01(){
        bookBiz.BookList01().forEach(System.out::println);
    }
 
    @Test
    public  void List02(){
        bookBiz.BookList02().forEach(System.out::println);
    }

List01测试结果如下：

List02测试结果如下：

最后MyBatis之动态sql及分页就到这里，祝大家在敲代码的路上一路通畅!

感谢大家的观看 !

相关推荐
这孩子叫逆10 分钟前
6. 什么是MySQL的事务？如何在Java中使用Connection接口管理事务？
数据库·mysql
Karoku06614 分钟前
【网站架构部署与优化】web服务与http协议
linux·运维·服务器·数据库·http·架构
码农郁郁久居人下40 分钟前
Redis的配置与优化
数据库·redis·缓存
MuseLss2 小时前
Mycat搭建分库分表
数据库·mycat
Hsu_kk2 小时前
Redis 主从复制配置教程
数据库·redis·缓存
DieSnowK2 小时前
[Redis][环境配置]详细讲解
数据库·redis·分布式·缓存·环境配置·新手向·详细讲解
程序猿小D2 小时前
第二百三十五节 JPA教程 - JPA Lob列示例
java·数据库·windows·oracle·jdk·jpa
Flerken1012 小时前
数据库语言、SQL语言、数据库系统提供的两种语言
数据库·sql·oracle
掘根2 小时前
【网络】高级IO——poll版本TCP服务器
网络·数据库·sql·网络协议·tcp/ip·mysql·网络安全
消失在人海中2 小时前
oracle 表的外键
数据库·oracle
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07浏览器插件——ModHeader 的分享和学习08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解