Mybatis【入门】

Java3y Java3y 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 461平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-06-01 00:30:00 发布 461 阅读 AI 写同款· GEO 优化 ›
MyBatis入门到精通——入门篇 目录一、什么是 MyBatis？二、入门案例（1）创建maven项目（2）引入依赖包（3）创建数据库执行sql脚本三、入门程序源码（1）User.java（2）UserMapper.java（3）MybatisUtils.java（4）UserMapperTest.java（6）UserMapper.xml（7）mybatis-config.xml（8）pom.xml 四、程序单元测试结果五、程序完整源码获取在此之前，需要提前配置好java环境变量和maven环境变量。 （3）创建数据库执行sql 阅读详情 
什么是MyBatis
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。是一个基于Java的持久层框架
为什么我们要用Mybatis？
无论是Mybatis、Hibernate都是ORM的一种实现框架，都是对JDBC的一种封装！
640?wx_fmt=jpeg
这里写图片描述
到目前为止，我们已经在持久层中学了几种技术了…
那我们为啥还要学Mybatis呢？？？现在Mybatis在业内大行其道，那为啥他能那么火呢？？
Hibernate是一个比较老旧的框架，用过他的同学都知道，只要你会用，用起来十分舒服…啥sql代码都不用写…但是呢，它也是有的缺点：：处理复杂业务时，灵活度差, 复杂的HQL难写难理解，例如多表查询的HQL语句
而JDBC很容易理解，就那么几个固定的步骤，就是开发起来太麻烦了，因为什么都要我们自己干..
而SpringDAO其实就是JDBC的一层封装，就类似于dbutils一样，没有特别出彩的地方….
我们可以认为，Mybatis就是jdbc和Hibernate之间的一个平衡点…毕竟现在业界都是用这个框架，我们也不能不学呀！
Mybatis快速入门
其实我们已经学过了Hibernate了，对于Mybatis入门其实就非常类似的。因此就很简单就能掌握基本的开发了…
导入开发包
导入Mybatis开发包
导入mysql/oracle开发包
准备测试工作
创建一张表
create table students(  id  int(5) primary key,  name varchar(10),  sal double(8,2));table students(
  id  int(5) primary key,
  name varchar(10),
  sal double(8,2)
);
创建实体：
/** * Created by ozc on 2017/7/21. */public class Student {    private Integer id;    private String name;    private Double sal;    public Student() {    }    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Double getSal() {        return sal;    }    public void setSal(Double sal) {        this.sal = sal;    }}

public class Student {
    private Integer id;
    private String name;
    private Double sal;

    public Student() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }
}
创建mybatis配置文件
创建mybatis的配置文件，配置数据库的信息….数据库我们可以配置多个，但是默认的只能用一个…
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>    <!-- 加载类路径下的属性文件 -->    <properties resource="db.properties"/>    <!-- 设置一个默认的连接环境信息 -->    <environments default="mysql_developer">        <!-- 连接环境信息，取一个任意唯一的名字 -->        <environment id="mysql_developer">            <!-- mybatis使用jdbc事务管理方式 -->            <transactionManager type="jdbc"/>            <!-- mybatis使用连接池方式来获取连接 -->            <dataSource type="pooled">                <!-- 配置与数据库交互的4个必要属性 -->                <property name="driver" value="${mysql.driver}"/>                <property name="url" value="${mysql.url}"/>                <property name="username" value="${mysql.username}"/>                <property name="password" value="${mysql.password}"/>            </dataSource>        </environment>        <!-- 连接环境信息，取一个任意唯一的名字 -->        <environment id="oracle_developer">            <!-- mybatis使用jdbc事务管理方式 -->            <transactionManager type="jdbc"/>            <!-- mybatis使用连接池方式来获取连接 -->            <dataSource type="pooled">                <!-- 配置与数据库交互的4个必要属性 -->                <property name="driver" value="${oracle.driver}"/>                <property name="url" value="${oracle.url}"/>                <property name="username" value="${oracle.username}"/>                <property name="password" value="${oracle.password}"/>            </dataSource>        </environment>    </environments></configuration>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>


    <!-- 加载类路径下的属性文件 -->
    <properties resource="db.properties"/>

    <!-- 设置一个默认的连接环境信息 -->
    <environments default="mysql_developer">
        <!-- 连接环境信息，取一个任意唯一的名字 -->
        <environment id="mysql_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>


        <!-- 连接环境信息，取一个任意唯一的名字 -->
        <environment id="oracle_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${oracle.driver}"/>
                <property name="url" value="${oracle.url}"/>
                <property name="username" value="${oracle.username}"/>
                <property name="password" value="${oracle.password}"/>
            </dataSource>
        </environment>
    </environments>


