Mybaties

最新推荐文章于 2024-08-21 23:39:15 发布

天线短路宝宝529

最新推荐文章于 2024-08-21 23:39:15 发布

阅读量104

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_56024630/article/details/133163424

版权

概述

Mybatis是个基于java语⾔的持久层的框架，主要用来简化数据库的访问操作,内部封装了原来的jdbc代码,替换了原有项目开发中的jdbc技术,他可以自动完成对象与关系的映射(ORM),极度简化了我们的开发,提高开发效率。

1.1 原始的JDBC操作
谈及mybatis，必然需要先了解Java和数据库的连接技术——JDBC(Java DataBase Connectivity)。但是原始JDBC操作中，却存在如下缺点：

数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能。

sql语句在代码中硬编译，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变Java代码。

查询操作时，需要手动将结果集中的数据手动封装到实体中；插入操作时，需要手动将实体的数据设置到sql语句的占位符位置。

public class JDBCDemo {
    public static void main(String[] args) throws Exception{
        //获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1","root","root");
        //定义sql语句
        String sql = "select * from emp";
        //获取执行sql的对象Statement
        Statement stmt = conn.createStatement();
        //执行sql
        ResultSet resultSet = stmt.executeQuery(sql);
        //处理结果
        while(resultSet.next()) {             
            int id = resultSet.getInt(1);                    //获取id
            String name = resultSet.getString("ename");             //获取姓名
            System.out.println("id:" + id + " name:" + name);
        }
        //释放资源
        stmt.close();
        conn.close();
    }
}
//问题
//1. 大量的代码冗余 (处理结果集的时候存在大量的冗余)
//2. 不能完成数据库和实体的自动转换 (需要手动动封装实体,不能自定封装实体类)

1.2 如何克服JDBC固有缺陷

而面对上述缺点，我们的解决方案是：

使用数据库连接池技术（C3P0或者Druid）初始化连接资源；

将sql语句抽取到xml配置文件中（解耦合）；

使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射（比较困难）。

因此，mybatis应运而生！

1.3 什么是MyBatis

mybatis 是一个优秀的基于java的持久层框架，它内部封装了 jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

mybatis通过xml或注解的方式将要执行的各种 statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。

最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作。

二、MyBatis传统开发步骤

2.1 添加MyBatis的坐标

把mysql和mybatis的坐标引入pom.xml中。

<!--mysql驱动坐标-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
</dependency>

<!--mybatis坐标-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<!--日志坐标-->
<dependency>    
    <groupId>log4j</groupId>    
    <artifactId>log4j</artifactId>    
    <version>1.2.12</version>
</dependency>
<!--单元测试坐标-->
<dependency>    
    <groupId>junit</groupId>    
    <artifactId>junit</artifactId>    
    <version>4.12</version>    
    <scope>test</scope>
</dependency>

2.2 创建一个实体

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

在项目下创建一个User.java的实体。

public class User {
   private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    
    get...
    set...
    
}

开发DAO接口

//用户的持久层接口
public interface IUserDao {

    /**
     * 查询所有操作
     * @return
     */
    List<User> findAll();
}

2.3 编写映射文件

在文件夹resources下再创建一个mapper文件夹，再创建映射文件**UserMapper.xml。**后续我们的sql语句可以全部写到这里。

2.3.1先写一个通用的dtd约束头

<?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.dong.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="com.dong.domain.User">
        select * from user
    </select>
</mapper>

2.4 编写核心文件

配置文件jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db1
jdbc.username=root
jdbc.password=root

