2021-03-31

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量61 收藏
点赞数
分类专栏： java项目学习分类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53123681/article/details/115343365
版权

MyBatis_1

1. 什么是MyBatis?

    MyBatis是一个基于ORM的数据访问层框架。

    框架----在学习JavaSE和JavaWEB的过程中，学的都是基础和底层的技术，使用这些技术完全可以开发出web应用。但是使用这些技术开发的效率非常低下，并且会出现很多繁琐的步骤，同时也不利于后期的代码维护和升级。于是就有一些牛逼的人物，他们针对JavaSE和JavaWEB中的技术进行各种的封装，进而可以帮助开发者提高开发的效率，同时也能提升项目的性能。而这些牛人封装的这些东西就称为框架。

    框架本质还是Java程序，这些程序将特别原始和底层的代码进行了封装，然后把这些封装以后的程序打包之后提供给开发人员使用。帮助开发者提高开发的效率，同时也能提升项目的性能。

数据访问层--通常我们在左项目的时候，会把一个项目分成3个部分，这3个部分分别是：

  1. 控制层[web层]----用来做数据的导航【Servlet、Struts2、SpringMVC】
  2. 业务层----用来处理相关功能的具有实现业务。【Spring】
  3. 数据访问层[数据持久层]---用来访问数据库数据。【JDBC、Hibernate、MyBatis】

早期javaweb的3大框架---SSH[Struts2-Spring-Hibernate]

现在流行的javaweb的3大框架---SSM[SpringMVC-Spring-MyBatis]

2. 什么是ORM?

    ORM---对象关系映射

    我们在访问数据库的时候所编写的都是Java程序，Java程序只认识Java对象，而我们所访问的数据库大多数都是关系型数据库，那么这时Java程序要想访问关系型数据库，那么就需要将Java对象转换成关系型数据，才能被数据库认识。

    这时我们可以认为一个Java类就是关系型数据库中的一张数据表，Java类中的成员变量是数据库表中的一个列，Java类创建的Java对象就是数据库表中的一行记录。这时将Java对象对应成为数据库表记录的过程就是对象关系映射【ORM】。

3. 为什么要使用MyBatis?

  1. 为了简化数据库访问操作，提高开发的效率，提升项目的性能，增加程序的可维护性
  2. 当我们使用Java程序控制Java对象的时候，数据库中的数据表记录会随之变化。【将原来通过java程序访问数据库表的操作，简化成通过java程序访问java对象】

使用MyBatis框架

  1. 准备数据库表
create  table t_person(
per_id int primary key auto_increment,
per_name varchar(20),
per_age int,
per_address varchar(30)
);
  1. 创建maven工程
  2. 添加jar依赖
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.6</version>
</dependency>

4. 参考数据库表，创建javaBean类

package com.wangxing.mybatis.bean;
public class Person {
    private int perid;
    private String pername;
    private int perage;
    private String peraddress;
    public int getPerid() {
        return perid;
    }
    public void setPerid(int perid) {
        this.perid = perid;
    }
    public String getPername() {
        return pername;
    }
    public void setPername(String pername) {
        this.pername = pername;
    }
    public int getPerage() {
        return perage;
    }
    public void setPerage(int perage) {
        this.perage = perage;
    }
    public String getPeraddress() {
        return peraddress;
    }
    public void setPeraddress(String peraddress) {
        this.peraddress = peraddress;
    }
}

5.在src/main/resources编写数据库链接字符串的配置文件【mydate.properties】

mydrivername=com.mysql.jdbc.Driver
myurl=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8
myusername=root
mypassword=123456

6. 创建数据库访问接口

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import java.util.List;
public interface PersonMapper {
    /**
     * 添加数据
     * @param person
     * @return
     */
    boolean insertPerson(Person person);
    /**
     * 修改数据
     * @param person
     * @return
     */
    boolean updatePerson(Person person);
    /**
     * 删除数据
     * @return
     */
    boolean deletePersonById(int perid);
    /**
     * 根据id查询数据
     * @return
     */
    Person selectPersonById(int perid);
    /**
     * 查询所有数据
     * @return
     */
    List<Person> selectPerson();
}