</configuration>
编写工具类测试是否获取到连接
使用Mybatis的API来创建一个工具类，通过mybatis配置文件与数据库的信息，得到Connection对象
package cn.itcast.javaee.mybatis.util;import java.io.IOException;import java.io.Reader;import java.sql.Connection;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;/** * 工具类 * @author AdminTC */public class MybatisUtil {    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();    private static SqlSessionFactory sqlSessionFactory;    /**     * 加载位于src/mybatis.xml配置文件     */    static{        try {            Reader reader = Resources.getResourceAsReader("mybatis.xml");            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);        } catch (IOException e) {            e.printStackTrace();            throw new RuntimeException(e);        }    }    /**     * 禁止外界通过new方法创建      */    private MybatisUtil(){}    /**     * 获取SqlSession     */    public static SqlSession getSqlSession(){        //从当前线程中获取SqlSession对象        SqlSession sqlSession = threadLocal.get();        //如果SqlSession对象为空        if(sqlSession == null){            //在SqlSessionFactory非空的情况下，获取SqlSession对象            sqlSession = sqlSessionFactory.openSession();            //将SqlSession对象与当前线程绑定在一起            threadLocal.set(sqlSession);        }        //返回SqlSession对象        return sqlSession;    }    /**     * 关闭SqlSession与当前线程分开     */    public static void closeSqlSession(){        //从当前线程中获取SqlSession对象        SqlSession sqlSession = threadLocal.get();        //如果SqlSession对象非空        if(sqlSession != null){            //关闭SqlSession对象            sqlSession.close();            //分开当前线程与SqlSession对象的关系，目的是让GC尽早回收            threadLocal.remove();        }    }       /**     * 测试     */    public static void main(String[] args) {        Connection conn = MybatisUtil.getSqlSession().getConnection();        System.out.println(conn!=null?"连接成功":"连接失败");    }}

import java.io.IOException;
import java.io.Reader;
import java.sql.Connection;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

/**
 * 工具类
 * @author AdminTC
 */
public class MybatisUtil {
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
    private static SqlSessionFactory sqlSessionFactory;
    /**
     * 加载位于src/mybatis.xml配置文件
     */
    static{
        try {
            Reader reader = Resources.getResourceAsReader("mybatis.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 禁止外界通过new方法创建 
     */
    private MybatisUtil(){}
    /**
     * 获取SqlSession
     */
    public static SqlSession getSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //如果SqlSession对象为空
        if(sqlSession == null){
            //在SqlSessionFactory非空的情况下，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession();
            //将SqlSession对象与当前线程绑定在一起
            threadLocal.set(sqlSession);
        }
        //返回SqlSession对象
        return sqlSession;
    }
    /**
     * 关闭SqlSession与当前线程分开
     */
    public static void closeSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //如果SqlSession对象非空
        if(sqlSession != null){
            //关闭SqlSession对象
            sqlSession.close();
            //分开当前线程与SqlSession对象的关系，目的是让GC尽早回收
            threadLocal.remove();
        }
    }   
    /**
     * 测试
     */
    public static void main(String[] args) {
        Connection conn = MybatisUtil.getSqlSession().getConnection();
        System.out.println(conn!=null?"连接成功":"连接失败");
    }
}
创建实体与映射关系文件
配置实体与表的映射关系
<?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"><!-- namespace属性是名称空间，必须唯一 --><mapper namespace="cn.itcast.javaee.mybatis.app04.Student">        <!-- resultMap标签:映射实体与表          type属性：表示实体全路径名         id属性：为实体与表的映射取一个任意的唯一的名字    -->    <resultMap type="student" id="studentMap">        <!-- id标签:映射主键属性             result标签：映射非主键属性             property属性:实体的属性名             column属性：表的字段名          -->                                 <id property="id" column="id"/>        <result property="name" column="name"/>        <result property="sal" column="sal"/>    </resultMap></mapper>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace属性是名称空间，必须唯一 -->
<mapper namespace="cn.itcast.javaee.mybatis.app04.Student">    

    <!-- resultMap标签:映射实体与表 
         type属性：表示实体全路径名
         id属性：为实体与表的映射取一个任意的唯一的名字
    -->
    <resultMap type="student" id="studentMap">
        <!-- id标签:映射主键属性
             result标签：映射非主键属性
             property属性:实体的属性名
             column属性：表的字段名  
        -->                         
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sal" column="sal"/>
    </resultMap>

</mapper>
现在我们已经有了Mybatis的配置文件和表与实体之前的映射文件了，因此我们要将配置文件和映射文件关联起来
    <mappers>        <mapper resource="StudentMapper.xml"/>    </mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
在测试类上，我们是可以获取得到连接的
640?wx_fmt=png
这里写图片描述
编写DAO
public class StudentDao {    public void add(Student student) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        sqlSession.insert();    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        Student student = new Student(1, "zhongfucheng", 10000D);        studentDao.add(student);    }}class StudentDao {


    public void add(Student student) throws Exception {
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        sqlSession.insert();
    }

    public static void main(String[] args) throws Exception {

        StudentDao studentDao = new StudentDao();

        Student student = new Student(1, "zhongfucheng", 10000D);
        studentDao.add(student);

    }
}
到现在为止，我们实体与表的映射文件仅仅映射了实体属性与表的字段的关系…
我们在Hibernate中如果想要插入数据什么的，只要调用save()方法就行了。Hibernate是自动化屏蔽掉了数据库的差异，而我们Mybatis是需要自己手动编写SQL代码的…
那么SQL代码是写在哪里的呢？？？明显地，我们作为一个框架，不可能在程序中写SQL，我们是在实体与表的映射文件中写的！
Mybatis实体与表的映射文件中提供了insert标签【SQL代码片段】供我们使用
    //在JDBC中我们通常使用?号作为占位符，而在Mybatis中，我们是使用#{}作为占位符    //parameterType我们指定了传入参数的类型    //#{}实际上就是调用了Student属性的get方法    <insert id="add" parameterType="Student">        INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});    </insert>
    //#{}实际上就是调用了Student属性的get方法

    <insert id="add" parameterType="Student">

        INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});
    </insert>
在程序中调用映射文件的SQL代码片段
    public void add(Student student) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            sqlSession.insert("StudentID.add", student);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            sqlSession.insert("StudentID.add", student);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
值得注意的是：Mybatis中的事务是默认开启的，因此我们在完成操作以后，需要我们手动去提交事务！
Mybatis工作流程
完成CRUD操作
我们在上面中已经简单知道了Mybatis是怎么使用的以及工作流程了，这次我们使用Mybatis来完成CRUD的操作，再次巩固Mybatis的开发步骤以及一些细节
包与类之间的结构
640?wx_fmt=png
这里写图片描述
增加学生
配置文件
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>    <!-- 加载类路径下的属性文件 -->    <properties resource="db.properties"/>    <!-- 设置一个默认的连接环境信息 -->    <environments default="mysql_developer">        <!-- 连接环境信息，取一个任意唯一的名字 -->        <environment id="mysql_developer">            <!-- mybatis使用jdbc事务管理方式 -->            <transactionManager type="jdbc"/>            <!-- mybatis使用连接池方式来获取连接 -->            <dataSource type="pooled">                <!-- 配置与数据库交互的4个必要属性 -->                <property name="driver" value="${mysql.driver}"/>                <property name="url" value="${mysql.url}"/>                <property name="username" value="${mysql.username}"/>                <property name="password" value="${mysql.password}"/>            </dataSource>        </environment>        <!-- 连接环境信息，取一个任意唯一的名字 -->        <environment id="oracle_developer">            <!-- mybatis使用jdbc事务管理方式 -->            <transactionManager type="jdbc"/>            <!-- mybatis使用连接池方式来获取连接 -->            <dataSource type="pooled">                <!-- 配置与数据库交互的4个必要属性 -->                <property name="driver" value="${oracle.driver}"/>                <property name="url" value="${oracle.url}"/>                <property name="username" value="${oracle.username}"/>                <property name="password" value="${oracle.password}"/>            </dataSource>        </environment>    </environments>    <mappers>        <mapper resource="zhongfucheng/StudentMapper.xml"/>    </mappers></configuration>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <!-- 加载类路径下的属性文件 -->
    <properties resource="db.properties"/>

    <!-- 设置一个默认的连接环境信息 -->
    <environments default="mysql_developer">
        <!-- 连接环境信息，取一个任意唯一的名字 -->
        <environment id="mysql_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>


        <!-- 连接环境信息，取一个任意唯一的名字 -->
        <environment id="oracle_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${oracle.driver}"/>
                <property name="url" value="${oracle.url}"/>
                <property name="username" value="${oracle.username}"/>
                <property name="password" value="${oracle.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="zhongfucheng/StudentMapper.xml"/>
    </mappers>