核心配置文件mysqlConfig.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">
<!-- mybatis的主配置文件 -->
<configuration>
    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties"/>
    <!--数据源环境-->
    <environments default="mysql">
        <!--配置mysql-->
        <environment id="mysql">
            <!--配置事务类型-->
            <!--取值有两种，JDBC和MANAGED，这里我们使用JDBC-->
            <transactionManager type="JDBC"/>
            <!--配置数据源/连接池-->
            <!--取值有三种，UNPOOLED、POOLED和JNDI-->
            <dataSource type="POOLED">
                <!--配置连接数据库的基本信息-->
                <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>
    <!--加载映射文件-->
    <mappers>
        <!--
		使用相对于类路径的资源引用
			使用xml进行查询
		-->
        <mapper resource="mapper/UserMapper.xml"/>
        <!--使用映射器接口实现类的完全限定类名-->
        <!--<mapper class="com.dong.dao.IUserDao"/>-->
        <!--扫描mapper下所有注解 最常用  将包内的映射器接口实现全部注册为映射器-->
        <package name="com.dong.dao"/>
        
    </mappers>
</configuration>

2.5 测试

2.5.1 编写测试代码

/**
 * 查询
 * @throws IOException
 */
@Test
public void test1() throws IOException {
    //获得核心配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    //获得session工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    //获得session会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行操作 参数：namespace+id
    //List<User> userList = sqlSession.selectList("userMapper.findAll");
     //获取DAO对象
    UserDAO userDAO = sqlSession.getMapper(UserDAO.class);
    List<User> userList = userDAO.findAll();
    //打印数据
    System.out.println(userList);
    //释放资源
    sqlSession.close();
}

SqlSessionFactoryBuilder ：工厂构建器。通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象。

SqlSessionFactory：工厂对象，用来创建sql会话。openSession( )会默认开启一个事务，但事务不会自动提交，也就意味着需要手动提交该事务，更新操作数据才会持久化到数据库中。如果里面传一个参数为true，那么不需要手动提交事务（更新操作中sqlSession.commit()方法就不需要写了）。

SqlSession ：会话对象。执行接下来的增删改查操作。

2.5.2 代码要点

这里我们可以看到，查询数据的一段java代码为：

List<User> userList = sqlSession.selectList("userMapper.findAll");

而这句代码中sqlSession.selectList的参数即我们刚才在UserMapper.xml 中写的代码：

 <select id="findAll" resultType="com.dong.entity.User">
        select * from db1.user
    </select>

同理，我们也可以同样得到添加数据、修改数据和删除数据类似的代码：

添加数据：

sqlSession.insert("userMapper.add", user);

<insert id="add" parameterType="com.dong.entity.User" keyProperty="id" useGeneratedKeys="true">
insert into user values(#{id},#{name},#{age},#{bir})
</insert>

insert：插入操作

id：方法名

parameterType：参数类型

#{对象中的属性名}

useGeneratedKeys：使用数据库自动生成策略，只对mysql数据库有效‘

keyProperty：主键属性

 UserDAO userDAO = sqlSession.getMapper(UserDAO.class);
try {
  User user = new User();
  //user.setId(1);//不设置id使用数据库自动生成id
  user.setName("小王");
  user.setAge(23);
  user.setBir(new Date());
  int count = userDAO.save(user);
  System.out.println("影响的条数: " + count);
  //数据当前保存这条记录id
  System.out.println("本次数据库生成id: "+user.getId());
  sqlSession.commit();//提交事务
} catch (Exception e) {
  e.printStackTrace();
  sqlSession.rollback();//提交事务
} finally {
  sqlSession.close();//释放资源
}

2.5.3 多参数

IUserDao
    public List<User> query(@Param("name") String name,@Param("age") Interge age);

//多参数 省略 parameterType 使用@Param绑定参数
<select id="query" resultType="com.dong.entity.User">
        select * from db1.user where name=#{name} and age =#{age}
    </select>

/**
 *
 * 用户的持久层接口
 */
public interface IUserDao {

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


    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);


    /**
     * 根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

    /**
     * 根据传入参数条件
     * @param user 查询的条件：有可能有用户名，有可能有性别，也有可能有地址，还有可能是都有
     * @return
     */
    List<User> findUserByCondition(User user);

    /**
     * 根据queryvo中提供的id集合，查询用户信息
     * @param vo
     * @return
     */
    List<User> findUserInIds(QueryVo vo);
}