7. 在src/main/resources编写sql映射文件[PersonMapper.xml]

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wangxing.mybatis.mapper.PersonMapper">
    <insert id="insertPerson" parameterType="com.wangxing.mybatis.bean.Person">
        insert into t_person values (null,#{pername},#{perage},#{peraddress});
    </insert>
    <update id="updatePerson" parameterType="com.wangxing.mybatis.bean.Person">
        update t_person set per_name=#{pername},per_age=#{perage},per_address=#{peraddress} where per_id=#{perid};
    </update>
    <resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
        <id column="per_id" property="perid"></id>
        <result column="per_name" property="pername"></result>
        <result column="per_age" property="perage"></result>
        <result column="per_address" property="peraddress"></result>
    </resultMap>
    <select id="selectPersonById" parameterType="int" resultMap="personMap">
        select * from  t_person where per_id=#{perid};
    </select>
    <select id="selectPerson" resultMap="personMap">
        select * from  t_person;
    </select>
    <delete id="deletePersonById" parameterType="java.lang.Integer">
        delete from t_person where per_id=#{perid};
    </delete>
</mapper>

8. 在src/main/resources编写MyBatis配置文件【名称建议使用mybatis-config.xml，也可以随便写】

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置引入数据库链接字符串的资源文件 -->
    <properties resource="mydata.properties"></properties>
    <!-- 配置mybatis默认的连接数据库的环境 -->
    <environments default="development">
    <environment id="development">
        <!-- 配置事务管理器 -->
        <transactionManager type="JDBC"></transactionManager>
        <!-- 配置数据源 -->
        <dataSource type="POOLED">
            <property name="driver" value="${mydriver}"/>
            <property name="url" value="${myurl}"/>
            <property name="username" value="${myusername}"/>
            <property name="password" value="${mypassword}"/>
        </dataSource>
    </environment>
</environments>

9. 创建测试类

package com.wangxing.mybatis.test;
import com.wangxing.mybatis.bean.Person;
import com.wangxing.mybatis.mapper.PersonMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.util.List;
public class TestMain {
    public static void testInsertPerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=new Person();
            person.setPername("zhangsan");
            person.setPerage(23);
            person.setPeraddress("西安");
            personMapper.insertPerson(person);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
           e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testUpdatePerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=new Person();
            person.setPerid(1);
            person.setPername("lisi");
            person.setPerage(24);
            person.setPeraddress("beijing");
            personMapper.updatePerson(person);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testSelectPersonById(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=personMapper.selectPersonById(1);
            //提交sqlsession
            sqlSession.commit();
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testSelectPerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            List<Person> personlist=personMapper.selectPerson();
            //提交sqlsession
            sqlSession.commit();
            System.out.println("personlist.size----"+personlist.size());
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testDeletePerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            personMapper.deletePersonById(1);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void main(String[] args) {
        //测试添加用户信息
        //testInsertPerson();
        //测试修改用户信息
        //testUpdatePerson();
        //测试根据id查询用户信息
        //testSelectPersonById();
        //测试查询所有用户信息
        //testSelectPerson();
        //测试根据id删除用户信息
        testDeletePerson();
    }
}

1.MyBatis执行SQL的两种方式：SqlSession和Mapper接口

  1. 用 Mapper 接口发送 SQL

 PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);

 personMapper.insertPerson(person);

通过 SqlSession 的 getMapper 方法来获取一个 Mapper 接口，就可以调用它的方法了。因为 SQL映射 文件或者接口注解定义的 SQL 都可以通过“类的全限定名+方法名”查找，所以 MyBatis 会启用对应的 SQL 进行运行，并返回结果。

实例：

package com.wangxing.mybatis.test;
import com.wangxing.mybatis.bean.Person;
import com.wangxing.mybatis.mapper.PersonMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.util.List;
public class TestMain {
    public static void testInsertPerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=new Person();
            person.setPername("zhangsan");
            person.setPerage(23);
            person.setPeraddress("西安");
            personMapper.insertPerson(person);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
           e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testUpdatePerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=new Person();
            person.setPerid(1);
            person.setPername("lisi");
            person.setPerage(24);
            person.setPeraddress("beijing");
            personMapper.updatePerson(person);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testSelectPersonById(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=personMapper.selectPersonById(1);
            //提交sqlsession
            sqlSession.commit();
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testSelectPerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            List<Person> personlist=personMapper.selectPerson();
            //提交sqlsession
            sqlSession.commit();
            System.out.println("personlist.size----"+personlist.size());
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void testDeletePerson(){
        //定义SqlSession对象
        SqlSession sqlSession=null;
        try {
            //通过SqlSessionFactoryBuilder类创建出SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            //从SqlSessionFactory中取得一个SqlSession对象
            sqlSession=sqlSessionFactory.openSession();
            //通过得到数据访问接口对象调用insertPerson方法
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            personMapper.deletePersonById(1);
            //提交sqlsession
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }
    public static void main(String[] args) {
        //测试添加用户信息
        //testInsertPerson();
        //测试修改用户信息
        //testUpdatePerson();
        //测试根据id查询用户信息
        //testSelectPersonById();
        //测试查询所有用户信息
        //testSelectPerson();
        //测试根据id删除用户信息
        testDeletePerson();
    }
}

2.SqlSession 发送 SQL

通过SqlSession对象的

int  insert(“数据访问接口的包名+接口名+方法名” ,  数据访问接口的方法的参数);

int  update(“数据访问接口的包名+接口名+方法名” ,  数据访问接口的方法的参数);

int  delete(“数据访问接口的包名+接口名+方法名” ,  数据访问接口的方法的参数);

<T>  selectOne(“数据访问接口的包名+接口名+方法名” ,  数据访问接口的方法的参数);

List<T>  selectList(“数据访问接口的包名+接口名+方法名” ,  数据访问接口的方法的参数);

.......

实例:

package com.wangxing.mybatis.test;
import com.wangxing.mybatis.bean.Person;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.util.List;
public class TestMain {
    public static void testInsertPerson(){
        SqlSession sqlSession=null;
        try{
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            sqlSession=sqlSessionFactory.openSession();
            Person person=new Person();
            person.setPername("zhangsan");
            person.setPerage(23);
            person.setPeraddress("xian");
        sqlSession.insert("com.wangxing.mybatis.mapper.PersonMapper.insertPerson",person);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    public static void testUpdatePerson(){
        SqlSession sqlSession=null;
        try{
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            sqlSession=sqlSessionFactory.openSession();
            Person person=new Person();
            person.setPerid(1);
            person.setPername("zhangsanfeng");
            person.setPerage(123);
            person.setPeraddress("wudang");
            sqlSession.update("com.wangxing.mybatis.mapper.PersonMapper.updatePerson",person);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    public static void testSelectPersonById(){
        SqlSession sqlSession=null;
        try{
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            sqlSession=sqlSessionFactory.openSession();
            Person person=(Person)sqlSession.selectOne("com.wangxing.mybatis.mapper.PersonMapper.selectPersonById",1);
            sqlSession.commit();
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    public static void testSelectPerson(){
        SqlSession sqlSession=null;
        try{
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            sqlSession=sqlSessionFactory.openSession();
            List<Person> perlist=sqlSession.selectList("com.wangxing.mybatis.mapper.PersonMapper.selectPerson");
            sqlSession.commit();
            System.out.println("perlist.size=="+perlist.size());
            Person person=perlist.get(0);
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    public static void testDeletePerson(){
        SqlSession sqlSession=null;
        try{
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
            sqlSession=sqlSessionFactory.openSession();
            sqlSession.delete("com.wangxing.mybatis.mapper.PersonMapper.deletePersonById",1);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }
    public static void main(String[] args) {
        //测试添加用户信息
        //testInsertPerson();
        //测试修改用户信息
        //testUpdatePerson();
        //测试根据id查询用户信息
        //testSelectPersonById();
        //测试查询所有用户信息
        //testSelectPerson();
        //测试根据id删除用户信息
        testDeletePerson();
    }
}

3.对比两种发送 SQL 方式

上面分别展示了 MyBatis 存在的两种发送 SQL 的方式，一种用 SqlSession 直接发送，另外一种通过 SqlSession 获取 Mapper 接口再发送。建议采用 SqlSession 获取 Mapper 的方式，理由如下：

  1. 使用 Mapper 接口编程可以消除 SqlSession 带来的功能性代码，提高可读性，而 SqlSession 发送 SQL，需要一个 SQL id 去匹配 SQL，比较晦涩难懂。
  2. 使用Mapper.selectPersonById(1)方式，IDE会提示错误和校验，而使用 sqlSession.selectOne（“com.wangxing.mybatis.mapper.PersonMapper.selectPersonById”,1）语法，只有在运行中才能知道是否会产生错误。

目前使用Mapper接口编程已成为主流，尤其在Spring 中运用MyBatis 时，Mapper 接口的使用就更为简单，所以本教程使用Mapper 接口发送SQL语句并执行的方式。

4.数据访问接口+注解

PersonMapper.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.wangxing.mybatis.mapper.PersonMapper">
    <resultMap id="perMap" type="com.wangxing.mybatis.bean.Person">
        <id column="per_id" property="perid"></id>
        <result column="per_name" property="pername"></result>
        <result column="per_age" property="perage"></result>
        <result column="per_address" property="peraddress"></result>
    </resultMap>
</mapper>

数据访问接口带注解

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface PersonMapper {
    /**
     * 添加数据
     * @param person
     * @return
     */
    @Insert("insert into t_person values (null,#{pername},#{perage},#{peraddress});")
    boolean insertPerson(Person person);
    /**
     * 修改数据
     * @param person
     * @return
     */
    @Update("update t_person set per_name=#{pername},per_age=#{perage},per_address=#{peraddress} where per_id=#{perid};")
    boolean updatePerson(Person person);
    /**
     * 删除数据
     * @return
     */
    @Delete("delete from t_person where per_id=#{perid};")
    boolean deletePersonById(int perid);
    /**
     * 根据id查询数据
     * @return
     */
    @Results(id = "personMap" , value = {
            @Result(column = "per_id",property = "perid"),
            @Result(column = "per_name",property = "pername"),
            @Result(column = "per_age",property = "perage"),
            @Result(column = "per_address",property = "peraddress"),
    })
    @Select("select * from  t_person where per_id=#{perid};")
    Person selectPersonById(int perid);
    /**
     * 查询所有数据
     * @return
     */
    @Select("select * from  t_person;")
    @ResultMap("perMap")
    List<Person> selectPerson();
}

注意:

org.apache.ibatis.binding.BindingException: Type interface com.wangxing.mybatis.mapper.PersonMapper is not known to the MapperRegistry.

因为没有在MyBatis的核心配置文件中注册数据访问接口，

解决方法:在MyBatis的核心配置文件中注册数据访问接口

select * from t_user u
left join t_user_role ur on u.id = ur.user_id
left join t_role r on ur.role_id = r.id
left join t_user_info ui on u.id = ui.user_id
left join t_female_health fh on u.id = fh.user_id
left join t_male_health mh on u.id = mh.user_id
where u.user_name like concat('%', ${userName},'%')
and r.role_name like concat('%', ${roleName},'%')
and u.sex = 1
and ui.head_image is not null;

显然这条 SQL 比较复杂，如果放入 @Select 中会明显增加注解的内容。如果把大量的SQL 放入 java 代码中，显然代码的可读性也会下降。如果同时还要考虑使用动态 SQL，比如当参数 userName 为空，则不使用 u.user_name like concat（'%',${userName},'%'）作为查询条件；当 roleName 为空，则不使用 r.role_name like concat（'%',${roleName},'%'）作为查询条件，但是还需要加入其他的逻辑，这样就使得这个注解更加复杂了，不利于日后的维护和修改。

用一张图来展示 MyBatis 核心组件之间的关系。

2.MyBatis 的工作原理

下面对图中的每步流程进行说明。
1）读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。

2）加载SQL映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。
3）构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。

4）创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。

5）Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。
6）MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。
7）输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。

8）输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

注意:Executor 执行器执行SQL语句时，是根据SQL映射文件中对应元素的<insert><update><delete><select>的id属性值去选择对应的sql语句,由于SQL映射文件中对应元素的<insert><update><delete><select>的id属性值是数据访问接口的方法名，所以数据访问接口中的方法是不能重载的。

weixin_53123681
关注
专栏目录
2021-03-15
zyt239000的博客
03-15 819
搭建mybatis环境 首先创建一个maven项目 然后我们要在pom.xml里添加配置 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0
2021-03-19
weixin_42564545的博客
03-19 476
aultium designer 中在原理图选择器件映射到 pcb，如下： 选择原理图的器件，然后依次 tool— Select PCB Compoments 。或者用快捷键，依次按t s，接下来会从原理图跳到pcb器件。
2021-02-03
qq_37135047的博客
02-03 1105
/** * 隐藏虚拟按键，并且全屏 */ protected void hideBottomUIMenu() { //隐藏虚拟按键，并且全屏 if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) { // lower api View v = this.getWindow().getDecorView(); ...
计算机视觉论文-2021-03-31
中科院AI算法工程师的博客
04-02 4300
本专栏是计算机视觉方向论文收集积累，时间：2021年3月31日，来源：paper digest 欢迎关注原创公众号【计算机视觉联盟】，回复【西瓜书手推笔记】可获取我的机器学习纯手推笔记！ 直达笔记地址：机器学习手推笔记（GitHub地址） 1, TITLE:3D AffordanceNet: A Benchmark for Visual Object Affordance Understanding AUTHORS: Shengheng Deng ; Xun Xu ; Chaoz...
2021-03-31-华为实习-机试题
qq_35632833的博客
04-02 1649
文章目录题目一1. 描述2. 代码 CSDN第一题：2021-03-31华为 牛客：三题 题目一 1. 描述 题目：双循环赛制每两只球队都会各比一次，赢了积3分，平手各积1分，输了不积分。现最多有26支队伍，用a，b，c…表示，统计所有球队的积分并按照从高到低排序，如果两支队伍的积分相同，则按球队的字典序排序。队伍之间用“，”分隔，输入以空行结束。 示例： 测试用例1: 输入： a-b 3:0 b-a 1-1 输出： a 4,b 1 解释：a球队胜利积3分，a与b平各积1分，a得4分b得1分 测试用例
2021-08-10
weixin_55997091的博客
08-10 407
本日先占位。
2021-01-06
qq_40504996的博客
01-06 909
运行机某个js文件访问不了。做了过滤器，没有被过滤的。其他js文件都可以。就单独一个403。考虑是否是防火墙做了一些敏感词的判断过滤。 将js文件名修改试一下，或者从防火墙那方面做文章 ...
2021-01-04
wubaoyu123的博客
01-04 2255
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 知了一笑 博客园 首页 新随笔 联系 订阅 管理 数据仓库组件：Hive环境搭建和基础用法 本文源码：GitHub || GitEE 一、Hive基础简介 1、基础描述 Hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，是一个可以对Hadoop中的大规模存储的数据进行查询和分析存储的组件，Hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成
Test-2021-03-31
03-31
例如，`Test-2021-03-31-master`可能是一个项目目录，其中包含了HTML文件和对应的CSS文件。开发者可能在这里实验了不同的CSS选择器、伪类、伪元素，以及盒模型、布局模式（如Flexbox和Grid）、响应式设计、动画和...
Draft 2021-03-01 10:48:46-数据集
03-04
数据集是机器学习和数据分析领域中的重要组成部分，它包含了用于训练和评估模型的真实或模拟数据。在这个特定的案例中，我们有两个数据集文件——"speed_dating_train.csv"和"speed_dating_test.csv"，它们可能源自...
java生成租金计划 需求：根据下面的条件生成每个月的月租金计划列表 递增周期：1年 租金递增率：6% 租赁开始时间 2021-03-01 租赁结束时间 2022-03-01 免租开始时间：2021-03-01 免租结束时间：2021-03-31 开始月租金：600 递增周期的时间是从租赁开始时间计算。列表含 计算过程
05-26
免租结束时间：2021-03-31 开始月租金：600.0 递增周期：12个月 计算过程： 2021-03-01：0.0 2021-04-01：636.0 2021-05-01：675.84 2021-06-01：717.72 2021-07-01：761.83 2021-08-01：808.32 2021-09-01：857.34...
Java-网络
2301_81543552的博客
09-14 335
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 334
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 418
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 592
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 386
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 419
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值