Mybatis框架学习3【数据库查询】

最新推荐文章于 2024-01-15 09:57:27 发布

iheanu_

最新推荐文章于 2024-01-15 09:57:27 发布

阅读量173

点赞数 2

文章标签：数据库 sql mybatis

本文链接：https://blog.csdn.net/m0_52155263/article/details/120329623

版权

本文详细介绍了MyBatis的配置文件，包括数据库连接信息、类型别名、环境配置和映射文件位置。接着，通过示例展示了如何进行一对一、一对多和多对多的查询操作，包括对应的XML配置和测试用例。涉及到的实体类有User、Account和Role，以及它们之间的关联关系。测试用表包括new_user、account和role，以及它们之间的映射关系。

摘要由CSDN通过智能技术生成

配置文件

<?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">
<!--mybatis的主配置文件-->
<configuration>

    <properties resource="jdbcConfig.properties"/>

    <typeAliases><!--用于配置类的别名  type是原类名，alias是别名，当指定了别名，就不在区分大小写-->
        <typeAlias type="com.yz.domain.Account" alias="Account"></typeAlias>
        <!--第二种-->
        <!--<package name="com.yz.dao"/>
        写上后，类名即是别名，不用再写全类名了
        typeAliases下的package用于指定实体类
        -->
    </typeAliases>

    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--连接数据库的相关信息-->
                <!--第一种写法-->
                <!--
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/db_1?&amp;useSSL=false&amp;serverTimezone=UTC&amp;characterEncoding=utf8&amp;characterSetResults=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="yz021014"/>  -->
                <!--第二种写法-->
                <!--environments前面加上<properties resource="jdbcConfig.properties"></properties>-->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--指定映射配置文件的位置，映射配置文件指每个dao独立的配置文件-->
    <mappers>
        <!--1.如果为resource为基于xml的配置方式-->
        <mapper resource="com/yz/dao/AccountDaoImp.xml"/><!--这里如果写为com.yz.dao.UserDaoImp.xml的形式会导致idea找不到相应的文件，因为在resources内文件都以目录形式存在而不是包-->
        <!--2.如果为基于class注解的配置方式-->
        <!--<mapper class="com.yz.dao.UserDaoImp"></mapper>-->
        
        <!--3.如果为基于package注解的配置方式-->
        <!--<package name="com/yz/dao"/>-->
        <!-- 用于指定dao接口所在的包，指定后便无需写resource或class来指定接口了-->
        <mapper resource="com/yz/dao/UserDaoImp.xml"/>
        <mapper resource="com/yz/dao/RoleDaoImp.xml"/>
    </mappers>
</configuration>

测试用表

在这里我们使用new_user表（由于本人数据库中已经有了一个user表，所以起名为new_user），account表，角色表，进行操作。

new_user表:

对应的user类：

package com.yz.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    //用于账户查询
    private List<Account> accounts;
    //用于角色查询
    private List<Role> userRoles;

     /**
     * 为节省空间,GetSet方法已省略
     *注意：在生成toString()时，accounts和userRoles属性可省去
     */

}

account表:

对应account类：

package com.yz.domain;

import java.io.*;

public class Account {
    private Integer id;
    private Integer uid;
    private Double money;
    private User user;

}

role表：

对应的role类：

package com.yz.domain;

public class Role {
    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：一个角色可以赋值多个用户
    private List<User> users;

}

中间表：

一对一查询

【场景举例：比如一个账户对应一个人】

步骤

两个表：用户表，账户表
两个实体类：用户类，账户类
UserDao接口的xml配置文件
实现配置，在相应的测试类中实现具体方法

在accountDao接口中创建一个findAll方法，在其对应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.yz.dao.AccountDaoImp">

    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUserMap" type="com.yz.domain.Account">
        <id property="id" column="aid"></id><!--由于不能由重复列名出现，所以account中的id列要起个别名-->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--一对一的关系映射，配置封装user的内容-->
        <association property="user" column="uid" javaType="com.yz.domain.User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </association>
    </resultMap>
    
    <select id="findAll" resultMap="accountUserMap">
        select u.*,a.id as aid, a.uid, a.money
        from account a,
             new_user u
        where u.id = a.uid
    </select>
</mapper>

测试类：

import com.yz.dao.AccountDaoImp;
import com.yz.domain.Account;
import com.yz.domain.AccountUser;
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.*;
import java.util.List;