2.6 动态sql

if标签
sql复用标签
where标签
foreach遍历标签

<!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="userMap" type="uSeR">
        <!-- 主键字段的对应 -->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userAddress" column="address"></result>
        <result property="userSex" column="sex"></result>
        <result property="userBirthday" column="birthday"></result>
    </resultMap>

    <!-- 了解的内容：抽取重复的sql语句-->
    <sql id="defaultUser">
        select * from user
    </sql>

    <!-- 查询所有 -->
    <select id="findAll" resultMap="userMap">
        <include refid="defaultUser"></include>
    </select>

    <!-- 根据id查询用户 -->
    <select id="findById" parameterType="INT" resultMap="userMap">
        select * from user where id = #{uid}
    </select>

    <!-- 根据名称模糊查询 -->
    <select id="findByName" parameterType="string" resultMap="userMap">
          select * from user where username like #{name}
   </select>

    <!-- 根据queryVo的条件查询用户 -->
    <select id="findUserByVo" parameterType="com.yxj.domain.QueryVo" resultMap="userMap">
        select * from user where username like #{user.userName}
    </select>

    <!-- 根据条件查询
    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user where 1=1
        <if test="userName != null">
          and username = #{userName}
        </if>
        <if test="userSex != null">
            and sex = #{userSex}
        </if>
    </select>-->

    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user
        <where>
            <if test="userName != null">
                and username = #{userName}
            </if>
            <if test="userSex != null">
                and sex = #{userSex}
            </if>
        </where>
    </select>

    <!-- 根据queryvo中的Id集合实现查询用户列表 -->
    <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
        <include refid="defaultUser"></include>
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>

2.7 关联关系

一对一关联关系

数据库：
--一对一
--用户表
create table t_users(
	id varchar2(36) primary key,
	name varchar2(40),
	age Integer,
	bir date,
	cardId varchar2(36) references t_card(id)
);
--身份信息表
create table t_card(
	id  varchar2(36) primary key,
	no varchar2(18),
	address varchar2(100),
	fork varchar2(30)
);
------------------------------------------------
--测试数据
insert into t_card values('1','32092411111111','北京市海淀区','汉族');
insert into t_card values('2','32092411111112','北京市昌平区','满族');

insert into t_users values('1','小黑',23,sysdate,'1');
insert into t_users values('2','小三',23,sysdate,'2');

--连接查询语句
select * from t_users u left join t_card c on u.cardId = c.id

实体类：
package com.yxj.entity;

import java.util.Date;

public class User {
	
	private String id;
	private String name;
	private Integer age;
	private Date bir;
	
	private Card card;//关系属性  不要出现在toString方法里面  
	
	
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	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;
	}
	public Date getBir() {
		return bir;
	}
	public void setBir(Date bir) {
		this.bir = bir;
	}
	public User(String id, String name, Integer age, Date bir) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.bir = bir;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + ", bir="
				+ bir + "]";
	}
}

package com.yxj.entity;

public class Card {
	private String id;
	private String no;
	private String address;
	private String fork;
	
	
	private User user;//关系属性
	
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getNo() {
		return no;
	}
	public void setNo(String no) {
		this.no = no;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public String getFork() {
		return fork;
	}
	public void setFork(String fork) {
		this.fork = fork;
	}
	public Card() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Card(String id, String no, String address, String fork) {
		super();
		this.id = id;
		this.no = no;
		this.address = address;
		this.fork = fork;
	}
	@Override
	public String toString() {
		return "Card [id=" + id + ", no=" + no + ", address=" + address
				+ ", fork=" + fork + "]";
	}
	
}

package com.yxj.dao;

import java.util.List;

import com.yxj.entity.User;

public interface UserDAO {
	
	//查询用户  并且查询用户的身份信息
	public List<User> queryAll();
	
}

<?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.dong.dao.UserDAO">
	<!-- 
		处理关联关系时  resultType无法将关系属性进行自动封装     只能处理单表简单类型(对象)
		