</configuration>
映射文件
<!-- namespace属性是名称空间，必须唯一 --><mapper namespace="StudentID">    <!-- resultMap标签:映射实体与表          type属性：表示实体全路径名         id属性：为实体与表的映射取一个任意的唯一的名字    -->    <resultMap type="zhongfucheng.Student" id="studentMap">        <!-- id标签:映射主键属性             result标签：映射非主键属性             property属性:实体的属性名             column属性：表的字段名        -->        <id property="id" column="id"/>        <result property="name" column="name"/>        <result property="sal" column="sal"/>    </resultMap>    <insert id="add" parameterType="zhongfucheng.Student">        INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});    </insert></mapper>
<mapper namespace="StudentID">

    <!-- resultMap标签:映射实体与表 
         type属性：表示实体全路径名
         id属性：为实体与表的映射取一个任意的唯一的名字
    -->
    <resultMap type="zhongfucheng.Student" id="studentMap">
        <!-- id标签:映射主键属性
             result标签：映射非主键属性
             property属性:实体的属性名
             column属性：表的字段名
        -->
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sal" column="sal"/>
    </resultMap>

    <insert id="add" parameterType="zhongfucheng.Student">
        INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});
    </insert>

</mapper>
插入数据
public class StudentDao {    public void add(Student student) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            sqlSession.insert("StudentID.add", student);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        Student student = new Student(3, "zhong3", 10000D);        studentDao.add(student);    }}class StudentDao {

    public void add(Student student) throws Exception {
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            sqlSession.insert("StudentID.add", student);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        Student student = new Student(3, "zhong3", 10000D);
        studentDao.add(student);
    }
}
640?wx_fmt=png
这里写图片描述
根据ID查询数据
增加select标签
    <!--        查询根据id        resultMap这个属性代表是返回值类型，返回值的类型是Student，就是上面实体类型    -->    <select id="findById" parameterType="int" resultMap="studentMap">        SELECT * FROM STUDENTS WHERE id = #{id};    </select>
    <select id="findById" parameterType="int" resultMap="studentMap">
        SELECT * FROM STUDENTS WHERE id = #{id};
    </select>
查询出来的结果是一个Student对象，我们调用SelectOne方法
    public Student findById(int id) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            return sqlSession.selectOne("StudentID.findById",id);        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        Student student = studentDao.findById(1);        System.out.println(student.getName());    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            return sqlSession.selectOne("StudentID.findById",id);
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        Student student = studentDao.findById(1);
        System.out.println(student.getName());

    }
640?wx_fmt=png
这里写图片描述
查询所有数据
    <!--        查询所有数据        返回值类型讲道理是List<Student>的，但我们只要写集合中的类型就行了    -->    <select id="findAll" resultMap="studentMap">        SELECT * FROM STUDENTS;    </select>
    <select id="findAll" resultMap="studentMap">
        SELECT * FROM STUDENTS;
    </select>
我们查询出来的结果不单单只有一个对象了，因此我们使用的是SelectList这个方法
  public List<Student> findAll() throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            return sqlSession.selectList("StudentID.findAll");        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        List<Student> students = studentDao.findAll();        System.out.println(students.size());    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            return sqlSession.selectList("StudentID.findAll");
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        List<Student> students = studentDao.findAll();
        System.out.println(students.size());

    }
根据id删除
    <!--根据id删除-->    <delete id="delete" parameterType="int">        DELETE FROM STUDENTS WHERE id=#{id};    </delete>
    <delete id="delete" parameterType="int">
        DELETE FROM STUDENTS WHERE id=#{id};

    </delete>
调用delete方法删除
    public void delete(int id ) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            sqlSession.delete("StudentID.delete", id);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        studentDao.delete(1);    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            sqlSession.delete("StudentID.delete", id);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        studentDao.delete(1);

    }
640?wx_fmt=png
这里写图片描述
修改
    <!--更新-->    <update id="update" parameterType="zhongfucheng.Student">        update students set name=#{name},sal=#{sal} where id=#{id};    </update>
    <update id="update" parameterType="zhongfucheng.Student">

        update students set name=#{name},sal=#{sal} where id=#{id};

    </update>
查询出对应的对象，对其进行修改
    public void update(Student student ) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            sqlSession.update("StudentID.update", student);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        Student student = studentDao.findById(2);        student.setName("fucheng");        student.setSal(2000D);        studentDao.update(student);    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            sqlSession.update("StudentID.update", student);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        Student student = studentDao.findById(2);
        student.setName("fucheng");
        student.setSal(2000D);
        studentDao.update(student);

    }
640?wx_fmt=png
这里写图片描述
小细节
    <!--         注意：这个insert/update/delete标签只是一个模板，在做操作时，其实是以SQL语句为核心的             即在做增/删/时，insert/update/delete标签可通用，             但做查询时只能用select标签             我们提倡什么操作就用什么标签    --> 
        注意：这个insert/update/delete标签只是一个模板，在做操作时，其实是以SQL语句为核心的
             即在做增/删/时，insert/update/delete标签可通用，
             但做查询时只能用select标签
             我们提倡什么操作就用什么标签
    --> 
