MyBatis基础

最新推荐文章于 2024-04-14 09:10:31 发布

程序服务个体户

最新推荐文章于 2024-04-14 09:10:31 发布

阅读量211

点赞数

分类专栏： Mybatis java基础文章标签： mybatis mysql java

本文链接：https://blog.csdn.net/Mas1461261388/article/details/115624645

版权

java基础同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

Mybatis

1 篇文章 0 订阅

订阅专栏

配置：

MyBatisConfigs.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/db4?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
        <mappers>
            <mapper resource="StudentMapper.xml"/>
        </mappers>
</configuration>

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="StudentMapper">
    <!--
     select：查询功能的标签
     id属性：唯一标识
     resultType属性：指定结果映射对象类型
     parameterType属性：指定参数映射对象类型
 -->
    <select id="SelectAll" resultType="com.MyBatisItem.beans.Student">
        SELECT * FROM student
    </select>
</mapper>

student.java

package com.MyBatisItem.beans;

public class Student {

    private Integer sid;
    private String name;
    private Integer age;

    public Student(){
    }

    public Student(Integer sid, String name, Integer age) {
        this.sid = sid;
        this.name = name;
        this.age = age;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

StudentTest01

import com.MyBatisItem.beans.Student;
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.Test;

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

public class StudentTest01 {

    @Test
    public void SelectAll() throws Exception{
        //1.加载核心配置文件
        //InputStream inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
        InputStream inputStream =  StudentTest01.class.getClassLoader().getResourceAsStream("MyBatisConfigs.xml");
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.执行映射配置文件中的sql语句，并接收结果
        List<Student> list = sqlSession.selectList("StudentMapper.SelectAll");
        //5.提交事务
        
        //6.处理结果
        for (Student student : list){
            System.out.println(student);
        }
        //7.释放资源
        sqlSession.close();
        inputStream.close();
    }
}

Mybatis进阶

MyBatisConfigs.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>
    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
    <!--起别名-->
    <typeAliases>
        <typeAlias type="com.MyBatisItem.beans.Student" alias="student"/>
        <!--<package name="com.itheima.bean"/>-->
    </typeAliases>
    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>
    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>
    <!--起别名-->
    <typeAliases>
        <typeAlias type="com.MyBatisItem.beans.Student" alias="student"/>
        <!--<package name="com.itheima.bean"/>-->
    </typeAliases>
    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

StudentMapper.java

import com.MyBatisItem.beans.Student;
import java.util.List;

public interface StudentMapper {

    //查询全部
    public abstract List<Student> selectAll();

    //根据id查询 
    public abstract Student selectBySid(Integer sid);

    //新增数据 
    public abstract Integer insert(Student stu);

    //修改数据 
    public abstract Integer update(Student stu);

    //删除数据 
    public abstract Integer delete(Integer sid);

    //多条件查询 
    public abstract List<Student> selectCondition(Student stu);

    //根据多个id查询 
    public abstract List<Student> selectBySids(List<Integer> sid);
}

StudentService.java

import com.MyBatisItem.beans.Student;

import java.io.IOException;
import java.util.List;

public interface StudentService {

    public abstract List<Student> SelectAll();

    public abstract Student SelectBySid(Integer sid);

    public abstract Integer update(Student student);

    public abstract Integer insert(Student student);

    public abstract Integer deleteBySid(Integer sid) throws IOException;

    public abstract List<Student> selectByIds( Integer[] stuIds ) throws IOException;

    public abstract List<Student> selectCondition(Student student) throws IOException;
}

StudentServiceImpl.java

import com.MyBatisItem.beans.Student;
import com.MyBatisItem.mapper.StudentMapper;
import com.MyBatisItem.service.StudentService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
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.Test;

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

public class StudentServiceImpl implements StudentService {

    @Override
    public List<Student> SelectAll() {
        List<Student> list = new ArrayList<>();
        InputStream inputStream = null;
        SqlSession sqlSession = null;
        try {
            //1.加载核心配置文件
            inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");

            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory  = new SqlSessionFactoryBuilder().build(inputStream);

            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

            //5.通过实现类对象调用方法，接收结果
            list = studentMapper.selectAll();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (sqlSession!=null) {sqlSession.close();}
                if (inputStream!=null) {inputStream.close();}
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    @Override
    public Student SelectBySid(Integer sid) {
        Student student = new Student();
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        try {
            //1.加载核心配置文件
            inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");

            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory  = new SqlSessionFactoryBuilder().build(inputStream);

            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);

            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

            //5.通过实现类对象调用方法，接收结果
            student = studentMapper.selectBySid(sid);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (sqlSession!=null) {sqlSession.close();}
                if (inputStream!=null) {inputStream.close();}
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return student;

    }

    @Override
    public Integer update(Student student) {
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        int result = 0;
        try {
            inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");

            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

            sqlSession = sqlSessionFactory.openSession(true);

            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);

            result = studentMapper.update(student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (sqlSession!=null) {sqlSession.close();}
                if (inputStream!=null) {inputStream.close();}
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    @Override
    public Integer insert(Student student) {
        SqlSession sqlSession= null;
        InputStream inputStream  = null;

        int result = 0;
        try {
            inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession = sqlSessionFactory.openSession(true);

            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
            result = studentMapper.insert(student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (sqlSession!=null) {sqlSession.close();}
                if (inputStream!=null) {inputStream.close();}
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public Integer deleteBySid(Integer sid) throws IOException {
        SqlSession sqlSession= null;
        InputStream inputStream  = null;

        inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        int res = studentMapper.delete(sid);

        try {
            if (sqlSession!=null) {sqlSession.close();}
            if (inputStream!=null) {inputStream.close();}
        } catch (Exception e) {
            e.printStackTrace();
        }

        return res;
    }

    @Override
    public List<Student> selectByIds( Integer[] stuIds ) throws IOException {
        int i=0;
        SqlSession sqlSession= null;
        InputStream inputStream  = null;

        inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        List<Integer> list= new ArrayList<>();
        while (stuIds.length>i){ list.add(stuIds[i++]); }

        List<Student> studentList = studentMapper.selectBySids(list);

        try {
            if (sqlSession!=null) {sqlSession.close();}
            if (inputStream!=null) {inputStream.close();}
        } catch (Exception e) { e.printStackTrace(); }

        return studentList;
    }

    @Override
    public List<Student> selectCondition(Student student) throws IOException {
        SqlSession sqlSession= null;
        InputStream inputStream  = null;

        inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper studentMapper =sqlSession.getMapper(StudentMapper.class);

        student.setSid(student.getSid());
        student.setName(student.getName());

        //5.调用实现类的方法，接收结果
        List<Student> list = studentMapper.selectCondition(student);
        try {
            if (sqlSession!=null) {sqlSession.close();}
            if (inputStream!=null) {inputStream.close();}
        } catch (Exception e) { e.printStackTrace(); }
        return list;
    }

    @Test
    public void selectPaging() throws Exception {

        SqlSession sqlSession= null;
        InputStream inputStream  = null;

        inputStream = Resources.getResourceAsStream("MyBatisConfigs.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sqlSessionFactory.openSession(true);
        StudentMapper studentMapper =sqlSession.getMapper(StudentMapper.class);
        List<Student> list = studentMapper.selectAll();

        PageInfo<Student> studentPageInfo = new PageInfo<>(list);

        //通过分页助手来实现分页功能
        // 第一页：显示3条数据
        //PageHelper.startPage(1,3);
        // 第二页：显示3条数据
        //PageHelper.startPage(2,3);
        // 第三页：显示3条数据
        PageHelper.startPage(1,3);
        //6.处理结果
        for (Student student : list) {
            System.out.println(student);
        }

        PageInfo<Student> info = new PageInfo<>(list);
        System.out.println("总条数：" + info.getTotal());
        System.out.println("总页数：" + info.getPages());
        System.out.println("当前页：" + info.getPageNum());
        System.out.println("每页显示条数：" + info.getPageSize());
        System.out.println("上一页：" + info.getPrePage());
        System.out.println("下一页：" + info.getNextPage());
        System.out.println("是否是第一页：" + info.isIsFirstPage());
        System.out.println("是否是最后一页：" + info.isIsLastPage());
    }
}

StudentController.java

import com.MyBatisItem.beans.Student;
import com.MyBatisItem.service.StudentService;
import com.MyBatisItem.service.impl.StudentServiceImpl;
import org.junit.Test;

import java.io.IOException;
import java.util.List;

public class StudentController {
    StudentService studentService = new StudentServiceImpl();

    @Test
    public void selectAll(){
        List<Student> list = studentService.SelectAll();
        for (Student st : list) {
            System.out.println(st);
        }
    }

    @Test
    public void selectBySid(){
        Student student = studentService.SelectBySid(2);
        System.out.println(student);
    }

    @Test
    public void update(){
        Student student = new Student(5,"老王",55);
        int a = studentService.update(student);
        System.out.println(a);
    }

    @Test
    public void insert(){
        Student student = new Student(6,"老lao王",59);
        int a = studentService.insert(student);
        System.out.println(a);
    }

    @Test
    public void delete() throws IOException {
        int a = studentService.deleteBySid(6);
        System.out.println(a);
    }

    @Test
    public void selectByIds() throws IOException {
        Integer[] a={1,2,3,4};
        List<Student> studentList = studentService.selectByIds(a);
        for (Student student :studentList){
            System.out.println(student);
        }
    }

    @Test
    public void selectCondition()throws IOException{
        Student student = new Student(5,"老王",77);
        List<Student> list = studentService.selectCondition(student);
        for (Student student1 :list){
            System.out.println(student1);
        }
    }
}

--------------------------------------------------------------------------------

MyBatis高阶

数据准备：创建数据库并建立以下数据

一对一数据：

CREATE TABLE person(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20),
	age INT
);
INSERT INTO person VALUES (NULL,'张三',23);
INSERT INTO person VALUES (NULL,'李四',24);
INSERT INTO person VALUES (NULL,'王五',25);

CREATE TABLE card(
	id INT PRIMARY KEY AUTO_INCREMENT,
	number VARCHAR(30),
	pid INT,
	CONSTRAINT cp_fk FOREIGN KEY (pid) REFERENCES person(id)
);
INSERT INTO card VALUES (NULL,'12345',1);
INSERT INTO card VALUES (NULL,'23456',2);
INSERT INTO card VALUES (NULL,'34567',3);

一对多数据准备：

CREATE TABLE classes(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20)
);
INSERT INTO classes VALUES (NULL,'黑马一班');
INSERT INTO classes VALUES (NULL,'黑马二班');


CREATE TABLE student(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(30),
	age INT,
	cid INT,
	CONSTRAINT cs_fk FOREIGN KEY (cid) REFERENCES classes(id)
);
INSERT INTO student VALUES (NULL,'张三',23,1);
INSERT INTO student VALUES (NULL,'李四',24,1);
INSERT INTO student VALUES (NULL,'王五',25,2);
INSERT INTO student VALUES (NULL,'赵六',26,2);

多对多数据准备

CREATE TABLE stu_cr(
	id INT PRIMARY KEY AUTO_INCREMENT,
	sid INT,
	cid INT,
	CONSTRAINT sc_fk1 FOREIGN KEY (sid) REFERENCES student(id),
	CONSTRAINT sc_fk2 FOREIGN KEY (cid) REFERENCES course(id)
);
INSERT INTO stu_cr VALUES (NULL,1,1);
INSERT INTO stu_cr VALUES (NULL,1,2);
INSERT INTO stu_cr VALUES (NULL,2,1);
INSERT INTO stu_cr VALUES (NULL,2,2);

建立映射类

ManyToManyMapper.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.Table.Table_Test3.ManyToManyMapper">
    <resultMap id="ManyToMany" type="student">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>

        <collection property="courses" ofType="course">
            <id column="cid" property="id"/>
            <result column="cname" property="name"/>
        </collection>
     </resultMap>
    <select id="selectAll" resultMap="ManyToMany">
        SELECT sc.sid,s.name sname,s.age sage,sc.cid,c.name cname
        FROM student s,course c,stu_cr sc
        WHERE sc.sid=s.id AND sc.cid=c.id
    </select>
</mapper>

OneToManyMapper.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.Table.Table_Test2.OneToManyMapper">
    <resultMap id="OneToMany" type="classes">
        <id column="cid" property="id"/>
        <result column="cname" property="name"/>

        <!--
            collection：配置被包含的集合对象映射关系
            property：被包含对象的变量名
            ofType：被包含对象的实际数据类型
        -->

        <collection property="students" ofType="student">
            <id column="sid" property="id"/>
            <result column="sname" property="name"/>
            <result column="sage" property="age"/>
        </collection>
    </resultMap>
    
    <select id="selectAll" resultMap="OneToMany">
        select  s.id sid, s.name sname, s.age sage , c.id cid, c.name cname
        from student s, classes c
        where s.id = c.id
    </select>
</mapper>

OneToManyMapper.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.Table.Table_Test1.OneToOneMapper">
    <!--配置字段和实体对象属性的映射关系-->
    <resultMap id="OnToOne" type="card">
        <id column="cid" property="id"/>
        <result column="number" property="number"/>
        <!--
            association：配置被包含对象的映射关系
            property：被包含对象的变量名
            javaType：被包含对象的数据类型
        -->
        <association property="p" javaType="person">
            <id column="pid" property="id" />
            <result column="name" property="name" />
            <result column="age" property="age" />
        </association>
    </resultMap>
    <select id="selectAll" resultMap="OnToOne">
         SELECT c.id cid,number,pid,NAME,age FROM card c,person p WHERE c.pid=p.id
    </select>
</mapper>

MyBatisConfigs2.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>
    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc2.properties"/>
    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <typeAliases>
        <package name="com.Table.bean"/>
    </typeAliases>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="com/Table/One_To_One/OneToOneMapper.xml"/>
        <mapper resource="com/Table/One_To_Many/OneToManyMapper.xml"/>
        <mapper resource="com/Table/Many_To_Many/ManyToManyMapper.xml"/>
    </mappers>
</configuration>

jdbc2.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db9?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username=root
password=123456

OneToOneMapper

import com.Table.bean.Card;
import java.util.List;

public interface OneToOneMapper {
    public abstract List<Card> selectAll();
}

OneToOneMapperTest1

import com.Table.bean.Card;
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.Test;

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

public class OneToOneTest1 {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfigs2.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        //4.获取OneToOneMapper接口的实现类对象
        OneToOneMapper oneToOneMapper = sqlSession.getMapper(OneToOneMapper.class);

        //5.调用实现类的方法，接收结果
        List<Card> list = oneToOneMapper.selectAll();
        for (Card l:list){ System.out.println(l); }
        inputStream.close();
        sqlSession.close();
    }
}

OneToManyMapper

import com.Table.bean.Classes;
import java.util.List;

public interface OneToManyMapper {
    //查询全部
    public abstract List<Classes> selectAll();
}

OneToManyMapperTest1

import com.Table.bean.Classes;
import com.Table.bean.Student;
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.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class OneToManyTest1 {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfigs2.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        //4.获取OneToOneMapper接口的实现类对象
        OneToManyMapper oneToManyMapper = sqlSession.getMapper(OneToManyMapper.class);

        //5.调用实现类的方法，接收结果
        List<Classes> classesList = oneToManyMapper.selectAll();

        for (Classes cls:classesList){
            System.out.println(cls.getId() + "," + cls.getName());
            List<com.Table.bean.Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }
        inputStream.close();
        sqlSession.close();
    }
}

ManyToManyMapper

import com.Table.bean.Student;
import java.util.List;

public interface ManyToManyMapper {
    public abstract List<Student> selectAll();
}

ManyToManyMapperTest1

import com.Table.bean.Student;
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.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class ManyToManyTest1 {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;
        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfigs2.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        //4.获取ManyToOneMapper接口的实现类对象
        ManyToManyMapper manyToManyMapper = sqlSession.getMapper(ManyToManyMapper.class);
        List<Student> studentList = manyToManyMapper.selectAll();
        for (Student s: studentList){
            System.out.println(s);
        }
        inputStream.close();
        sqlSession.close();
    }
}

MyBatis注解多表操作

（映射类依然和前面一样）

CardMapper

import com.MutiTable.bean.Card;
import com.MutiTable.bean.Person;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface CardMapper {
    @Select("SELECT * FROM card")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
                    property = "p",             // 被包含对象的变量名
                    javaType = Person.class,    // 被包含对象的实际数据类型
                    column = "pid",             // 根据查询出的card表中的pid字段来查询person表
                     /*
                        one、@One 一对一固定写法
                        select属性：指定调用哪个接口中的哪个方法
                     */
                    one = @One(select = "com.MutiTable.OneToOne.PersonMapper.selectById")
            )
    })
    public abstract List<Card> selectAll();
}

PersonMapper

import com.MutiTable.bean.Person;
import org.apache.ibatis.annotations.Select;

public interface PersonMapper {
    //根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person selectById(Integer id);

}

Test_One_To_One

import com.MutiTable.bean.Card;
import com.MutiTable.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 org.junit.Test;

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

public class Test_One_To_One {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        //4.获取OneToOneMapper接口的实现类对象
        CardMapper cardMapper = sqlSession.getMapper(CardMapper.class);
        List<Card> cards = cardMapper.selectAll();
        for (Card c:cards){
            System.out.println(c);
        }
        //7.释放资源
        sqlSession.close();
        inputStream.close();
    }
}

Classes

import com.MutiTable.bean.Classes;
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface ClassesMapper {
    //查询全部
    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",  // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出的classes表的id字段来查询student表
                    /*many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法*/
                    many = @Many(select = "com.MutiTable.OneToMany.StudentMapper.selectByCid")
            )})
    public abstract List<Classes> selectAll();
}