		处理关系属性赋值 :使用resultMap
			type:封装对象类型  如果是一个 直接写对象的全名(别名)  如果是多个 同样写泛型的类型
			id : resultMap的名字
	 -->
	 
	 
	 <resultMap type="com.dong.entity.User" id="userR">
	 	<!-- 用来封装user中的主键的值 column 数据库返回的列名   property 类中属性名 -->
	 	<id column="userId" property="id"/>
	 	<!-- 用来封装user中的普通属性值 -->
	 	<result column="name" property="name"/>
	 	<result column="age" property="age"/>
	 	<result column="bir" property="bir"/>
	 	<!-- 关系属性封装 一对一  对象类型
	 		association: 用来处理一对一关系属性封装
	 		property : 关系属性名
	 		javaType: 关系属性的类型
	 	 -->
	 	<association property="card" javaType="com.dong.entity.Card" >
	 		<id column="cardId" property="id" />
	 		<result column="no" property="no"/>
	 		<result column="address" property="address"/>
	 		<result column="fork" property="fork"/>
	 	</association>
	 </resultMap>

	<!-- 
		resultMap: 封装对象时使用外部的哪个resultMap进行封装  书写resultMap标签的id属性
	 -->
	<select id="queryAll" resultMap="userR">
		select u.id userId,u.name,u.age,u.bir,
		       c.id cardId,c.no,c.fork,c.address 
		from t_users u 
		left join t_card c 
		on  u.cardId = c.id
	</select>
</mapper>


/**
 
 * 
 *
 * 测试mybatis的crud操作
 */
public class MybatisTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        //5.执行查询所有方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }

    }

    /**
     * 测试保存操作
     */
    @Test
    public void testSave(){
        User user = new User();
        user.setUserName("modify User property");
        user.setUserAddress("北京市顺义区");
        user.setUserSex("男");
        user.setUserBirthday(new Date());
        System.out.println("保存操作之前："+user);
        //5.执行保存方法
        userDao.saveUser(user);

        System.out.println("保存操作之后："+user);
    }

    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setUserId(50);
        user.setUserName("mybastis update user");
        user.setUserAddress("北京市顺义区");
        user.setUserSex("女");
        user.setUserBirthday(new Date());

        //5.执行保存方法
        userDao.updateUser(user);
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testDelete(){
        //5.执行删除方法
        userDao.deleteUser(48);
    }

    /**
     * 测试删除操作
     */
    @Test
    public void testFindOne(){
        //5.执行查询一个方法
        User  user = userDao.findById(50);
        System.out.println(user);
    }

    /**
     * 测试模糊查询操作
     */
    @Test
    public void testFindByName(){
        //5.执行查询一个方法
        List<User> users = userDao.findByName("%王%");
//        List<User> users = userDao.findByName("王");
        for(User user : users){
            System.out.println(user);
        }
    }

    /**
     * 测试查询总记录条数
     */
    @Test
    public void testFindTotal(){
        //5.执行查询一个方法
        int count = userDao.findTotal();
        System.out.println(count);
    }


    /**
     * 测试使用QueryVo作为查询条件
     */
    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        //5.执行查询一个方法
        List<User> users = userDao.findUserByVo(vo);
        for(User u : users){
            System.out.println(u);
        }
    }
}

一对多关联关系

--处理一对多
--部门表
create table t_dept(
	id varchar2(36) primary key,
	name varchar2(40)
);
--员工表
create table t_emps(
	id varchar2(36) primary key,
	name varchar2(40),
	age Integer ,
	bir date,
	salary number(7,2),
	deptId varchar2(36) references t_dept(id)
);
--部门测试数据
insert into t_dept values('1','教学部');
insert into t_dept values('2','研发部');
--员工的测试数据
insert into t_emps values('1','小黑',12,sysdate,23000.12,'1');
insert into t_emps values('2','小三',12,sysdate,23000.12,'2');
insert into t_emps values('3','小黄',12,sysdate,23000.12,'1');
insert into t_emps values('4','小牛',12,sysdate,23000.12,'1');
insert into t_emps values('5','小金',12,sysdate,23000.12,'1');
insert into t_emps values('6','小陈',12,sysdate,23000.12,'2');