Mybatis分页
分页是一个非常实用的技术点，我们也来学习一下使用Mybatis是怎么分页的…
我们的分页是需要多个参数的，并不是像我们之前的例子中只有一个参数。当需要接收多个参数的时候，我们使用Map集合来装载！
    public List<Student>  pagination(int start ,int end) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            /**             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集             * 因此我们使用Map集合来装载我们的参数             */            Map<String, Object> map = new HashMap();            map.put("start", start);            map.put("end", end);            return sqlSession.selectList("StudentID.pagination", map);        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        List<Student> students = studentDao.pagination(0, 3);        for (Student student : students) {            System.out.println(student.getId());        }    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL


            /**
             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集
             * 因此我们使用Map集合来装载我们的参数
             */
            Map<String, Object> map = new HashMap();
            map.put("start", start);
            map.put("end", end);
            return sqlSession.selectList("StudentID.pagination", map);
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        List<Student> students = studentDao.pagination(0, 3);
        for (Student student : students) {

            System.out.println(student.getId());

        }

    }
那么在实体与表映射文件中，我们接收的参数就是map集合
    <!--分页查询-->    <select id="pagination" parameterType="map" resultMap="studentMap">        /*根据key自动找到对应Map集合的value*/        select * from students limit #{start},#{end};    </select>
    <select id="pagination" parameterType="map" resultMap="studentMap">

        /*根据key自动找到对应Map集合的value*/
        select * from students limit #{start},#{end};

    </select>
640?wx_fmt=png
这里写图片描述
动态SQL
何为动态SQL？？回顾一下我们之前写的SSH项目中，有多条件查询的情况，如下图
640?wx_fmt=jpeg
这里写图片描述
我们当时刚开始做的时候，是需要在Controller中判断SQL是否已经有条件了，因为SQL语句需要拼接起来….这样干的话，就非常容易出错的。
如下的代码，如果有多个条件的话，那么拼接起来很容易出错！
  public String listUI() {        //查询语句        String hql = "FROM Info i ";        List<Object> objectList  = new ArrayList<>();        //根据info是否为null来判断是否是条件查询。如果info为空，那么是查询所有。        if (info != null) {            if (StringUtils.isNotBlank(info.getTitle())) {                hql += "where i.title like ?";                objectList.add("%" + info.getTitle() + "%");            }        }        infoList = infoServiceImpl.findObjects(hql,objectList);        ActionContext.getContext().getContextMap().put("infoTypeMap", Info.INFO_TYPE_MAP);        return "listUI";    }

        //查询语句
        String hql = "FROM Info i ";
        List<Object> objectList  = new ArrayList<>();

        //根据info是否为null来判断是否是条件查询。如果info为空，那么是查询所有。
        if (info != null) {
            if (StringUtils.isNotBlank(info.getTitle())) {
                hql += "where i.title like ?";
                objectList.add("%" + info.getTitle() + "%");
            }
        }
        infoList = infoServiceImpl.findObjects(hql,objectList);
        ActionContext.getContext().getContextMap().put("infoTypeMap", Info.INFO_TYPE_MAP);
        return "listUI";
    }
后来，我们觉得这样不好，于是就专门写了一个查询助手类：
package zhongfucheng.core.utils;import java.util.ArrayList;import java.util.List;/** * Created by ozc on 2017/6/7. */public class QueryHelper {    private String fromClause = "";    private String whereClause = "";    private String orderbyClause = "";    private List<Object> objectList;    public static String ORDER_BY_ASC = "asc";    public static String ORDER_BY_DESC = "desc";    //FROM子句只出现一次    /**     * 构建FROM字句，并设置查询哪张表     * @param aClass 用户想要操作的类型     * @param alias  别名     */    public QueryHelper(Class aClass, String alias) {        fromClause = "  FROM " + aClass.getSimpleName() + "  " + alias;    }    //WHERE字句可以添加多个条件，但WHERE关键字只出现一次    /**     * 构建WHERE字句     * @param condition     * @param objects     * @return     */    public QueryHelper addCondition(String condition, Object... objects) {        //如果已经有字符了，那么就说明已经有WHERE关键字了        if (whereClause.length() > 0) {            whereClause += " AND  " + condition;        } else {            whereClause += " WHERE" + condition;        }        //在添加查询条件的时候，?对应的查询条件值        if (objects == null) {            objectList = new ArrayList<>();        }        for (Object object : objects) {            objectList.add(object);        }        return this;    }    /**     *     * @param property 要排序的属性     * @param order 是升序还是降序     * @return     */    public QueryHelper orderBy(String property, String order) {        //如果已经有字符了，那么就说明已经有ORDER关键字了        if (orderbyClause.length() > 0) {            orderbyClause += " ,  " + property +"   " + order;        } else {            orderbyClause += "  ORDER BY " + property+"   " + order;        }        return this;    }    /**     * 返回HQL语句     */    public String returnHQL() {        return fromClause + whereClause + orderbyClause;    }    /**     * 得到参数列表     * @return     */    public List<Object> getObjectList() {        return objectList;    }}

import java.util.ArrayList;
import java.util.List;

/**
 * Created by ozc on 2017/6/7.
 */
public class QueryHelper {

    private String fromClause = "";
    private String whereClause = "";
    private String orderbyClause = "";
    private List<Object> objectList;

    public static String ORDER_BY_ASC = "asc";
    public static String ORDER_BY_DESC = "desc";



    //FROM子句只出现一次
    /**
     * 构建FROM字句，并设置查询哪张表
     * @param aClass 用户想要操作的类型
     * @param alias  别名
     */
    public QueryHelper(Class aClass, String alias) {
        fromClause = "  FROM " + aClass.getSimpleName() + "  " + alias;
    }
    //WHERE字句可以添加多个条件，但WHERE关键字只出现一次
    /**
     * 构建WHERE字句
     * @param condition
     * @param objects
     * @return
     */
    public QueryHelper addCondition(String condition, Object... objects) {
        //如果已经有字符了，那么就说明已经有WHERE关键字了
        if (whereClause.length() > 0) {
            whereClause += " AND  " + condition;
        } else {
            whereClause += " WHERE" + condition;
        }
        //在添加查询条件的时候，?对应的查询条件值
        if (objects == null) {
            objectList = new ArrayList<>();
        }

        for (Object object : objects) {
            objectList.add(object);
        }

        return this;
    }
    /**
     *
     * @param property 要排序的属性
     * @param order 是升序还是降序
     * @return
     */
    public QueryHelper orderBy(String property, String order) {

        //如果已经有字符了，那么就说明已经有ORDER关键字了
        if (orderbyClause.length() > 0) {
            orderbyClause += " ,  " + property +"   " + order;
        } else {
            orderbyClause += "  ORDER BY " + property+"   " + order;
        }
        return this;
    }

    /**
     * 返回HQL语句
     */
    public String returnHQL() {
        return fromClause + whereClause + orderbyClause;
    }

    /**
     * 得到参数列表
     * @return
     */
    public List<Object> getObjectList() {
        return objectList;
    }
}
这样一来的话，我们就不用自己手动拼接了，给我们的查询助手类去拼接就好了。
而如果我们使用Mybatis的话，就可以免去查询助手类了。因为Mybatis内部就有动态SQL的功能【动态SQL就是自动拼接SQL语句】！
动态查询
    <!--多条件查询【动态SQL】-->    <!--会自动组合成一个正常的WHERE字句-->    <!--name值会从map中寻找-->    <select id="findByCondition" resultMap="studentMap" parameterType="map">        select * from students        <where>            <if test="name!=null">                and name=#{name}            </if>            <if test="sal!=null">                and sal < #{sal}            </if>        </where>    </select>
    <!--会自动组合成一个正常的WHERE字句-->
    <!--name值会从map中寻找-->

    <select id="findByCondition" resultMap="studentMap" parameterType="map">

        select * from students

        <where>
            <if test="name!=null">
                and name=#{name}
            </if>
            <if test="sal!=null">
                and sal < #{sal}
            </if>
        </where>

    </select>
查询出来小于9000块的人
   public List<Student> findByCondition(String name,Double sal) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            /**             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集             * 因此我们使用Map集合来装载我们的参数             */            Map<String, Object> map = new HashMap();            map.put("name", name);            map.put("sal", sal);            return sqlSession.selectList("StudentID.findByCondition", map);        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        List<Student> students = studentDao.findByCondition(null,9000D);        for (Student student : students) {            System.out.println(student.getId() + "---" + student.getName() + "----" + student.getSal());        }    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            /**
             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集
             * 因此我们使用Map集合来装载我们的参数
             */
            Map<String, Object> map = new HashMap();
            map.put("name", name);
            map.put("sal", sal);
            return sqlSession.selectList("StudentID.findByCondition", map);
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        List<Student> students = studentDao.findByCondition(null,9000D);
        for (Student student : students) {
            System.out.println(student.getId() + "---" + student.getName() + "----" + student.getSal());
        }


    }