Student

import com.MutiTable.bean.Student;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface StudentMapper {
    //根据cid查询student表
    @Select("select * from student where cid=#{cid}")
    public abstract List<Student> selectByCid(Integer cid);
}

TestOneToMany

import com.MutiTable.bean.Classes;
import com.MutiTable.bean.Student;
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.Test;

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

public class TestOneToMany {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;

        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        ClassesMapper classesMapper = sqlSession.getMapper(ClassesMapper.class);

        List<Classes> classes = classesMapper.selectAll();

        for (Classes cls : classes) {
            System.out.println(cls.getId() + "," + cls.getName());
            List<Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }
        //7.释放资源
        sqlSession.close();
        inputStream.close();
    }
}

CoursesMapper

import com.MutiTable.bean.Course;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface CourseMapper {
    //根据学生id查询所选课程
    @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}")
    public abstract List<Course> selectBySid(Integer id);
}

StudentMapper

import com.MutiTable.bean.Student;
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface StudentMapper {
    //查询全部
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
    @Results({
            @Result(column = "id", property = "id"),
            @Result(column = "name", property = "name"),
            @Result(column = "age", property = "age"),
            @Result(
                    property = "courses",   // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出student表的id来作为关联条件，去查询中间表和课程表
                    /*many、@Many 一对多查询的固定写法
                       select属性：指定调用哪个接口中的哪个查询方法*/
                    many = @Many(select = "com.MutiTable.ManyToMany.CourseMapper.selectBySid")
            )})
    public abstract List<Student> selectAll();
}

TestManyToMany

import com.MutiTable.bean.Course;
import com.MutiTable.bean.Student;
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.Test;

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

public class TestManyToMany {
    @Test
    public void selectAll() throws IOException {
        InputStream inputStream = null;
        SqlSession sqlSession = null;
        //1.加载核心配置文件
        inputStream = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //3.通过工厂对象获取SqlSession对象
        sqlSession = sqlSessionFactory.openSession(true);

        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = studentMapper.selectAll();
        //6.处理结果
        for (Student student : studentList) {
            System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println("\t" + cours);
            }
        }
        //7.释放资源
        sqlSession.close();
        inputStream.close();
    }
}

程序服务个体户

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MyBatis基础

配置：MyBatisConfigs.xml<?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>...
复制链接

扫一扫