--根据部门找员工信息
select * from t_dept d left join t_emps e on d.id  = e.deptId where d.id = '1'
--

package com.yxj.entity;

import java.util.Date;

public class Emp {
	private String id;
	private String name;
	private Integer age;
	private Double salary;
	private Date  bir;
	
	private Dept dept;//关系属性
	
	
	public Dept getDept() {
		return dept;
	}
	public void setDept(Dept dept) {
		this.dept = dept;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	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;
	}
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
	public Date getBir() {
		return bir;
	}
	public void setBir(Date bir) {
		this.bir = bir;
	}
	public Emp() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Emp(String id, String name, Integer age, Double salary, Date bir) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.bir = bir;
	}
	@Override
	public String toString() {
		return "Emp [id=" + id + ", name=" + name + ", age=" + age
				+ ", salary=" + salary + ", bir=" + bir + "]";
	}
	
}

package com.yxj.entity;

import java.util.List;

public class Dept {
	private String id;
	private String name;
	
	//关系属性
	private List<Emp> emps;
	
	public List<Emp> getEmps() {
		return emps;
	}
	public void setEmps(List<Emp> emps) {
		this.emps = emps;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Dept() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Dept(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Dept [id=" + id + ", name=" + name + "]";
	}
	
}

package com.yxj.dao;

import java.util.List;

import com.yxj.entity.Dept;

public interface DeptDAO {
	
	//查询部门的同时将部门中所有的员工信息一并查到
	public List<Dept> queryAll();
	
}

<?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.dong.dao.DeptDAO">


	<resultMap type="com.dong.entity.Dept" id="deptMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- 处理关系属性的封装
			collection 用来处理封装集合类型的管理属性   用来处理一对多这种情况
			property:  关系属性名 
			javaType:  关系属性类型
			ofType  :  集合中泛型类型  全名
		 -->
		<collection property="emps" javaType="list" ofType="com.dong.entity.Emp">
			<id column="eid" property="id"/>
			<result  column="ename" property="name"/>
			<result column="age" property="age"/>
			<result column="salary" property="salary"/>
			<result column="bir" property="bir"/>
		</collection>
	</resultMap>