640?wx_fmt=png
这里写图片描述
动态更新
640?wx_fmt=jpeg
这里写图片描述
    <!--动态更新-->    <!--不要忘了逗号-->    <update id="updateByConditions" parameterType="map">        update students        <set>            <if test="name!=null">                 name = #{name},            </if>            <if test="sal!=null">                 sal = #{sal},            </if>        </set>        where id = #{id}    </update>
    <!--不要忘了逗号-->
    <update id="updateByConditions" parameterType="map">

        update students
        <set>
            <if test="name!=null">
                 name = #{name},
            </if>
            <if test="sal!=null">
                 sal = #{sal},
            </if>
        </set>
        where id = #{id}
    </update>
给出三个更新的字段
    public void updateByConditions(int id,String name,Double sal) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            /**             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集             * 因此我们使用Map集合来装载我们的参数             */            Map<String, Object> map = new HashMap();            map.put("id", id);            map.put("name", name);            map.put("sal", sal);            sqlSession.update("StudentID.updateByConditions", map);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        studentDao.updateByConditions(2,"haha",500D);    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            /**
             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集
             * 因此我们使用Map集合来装载我们的参数
             */
            Map<String, Object> map = new HashMap();
            map.put("id", id);
            map.put("name", name);
            map.put("sal", sal);
            sqlSession.update("StudentID.updateByConditions", map);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }

    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        studentDao.updateByConditions(2,"haha",500D);

    }
640?wx_fmt=png
这里写图片描述
动态删除
640?wx_fmt=jpeg
这里写图片描述

以前我们使用JDBC也好，Hibernate也好，想要批量删除的时候，总是使用的是循环删除。而我们现在使用的是Mybatis，SQL语句是自己写的。所以我们可以写下如下的SQL来进行删除

delete from students where id in (?,?,?,?);
而我们的Mybatis又支持动态SQL,所以删除起来就非常方便了！
    <delete id="deleteByConditions" parameterType="int">        <!-- foreach用于迭代数组元素             open表示开始符号             close表示结束符合             separator表示元素间的分隔符             item表示迭代的数组，属性值可以任意，但提倡与方法的数组名相同             #{ids}表示数组中的每个元素值         -->        delete from students where id in         <foreach collection="array" open="(" close=")" separator="," item="ids">             #{ids}         </foreach>    </delete>

        <!-- foreach用于迭代数组元素
             open表示开始符号
             close表示结束符合
             separator表示元素间的分隔符
             item表示迭代的数组，属性值可以任意，但提倡与方法的数组名相同
             #{ids}表示数组中的每个元素值
         -->
        delete from students where id in
         <foreach collection="array" open="(" close=")" separator="," item="ids">
             #{ids}
         </foreach>

    </delete>
删除编号为2，3，4的记录
    public void deleteByConditions(int... ids) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            /**             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集             * 因此我们使用Map集合来装载我们的参数             */            sqlSession.delete("StudentID.deleteByConditions", ids);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        studentDao.deleteByConditions(2,3,4);    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            /**
             * 由于我们的参数超过了两个，而方法中只有一个Object参数收集
             * 因此我们使用Map集合来装载我们的参数
             */
            sqlSession.delete("StudentID.deleteByConditions", ids);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }

    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        studentDao.deleteByConditions(2,3,4);

    }
