package com.mybatisstudy.pojo;

public class User 
    private int id;
    private String username;
    private String sex;
    private String address;

    public User(String programmer, String man, String shangHai) 
        this.username = programmer;
        this.sex = man;
        this.address = shangHai;
    

    public User(int i, String programmer_1, String woman, String shenzhen) 
        this.id = i;
        this.username = programmer_1;
        this.sex = woman;
        this.address = shenzhen;
    

    public int getId() 
        return id;
    

    public void setId(int id) 
        this.id = id;
    

    public String getUsername() 
        return username;
    

    public void setUsername(String username) 
        this.username = username;
    

    public String getSex() 
        return sex;
    

    public void setSex(String sex) 
        this.sex = sex;
    

    public String getAddress() 
        return address;
    

    public void setAddress(String address) 
        this.address = address;
    

    @Override
    public String toString() 
        return "User[ " +
                "id=" + id +
                ", username='" + username + '\\'' +
                ", sex='" + sex + '\\'' +
                ", address='" + address + '\\'' +
                " ]";

一、查询所有用户

1. 持久层添加查询所有方法

// 查询所有用户
    List<User> findAll();

2. 在UserMapper.xml映射文件添加查询语句

<select id="findAll" resultType="com.mybatisstudy.pojo.User">
        select * from user
</select>

3. 测试方法

在test包下新建一个测试类TestUserMapper.java，注意测试类需要插入一个Junit依赖

import com.mybatisstudy.mapper.UserMapper;
import com.mybatisstudy.pojo.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;


import java.io.InputStream;
import java.util.List;

public class TestUserMapper 

    InputStream is = null;
    SqlSession session = null;
    UserMapper userMapper = null;

    //前置方法，不必重复代码
    @Before
    public void before() throws Exception 
        System.out.println("前置方法执行·············");
        // （1）读取核心配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // （2）创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // （3）SqlSessionFactoryBuilder对象获取SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(is);
        // （4）SqlSessionFactory对象获取SqlSession对象
        session = factory.openSession();
        // （5）SqlSession对象获取代理对象
        userMapper = session.getMapper(UserMapper.class);
    

    //后置方法，释放资源
    @After
    public void after() throws Exception 
        System.out.println("后置方法执行·············");
        session.close();
        is.close();
    
    // 测试查询所有用户的方法
    @Test
    public void testFindAll() throws Exception
        // 代理对象执行方法
        List<User> all = userMapper.findAll();
        all.forEach(System.out::println);

4. 运行结果

OK，下面我们来详细解释一下前置方法，前置方法也是MyBatis核心对象和工作流程

二、MyBatis核心对象及工作流程

1. MyBatis核心对象

SqlSessionFactoryBuilder

SqlSession工厂构建者对象，使用构造者模式创建SqlSession工厂对象。

SqlSessionFactory

SqlSession工厂，使用工厂模式创建SqlSession对象。

SqlSession

该对象可以操作数据库，也可以使用动态代理模式创建持久层接口的代理对象操作数据库。

Mapper

持久层接口的代理对象，他具体实现了持久层接口，用来操作数据库。

2. MyBatis工作流程

创建SqlSessionFactoryBuilder对象

SqlSessionFactoryBuilder对象构建了SqlSessionFactory对象：构造者模式

SqlSessionFactory对象生产了SqlSession对象：工厂模式

SqlSession对象创建了持久层接口的代理对象：动态代理模式

代理对象操作数据库

3. 使用SqlSession操作数据库

除了代理对象能够操作数据库，SqlSession也能操作数据库。只是这种方式在开发中使用的较少，接下来我们使用SqlSession操作数据库：

// SqlSession直接操作数据库
    List<User> users = session.selectList("com.itbaizhan.mapper.UserMapper.findAll");
    users.forEach(System.out::println);

这样也可以的，上面的是我们用的是调用接口方法执行。

三、添加其他常见方法

1. Mybatis新增用户

持久层添加新增用户方法

// 添加用户
    void add(User user);