public class AccountTest {
    private InputStream in;
    private SqlSession sqlSession;
    private AccountDaoImp accountDaoImp;

    @Before
    public void init() throws IOException {
        //1.读取配置文件
        in= Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        //3.使用工程生成sqlSession对象
        sqlSession= factory.openSession();

        //4.使用SqlSession创建Dao接口的代理对象
        accountDaoImp=sqlSession.getMapper(AccountDaoImp.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务,一般用于对数据库信息进行修改后使用，否则数据无法保存
        sqlSession.commit();//也可在init中添加factory.openSession(true);设为自动提交
        //释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有账户信息
     */
    @Test
    public void testFindAll(){
        //5.使用代理对象执行方法
        List<Account> accounts= accountDaoImp.findAll();
        for (Account account:accounts
        ) {
            System.out.println(account);

        }
    }
}

一对多查询

【场景举例：比如一个人有多个账户】

步骤

两个表：用户表，账户表
两个实体类：用户类，账户类
UserDao接口的xml配置文件
实现配置，在相应的测试类中实现具体方法

在userDao接口中创建一个findAll方法，在其对应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.yz.dao.UserDaoImp"><!--这里的namespace对于Dao中接口的位置-->
 <!--定义User的resultMap-->
    <resultMap id="userAccountMap" type="com.yz.domain.User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <!--配置user对象中accounts集合的映射-->
        <collection property="accounts" ofType="com.yz.domain.Account">
            <id column="aid" property="id"></id>
            <result column="uid" property="uid"></result>
            <result column="money" property="money"></result>
        </collection>
    </resultMap>

<!--由于我们要体现一对多的关系，所以要历遍user中的所以，且对于每个user查到对应的account信息（account信息不唯一，mybatis会自动把同一user的account整合在一起）-->
    <select id="findAll" resultMap="userAccountMap"><!--这里必须注意要指定查询结果的封装对象resultType-->
        SELECT *
        from new_user u
                 left outer join account a on u.id = a.uid
    </select>
</mapper>

测试类：

import com.yz.dao.UserDaoImp;
import com.yz.domain.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.*;
import java.util.Date;
import java.util.List;

public class MybatisTest {
    private InputStream in;
    private SqlSession sqlSession;
    private UserDaoImp userDao;

    @Before
    public void init() throws IOException {
        //1.读取配置文件
        in= Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        SqlSessionFactory factory=builder.build(in);
        //3.使用工程生成sqlSession对象
        sqlSession= factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        userDao=sqlSession.getMapper(UserDaoImp.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务,一般用于对数据库信息进行修改后使用，否则数据无法保存
        sqlSession.commit();//也可在init中添加factory.openSession(true);设为自动提交
        //释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        //5.使用代理对象执行方法
        List<User> users=userDao.findAll();
        for (User user:users
             ) {
            System.out.println(user+"     "+user.getAccounts());
        }
    }
}

多对多查询

【场景举例：比如一个人扮演着多个角色，一个角色可以赋予多个人】

步骤

三个表：用户表，角色表，中间表
两个实体类：用户类，角色类
两个xml配置文件
实现配置，在相应的测试类中实现具体方法

在roleDao接口中创建一个findAll方法，在其对应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.yz.dao.RoleDaoImp">
    <resultMap id="roleMap" type="com.yz.domain.Role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="com.yz.domain.User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>
    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
        select u.*, r.id as rid, r.role_name, r.role_desc
        from role r
                 left outer join user_role ur on r.id = ur.rid
                 left outer join new_user u on u.id = ur.uid
    </select>

</mapper>

在userDao接口中创建一个findAllRoles方法，在其对应xml约束文件中进行配置：

  <resultMap id="userRoleMap" type="com.yz.domain.User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <!--配置user对象中accounts集合的映射-->
        <collection property="userRoles" ofType="com.yz.domain.Role"><!--这里的property对应user类的成员变量-->
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>
    <select id="findAllRoles" resultMap="userRoleMap">
        select u.*, r.id as rid, r.role_name, r.role_desc
        from new_user u
                 left outer join user_role ur on u.id = ur.uid
                 left outer join role r on r.id = ur.rid
    </select>

最后在测试写入相关方法，验证是否成功。

其实现的效果应该是：当我们用roleDao接口的findAll()方法时，可以在每个角色后可以看到扮演的用户；当我们用userDao接口的findAllRoles()方法时，可以在每个用户后面看到对应的角色。