640?wx_fmt=png
这里写图片描述
动态插入
我们要想动态插入的话，就比其他的DML语句稍微复杂一点，因为它有两部分是不确定的，平常的SQL语句是这样的：
insert into student(id,name,sal) values(?,?,?)into student(id,name,sal) values(?,?,?)
640?wx_fmt=jpeg
这里写图片描述
SQL代码块是不能像之前那样帮我们自动去除多余的逗号的，因此我们需要使用trim标签来自己手动去除…
编写insertSQL语句的时候，不要忘了写()括号。
    <!--SQL片段默认是不帮我们自动生成合适的SQL，因此需要我们自己手动除去逗号-->    <sql id="key">        <trim suffixOverrides=",">            <if test="id!=null">                id,            </if>            <if test="id!=null">                name,            </if>            <if test="id!=null">                sal,            </if>        </trim>    </sql>    <sql id="value">        <trim suffixOverrides=",">            <if test="id!=null">                #{id},            </if>            <if test="id!=null">                #{name},            </if>            <if test="id!=null">                #{sal},            </if>        </trim>    </sql>    <!--动态插入-->    <insert id="insertByConditions" parameterType="zhongfucheng.Student">        insert into students (<include refid="key"/>) values        (<include refid="value"/>)    </insert>
    <sql id="key">
        <trim suffixOverrides=",">
            <if test="id!=null">
                id,
            </if>

            <if test="id!=null">
                name,
            </if>

            <if test="id!=null">
                sal,
            </if>
        </trim>
    </sql>

    <sql id="value">
        <trim suffixOverrides=",">
            <if test="id!=null">
                #{id},
            </if>

            <if test="id!=null">
                #{name},
            </if>

            <if test="id!=null">
                #{sal},
            </if>
        </trim>
    </sql>
    <!--动态插入-->
    <insert id="insertByConditions" parameterType="zhongfucheng.Student">

        insert into students (<include refid="key"/>) values
        (<include refid="value"/>)

    </insert>
测试三个不同内容的数据
    public void insertByConditions(Student student) throws Exception {        //得到连接对象        SqlSession sqlSession = MybatisUtil.getSqlSession();        try{            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL            sqlSession.insert("StudentID.insertByConditions", student);            sqlSession.commit();        }catch(Exception e){            e.printStackTrace();            sqlSession.rollback();            throw e;        }finally{            MybatisUtil.closeSqlSession();        }    }    public static void main(String[] args) throws Exception {        StudentDao studentDao = new StudentDao();        studentDao.insertByConditions(new Student(55, null, null));//name和sal为空        studentDao.insertByConditions(new Student(66, "haxi", null));//sal为空        studentDao.insertByConditions(new Student(77, null, 3999d));//name为空    }
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL
            sqlSession.insert("StudentID.insertByConditions", student);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }

    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        studentDao.insertByConditions(new Student(55, null, null));//name和sal为空

        studentDao.insertByConditions(new Student(66, "haxi", null));//sal为空
        studentDao.insertByConditions(new Student(77, null, 3999d));//name为空


    }
640?wx_fmt=png
这里写图片描述
总结
如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y


                

  
        

    

  






  




  

    
  




        

          

              版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
          

        

  


  
    
      ESP32 驱动 SYN6288 语音合成：Arduino IDE 下实现中文数字混合文本的智能播报
      本文详细介绍了如何在Arduino IDE环境下使用ESP32驱动SYN6288语音合成模块，实现中文数字混合文本的智能播报。通过硬件选型、开发环境搭建、编码转换原理、命令帧构造及串口通信实战等步骤，帮助开发者快速掌握语音播报技术。文章还提供了混合文本处理技巧和常见问题排查方法，适合智能硬件开发者参考。
    
    阅读详情
  





    

      

        
相关推荐

        
      

      

          
            
S32K144之芯片锁死解锁——关闭debug端口

              
S32K144之芯片锁死及解锁
经常捣鼓单片机就会发现，时常会因为某些操作不当导致芯片锁死情况的发生，通过Jlink我们可以读到芯片的ID，但是无法进行Debug，这很是让人苦恼。
基于S32K144的芯片锁死，一般有如下几种可能：
1、时钟配置异常，过高的配置时钟频率以及不配置时钟，都有可能造成芯片保护锁死，我就曾经因为不注意把时钟配置代码注释掉，导致芯片锁死。
2、我是微软雅黑烧写断电，如果在...

            

                weixin_41935674的博客
                
                  
                    1万+
                
            

          
          
            
Java基础之—反射（非常重要）

              
反射是框架设计的灵魂
（使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码））
一、反射的概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的

            

                敬业小码哥的博客
                
                  
                    76万+
                
            

          
          
            
【SEW-伺服电机-Profinet-io通讯控制——伺服配置】

              
SEW-伺服电机-Profinet-io通讯控制——伺服配置一、本次使用配置说明编写经历受国际形式与疫情影响相关资料查询阅读测试验证不易二、伺服配置流程1.基本准备条件2.硬件-电路连接3.设备在线连接4.软件-参数配置5.手动运行测试6.PN-IO自动控制配置8.PLC1200硬件组态9.PLC软件编程10.调试故障分析三、总结四、参考
一、本次使用配置说明编写经历
受国际形式与疫情影响
由于近期受国际形式影响以及全球疫情影响，Siemens等常用产品供货期与供货量严重受限，项目上不得不采取选用其它替代产

            

                qq_39024187的博客
                
                  
                    1万+
                
            

          
          
            
Java单元测试实践-17.Mybatis与Mock

              
Java单元测试实践-00.目录（9万多字文档+700多测试示例）
https://blog.youkuaiyun.com/a82514921/article/details/107969340
1. Mybatis与Mock
在对Mybatis的Mapper对象进行处理时，可能需要使某个Mapper对象在某些情况下返回指定值，在某些情况下执行真实方法；或者需要对Mapper对象相关的数据库操作进行记录，以下进行说明。
1.1. 测试示例说明
与Mybatis相关的测试类在测试示例的adrninistrator.tes

            

                adrninistrat0r的博客
                
                  
                    1万+
                
            

          
          
            
自考计算机系统原理（第六章计算机系统概论）-13015

              
名词解释