映射文件新增标签

    <insert id="add" parameterType="com.mybatisstudy.pojo.User">
        insert into user(username,sex,address) values(#username,#sex,#address)
    </insert>

在测试类新增方法测试一下

注意：这里一定要执行提交事务方法

// 测试新增用户方法
    @Test
    public void testAdd() throws Exception 
        User user = new User("programmer","man","ShangHai");
        userMapper.add(user);

        //提交事务
        session.commit();

2. Mybatis用户更改

持久层添加用户信息更改方法

// 更新用户
    void update(User user);

映射文件新增标签

    <update id="update" parameterType="com.mybatisstudy.pojo.User">
        update user set
        username = #username,
        sex = #sex,
        address = #address
        where id = #id
    </update>

在测试类新增方法测试一下

注意：这里一定要执行提交事务方法

// 测试更新用户方法
    @Test
    public void testUpdate() throws Exception
        User user = new User(7,"programmer_1","woman","Shenzhen");
        userMapper.update(user);

        //提交事务
        session.commit();

3. Mybatis删除用户

持久层添加删除用户方法

// 删除用户
    void delete(int userId);

映射文件新增标签

    <delete id="delete" parameterType="int">
        delete from user where id = #id
    </delete>

在测试类新增方法测试一下

注意：这里一定要执行提交事务方法

// 测试删除用户方法
    @Test
    public void testDelete() throws Exception
        int userId = 7;
        userMapper.delete(userId);

        // 提交事务
        session.commit();

4. Mybatis根据用户id查询

持久层添加删除用户方法

// 根据ID查询用户
    User findById(int userId);

映射文件新增标签

    <select id="findById" parameterType="int" resultType="com.mybatisstudy.pojo.User">
        select * from user where id = #id
    </select>

在测试类新增方法测试一下

注意：这里一定要执行提交事务方法

// 测试根据用户查询Id
    @Test
    public void testFindById() throws Exception
        int userId = 1;
        User user = userMapper.findById(userId);

        System.out.println(user);

OK，本次Mybatis入门案例就写到这里了，感谢大家的认真浏览到这里的小伙伴，如果觉得觉得对你有帮助就三连支持一下吧！

Mybatis的多对多映射

一、Mybatis的多对多映射

　　本例讲述使用mybatis开发过程中常见的多对多映射查询案例。只抽取关键代码和mapper文件中的关键sql和配置，详细的工程搭建和Mybatis详细的流程代码可参见《Mybatis入门和简单Demo》和《Mybatis的CRUD案例》

　　完整的工程代码已上传至https://files.cnblogs.com/files/jiyukai/MyBatis.zip

　　案例：查询xx同学所选择的多个不同选修课，查询xx选修课被多少同学选修

　　步骤1.建表脚本，分别创建学生表，课程表，以及学生课程表，作为学生关系到课程的中间关联表。

create table students(
    sid int(5) primary key,
    sname varchar(10)
);
create table courses(
    cid int(5) primary key,
    cname varchar(10)
);
create table course_stu(
    sid int(5),
    cid int(5),
    primary key(sid,cid)    
);
insert into students(sid,sname) values(1,\'cat\');
insert into students(sid,sname) values(2,\'dog\');
insert into courses(cid,cname) values(1,\'java\');
insert into courses(cid,cname) values(2,\'net\');
insert into course_stu(sid,cid) values(1,1);
insert into course_stu(sid,cid) values(1,2);
insert into course_stu(sid,cid) values(2,1);
insert into course_stu(sid,cid) values(2,2);

　　步骤2.编写课程和学生实体类，学生可选择多门课程，课程中有多个学生，因此在各自的实体类中都以集合的形式引入对方

package com.jyk.mybatis.moreTomore;

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

public class Course {
    private Integer id;                        //课程id
    private String name;                    //课程名称
    private List<Student> studentList = new ArrayList<Student>();    //对应的学生名称
    public Course(){}
    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 List<Student> getStudentList() {
        return studentList;
    }
    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
}

package com.jyk.mybatis.moreTomore;

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

public class Student {
    private Integer id;                //学生id
    private String name;            //学生姓名
    private List<Course> courseList = new ArrayList<Course>();   //选修的课程
    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 List<Course> getCourseList() {
        return courseList;
    }
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
}

　　步骤3.编写mapper文件，在CourseMapper.xml中编写课程信息表字段与实体属性的映射关系，在StudentMapper.xml中编写学生实体和表字段的映射关系，并编写好根据学生姓名查询所有选修课程，以及根据选修课名称查询有多少学生的SQL，并将mapper文件和对应实体类的别名加入mybatis.xml（mybatis.xml的描述见Mybatis系列第一篇博客，此处由于配置type时指定了类的全路径，故无需将别名加入至mybatis.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="studentNamespace">
    <resultMap type="com.jyk.mybatis.moreTomore.Student" id="studentMap">
        <id property="id" column="sid" />
        <result property="name" column="sname"/>
    </resultMap>
    
    <!-- 查询java课程有哪些学生 -->
    <select id="findStudentByName" parameterType="string" resultMap="studentMap">
        select s.sid,s.sname
        from students s,course_stu m,courses c
        where s.sid = m.sid 
        and m.cid = c.cid
        and c.cname = #{name}
    </select>
</mapper>

<?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="courseNamespace">
    <resultMap type="com.jyk.mybatis.moreTomore.Course" id="courseMap">
        <id property="id" column="cid" />
        <result property="name" column="cname"/>
    </resultMap>
    
    <!-- 查询cat选学的课程 -->
    <select id="findCourseByName" parameterType="string" resultMap="courseMap">
        select c.cid,c.cname
        from students s,course_stu m,courses c
        where s.sid = m.sid 
        and m.cid = c.cid
        and s.sname = #{name}
    </select>
</mapper>

<?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">
    </properties>
    
    <!-- 设置类型别名 -->
    <typeAliases>

    </typeAliases>

    <!-- 设置一个默认的连接环境信息 -->
    <environments default="mysql_env">
        <!-- 连接环境信息，取一个唯一的编号 -->
        <environment id="mysql_env">
            <!-- mybatis使用的jdbc事务管理方式 -->
            <transactionManager type="jdbc">
            </transactionManager>
            
            <!-- mybatis使用连接池方式来获取链接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的四个属性 -->
                <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>
    </environments>
    
    <mappers>
        <mapper resource="com/jyk/mybatis/moreTomore/CourseMapper.xml"/>
        <mapper resource="com/jyk/mybatis/moreTomore/StudentMapper.xml"/>
    </mappers>
    
</configuration>

　　步骤4.编写Java代码实现该多对多查询，需要注意的是，区分于一对一查询，此处由于查询的结果有多个，是集合的形式返回，故查询的API应使用SqlSession提供的selectList接口而不再是selectOne。

package com.jyk.mybatis.moreTomore;

import java.util.List;
import org.apache.ibatis.session.SqlSession;

import com.jyk.mybatis.util.MyBatisUtil;

public class StudentCourseDao {
    /**
     * 查询cat选学的课程
     */
    public List<Course> findCourseByName(String name) throws Exception{
        SqlSession sqlSession = null;
        try{
            sqlSession = MyBatisUtil.getSqlSession();
            return sqlSession.selectList("courseNamespace.findCourseByName",name);
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            MyBatisUtil.closeSqlSession();
        }
    }
    /**
     * 查询java课程有哪些学生
     */
    public List<Student> findStudentByName(String name) throws Exception{
        SqlSession sqlSession = null;
        try{
            sqlSession = MyBatisUtil.getSqlSession();
            return sqlSession.selectList("studentNamespace.findStudentByName",name);
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            MyBatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception{
        StudentCourseDao dao = new StudentCourseDao();
        List<Course> courseList = dao.findCourseByName("cat");
        for(Course c : courseList){
            System.out.println(c.getId()+":"+c.getName());
        }
        /*List<Student> studentList = dao.findStudentByName("java");
        for(Student s : studentList){
            System.out.println(s.getId()+":"+s.getName());
        }*/
    }     
}

以上是关于Mybatis入门案例超详细的主要内容，如果未能解决你的问题，请参考以下文章