	<select id="queryAll" resultMap="deptMap">
		select d.id,d.name,e.id eid,e.name ename,e.age,e.salary,e.bir from t_dept d left join t_emps e on d.id  = e.deptId
	</select>
  
</mapper>

多对多关联关系

#学生表
CREATE TABLE student(
student_id  INT PRIMARY KEY AUTO_INCREMENT, -- 学生id 主键 自增长
name        VARCHAR(20),-- 姓名
age         INT,-- 年龄
id_no       CHAR(18),-- 身份证号码
sex         CHAR(1) -- 性别
);

#课程表
CREATE TABLE course(
course_id INT PRIMARY KEY AUTO_INCREMENT, -- 课程id 主键 自增长
NAME VARCHAR(20) -- 课程名称
);

#学生课程中间表
CREATE TABLE student_course_relation(
student_id INT,
course_id INT,

CONSTRAINT pk_sc_id PRIMARY KEY(student_id, course_id), -- 设置为联合id
CONSTRAINT fk_student_id FOREIGN KEY(student_id) REFERENCES student(student_id), -- 设置外键
CONSTRAINT fk_course_id FOREIGN KEY(course_id) REFERENCES course(course_id)
);


#学生表插入数据
INSERT INTO student(NAME,age,id_no,sex) VALUES('步惊云',20,'632323190605262000','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('聂风',22,'632323190605264501','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('赵敏',18,'632323190605261001','女');
INSERT INTO student(NAME,age,id_no,sex) VALUES('张三丰',40,'632323190605268000','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('张曼玉',25,'632323190605260447','女');
INSERT INTO student(NAME,age,id_no,sex) VALUES('猪八戒',50,'632323190605265002','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('孙悟空',500,'632323190605268780','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('任盈盈',20,'632323190605263007','女');
INSERT INTO student(NAME,age,id_no,sex) VALUES('赵灵儿',18,'632323190605260922','女');
INSERT INTO student(NAME,age,id_no,sex) VALUES('李逍遥',20,'632323190605267585','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('小白龙',200,'632323190605264085','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('叶凡',30,'632323190605266160','男');
INSERT INTO student(NAME,age,id_no,sex) VALUES('姬紫月',17,'632323190605265000','女');

#课程表插入数据
INSERT INTO course(NAME) VALUES('高等数学');
INSERT INTO course(NAME) VALUES('线性代数');
INSERT INTO course(NAME) VALUES('数据结构');
INSERT INTO course(NAME) VALUES('大学英语');
INSERT INTO course(NAME) VALUES('大学计算机基础');
INSERT INTO course(NAME) VALUES('概率论');
INSERT INTO course(NAME) VALUES('C语言');
INSERT INTO course(NAME) VALUES('c++');
INSERT INTO course(NAME) VALUES('高等代数');
INSERT INTO course(NAME) VALUES('插花艺术欣赏');
INSERT INTO course(NAME) VALUES('语文');

#课程-学生关联表插入数据
INSERT INTO student_course_relation(student_id,course_id) VALUES(1,1);
INSERT INTO student_course_relation(student_id,course_id) VALUES(1,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(1,7);
INSERT INTO student_course_relation(student_id,course_id) VALUES(2,2);
INSERT INTO student_course_relation(student_id,course_id) VALUES(2,3);
INSERT INTO student_course_relation(student_id,course_id) VALUES(2,10);
INSERT INTO student_course_relation(student_id,course_id) VALUES(3,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(3,8);
INSERT INTO student_course_relation(student_id,course_id) VALUES(3,6);
INSERT INTO student_course_relation(student_id,course_id) VALUES(4,2);
INSERT INTO student_course_relation(student_id,course_id) VALUES(4,11);
INSERT INTO student_course_relation(student_id,course_id) VALUES(5,1);
INSERT INTO student_course_relation(student_id,course_id) VALUES(5,2);
INSERT INTO student_course_relation(student_id,course_id) VALUES(5,3);
INSERT INTO student_course_relation(student_id,course_id) VALUES(6,1);
INSERT INTO student_course_relation(student_id,course_id) VALUES(6,9);
INSERT INTO student_course_relation(student_id,course_id) VALUES(6,10);
INSERT INTO student_course_relation(student_id,course_id) VALUES(7,3);
INSERT INTO student_course_relation(student_id,course_id) VALUES(7,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(7,7);
INSERT INTO student_course_relation(student_id,course_id) VALUES(8,2);
INSERT INTO student_course_relation(student_id,course_id) VALUES(8,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(8,4);
INSERT INTO student_course_relation(student_id,course_id) VALUES(9,9);
INSERT INTO student_course_relation(student_id,course_id) VALUES(9,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(9,4);
INSERT INTO student_course_relation(student_id,course_id) VALUES(10,5);
INSERT INTO student_course_relation(student_id,course_id) VALUES(11,3);
INSERT INTO student_course_relation(student_id,course_id) VALUES(12,3);
INSERT INTO student_course_relation(student_id,course_id) VALUES(13,9);

用户表

角色表

用户_角色表

package com.yxj.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 
 * @Company http://www.yxj.com
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getAddress() {
        return address;
    }

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

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

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

package com.yxj.domain;

import java.io.Serializable;
import java.util.List;

/**
 
 * @Company http://www.yxj.com
 */
public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }
}

UserDao
获取用户对于的角色

RoleDao
获取角色所对于的用户

天线短路宝宝529

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