I/O 硬件
I/O软件
用户空间I/O软件
内核空间I/O 软件
系统调用处理程序
系统调用服务例程
设备驱动程序
中断服务程序
系统级1/O函数
虚拟文件系统
文件描述符
文件元数据
流缓冲区
索引节点
目录文件
目录项
系统打开文件表
磁盘高速缓存
高速缓存 RAM
I / O 控制方式
程序直接控制I/O
就绪状态
中断控制I/O
中断屏蔽字
多重中断
中断嵌套
DMA 方式
DMA 控制器
设备控制器
I/O端口
控制端口
数据端口
状态端口
I/O 地址空间
独立编址方式
统一编址方

            

                qq_23872947的博客
                
                  
                    1150
                
            

          
          
            
避开STM32中断优先级配置的坑：HAL_NVIC_SetPriority()参数你真的用对了吗？

              
本文深入解析STM32中断优先级配置中的关键问题，重点剖析HAL_NVIC_SetPriority()函数的正确使用方法。通过实际案例揭示优先级分组设置、抢占优先级与子优先级的区别，提供多中断系统中的优化策略和调试技巧，帮助开发者避免常见配置错误，提升系统稳定性。

            

                weixin_42532938的博客
                
                  
                    421
                
            

          
          
            
springboot+mybatis+mockito单元测试

              
springboot、mybatis这里不做详细介绍，重点介绍一下mockito是什么，以及怎么与springboot、mybatis集成。

mockito是什么？举个简单例子：当service层通过调用dao层接口获取数据，然后进行数据处理。在实际做单元测试时，dao层的数据是从数据库来的，我们想自己构造一些数据跑一下service层的业务逻辑，这个时候就需要将从数据库查询的时候替换为自己构造的数据，也就是service层调用的dao层接口返回的数据需要替换为自己构造的数据，那怎么替换呢？这个时候moc

            

                小冷在努力~
                
                  
                    2634
                
            

          
          
            
黑猫带你学UFS协议第12篇：UFS标志（Flags）和属性（Atrributes）详解

              
UFS中的标志其实就是一些开关，布尔型，非0即1，打开或者关闭。这些标志可以用来使能或者禁止UFS设备的一些功能、模式或者状态。

简单来说，flag和attribute、discriptor一样，都是ufs的寄存器罢了。只不过spec将这些寄存器分类了，分成这三种大的类型了而已。

标志可以被清除、复位、设置、触发、读。

主机也是通过设备管理器的Query Request UPIU来读取或者写标志。

            

                黑猫奥利奥的博客
                
                  
                    2083
                
            

          
          
            
(五)Mybatis的复杂查询

              
Mybatis的动态SQL查询和多表查询

            

                lyj_010的博客
                
                  
                    976
                
            

          
          
            
YOLO26涨点改进 | 检测头Head创新改进篇 | 利用RFAConv感受野注意力卷积改进YOLO26检测头，RFAHead感受野注意力检测头，助力小目标检测高效涨点

              
YOLO26作为轻量化目标检测模型的新一代标杆，凭借高效的Backbone与Neck结构，在实时检测场景中表现突出，但原生检测头仍存在核心痛点——感受野固定、小目标特征感知薄弱、多尺度目标适配不足，导致在小目标密集、复杂背景遮挡等场景中漏检率偏高、定位精度不足。

            

                qq_36130719的博客
                
                  
                    167
                
            

          
          
            
乐鑫科技 EchoEar 喵伴修改自定义唤醒词的方法 EchoEar喵伴、唤醒词修改、ESP32、AI萌宠、智能音箱、开发者指南

              
标签：乐鑫科技、EchoEar喵伴、唤醒词修改、ESP32、AI萌宠、智能音箱、开发者指南大家好，我是一名前端开发工程师，最近在玩乐鑫科技推出的时，发现它不仅萌趣十足，还能进行全双工语音交互、多模态识别，甚至能识别你的情绪和与你互动。EchoEar 喵伴是由乐鑫科技和火山引擎扣子大模型团队合作开发的，它使用乐鑫的芯片方案（ESP32 系列）+ 火山引擎扣子大模型，支持 WiFi 连接和本地处理，长记忆能力可以让它记住用户的偏好与习惯。

            

                代码简单说 Vue、JAVA、PHP、Node.js 熟练运用，接口、架构、性能全搞定。
                
                  
                    1879
                
            

          
          
            
使用MyBatis实现条件查询

              
在test/java的net.huawei.mybatis.mapper包里创建TestStudentMapper类。运行测试方法testFindByCondition()，查看结果。运行测试方法testFindByCondition()，查看结果。运行测试方法testFindByCondition()，查看结果。运行测试方法testFindByCondition()，查看结果。比如查询姓“吴”，性别为“女”，同时年龄为19的学生记录。注意：注意：通配符%与_的区别。修改测试方法里的查询条件。

            

                梁辰兴的博客
                
                  
                    2818
                
            

          
          
            
京东豆自动领取脚本配置教程

              
腾讯云/阿里云服务器（Docker环境）：全自动跑脚本领京豆（无需本地代理，使用加速源）

            

                AIOT魔法师
                
                  
                    855
                
            

          
          
            
【MyBatis】入门程序

              
详解编写mybatis入门程序的主要步骤，以及junit、logback和工具类 SqlSessionUtil 的封装

            

                August_._的博客
                
                  
                    1182
                
            

          
          
            
精雕软件(JDpaint) 5.5 绿色版

              
精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

            

            

          
          
            
ssm框架搭建

              
这个是一个在idea上成功跑起来的ssm框架项目，保存在这里方便以后使用直接下载

            

            

          
          
            
Mybatis入门

              
在前面我们学习MySQL数据库时，都是利用图形化客户端工具(如：idea、datagrip)，来操作数据库的。在客户端工具中，编写增删改查的SQL语句，发给MySQL数据库管理系统，由数据库管理系统执行SQL语句并返回执行结果。增删改操作：返回受影响行数查询操作：返回结果集(查询的结果)我们做为后端程序开发人员，通常会使用Java程序来完成对数据库的操作。Java程序操作数据库，现在主流的方式是：Mybatis。什么是MyBatis?MyBatis是一款优秀的持久层框架，用于简化JDBC的开发。

            

                qq_63763836的博客
                
                  
                    1095
                
            

          
          
            
WINCC7.3破解文件

              
WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

            

            

          
          
            
MyBatis快速入门第二讲——MyBatis的快速入门

              
MyBatis框架的架构MyBatis框架的架构如下图： 
 
下面作简要概述：
SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句，此文件需要在SqlMapConfig.xml中加载。
通过mybatis环境等配置信息构造SqlSessionFactory(即会

            

                李阿昀的博客
                
                  
                    1万+
                
            

          
          
            
Camera2Demo

              
在Camera2 的基础上进行封装，使得Camera2一堆初始化逻辑与Activity分离，降低耦合度，完成预览拍照并保存的操作

            

            

          
          
            
MyBatis实战：从入门到精通，一站式学习MyBatis的最佳选择

              
MyBatis实战：从入门到精通，一站式学习MyBatis的最佳选择
项目介绍
MyBatis实战是一个专注于MyBatis技术学习的开源项目，旨在通过丰富的实战示例代码，帮助开发者从零开始掌握MyBatis的核心概念与高级用法。项目中的示例代码主要来源于刘增辉老师所著的《MyBatis从入门到精通》一书，经过精心整理与实践，确保每一个示例都能帮助开发者深入理解MyBatis的各个方面。
项目技术...

            

                gitblog_00834的博客
                
                  
                    1111
                
            

          
          
            
【Mybatis】Mybatis入門

              
1-1什么是MyBatis


a.MyBatis是对JDBC的封装
b.将SQL语句放在映射文件中(XML)
c.自动将输入参数映射到SQL语句的动态参数中
d.自动将SQL语句执行的结果映射成Java对象


1-2MyBatis的应用


(0)准备工作，创建学生表，添加数据
    
    CREATE TABLE tbl_student(id VARCHAR(32),NAME VARCHAR(32),age INT);

    INSERT INTO tbl_student VALUE("..

            

                keeper42的博客
                
                  
                    188
                
            

          
          
            
mybatis入门

              
Mybatis入门

亿图作品思维图（本人作）




            

                神韵
                
                  
                    492
                
            

          
          
            
Mybatis入门及使用

              
MyBatis是一款优秀的持久层框架，用于简化JDBC的开发。MyBatis本是 Apache的一个开源项目iBatis，2010年这个项目由apache迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github。在上面我们提到了两个词：一个是持久层，另一个是框架。持久层：指的是就是数据访问层(dao)，是用来操作数据库的。框架：是一个半成品软件，是一套可重用的、通用的、软件基础代码模型。在框架的基础上进行软件开发更加高效、规范、通用、可拓展。

            

                2202_75483664的博客
                
                  
                    1971
                
            

          
          
            
MyBatis详解（一）：入门程序

              
一、对原生态jdbc程序中问题总结1.1、原始jdbc程序步骤：（1） 注册驱动JDBC类库向DriverManager注册数据库驱动·（2）建立连接(url、username、password)使用DriverManager提供的getConnection()方法连接到数据库（3）创建SQL语句，获取语句执行对象编写SQL语句，并建立SQL语句执行对象（4）执行语句执行SQL语句，并将结果集合返回到ResultSet中（5）处理结果（6）释放资源（注意关闭的顺序）

            

                2501_90472645的博客
                
                  
                    1848
                
            

          
          
            
mybatis的入门使用

              
mybatis generator的使用
准备工作：
可编辑xml文件的编辑器（懒人直接用myeclipse打开就行）
mybatis generator core 包(mybatis-generator-core-1.3.2.jar)
jdbc驱动包(mysql-connector-java-5.1.40-bin.jar)
一个空的src文件夹
结构如图（根目录D:/mybatis

            

                qq499889810的博客
                
                  
                    450
                
            

          
          
            
Mybatis 配置Mybatis 二、MyBatis的入门程序

              
6.编写主配置文件，在resources目录下创建SqlMapConfig.xml的配置文件（其实名称可以任意），导入对应的约束，编写主配置文件。编写UserMapper.xml的配置文件，导入约束文件。引入log4j的jar包，1.2.12版本（需要引入log4j.properties的配置文件）4.编写UserMapper的接口和方法（就是咱们以前的UserDao接口）3.编写User的实现类，属性尽量使用包装类型，具体的代码如下。引入MyBatis的3.4.5的版本的坐标。

            

                best_virtuoso的博客
                
                  
                    1029
                
            

          
          
            
MyBatis框架的入门

              
MyBatis是一个优秀的基于Java的持久层框架，内部对JDBC做了封装，使开发者只需要关注SQL语句，而不用关注JDBC的代码，使开发变得更加的简单。MyBatis通过XML或者注解的方式将要执行的各种Statement对象配置起来，通过Java对象和statement中SQL的动态参数进行映射，并最终执行SQL语句。执行SQL后，最终将结果已Java对象返回。采用了ORM的思想。

            

                qq_63964907的博客
                
                  
                    901
                
            

          
          
            
MyBatis-什么是MyBatis？以及MyBatis的快速入门。

              
MyBatis-什么是MyBatis？以及MyBatis的快速入门。

            

                m0_63949203的博客
                
                  
                    1072
                
            

          
          
            
MyBatis 入门

              
MyBatis基础

            

                2301_80313139的博客
                
                  
                    1395
                
            

          
      

    


  

    

      上一篇：
      
        Struts2入门这一篇就够了
      
    

    

      下一篇：
      
        Mybatis【缓存、代理、逆向工程】
      
    

  



            
  



          

          


  

    
    
    
    

      点赞
      
      
            0
      
    

    
    
      评论
      
            0
      
    
    
    

      书签
      书签
      
          1
      
    

    
    
    
    
    
    
  


            

            

              

              

            

            
        

        


  

    

      
          Java3y
      
      

        

          Java3y
            
                  
                    领域专家: 后端开发技术领域
                      领域专家: 后端开发技术领域
                  
            
        

        

            
              博客等级
            
            码龄9年
          1万+粉丝
          509原创
        

      

    

    

          + 关注
    

  



      

      

        
      

      





	

		评论	
	

  

    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值