Java精进-20分钟学会mybatis使用
ztj100 2025-01-07 17:22 20 浏览 0 评论
相关概念
还是先上文字介绍吧!不敢兴趣的同学可直接跳过
Mybatis
MyBatis是一款优秀的基于ORM的半自动轻量级持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解来配置和映射原生类型、接口和Java的POJO （Plain Old Java Objects,普通老式Java对 象）为数据库中的记录。
对象/关系数据库映射（ORM）
ORM全称Object/Relation Mapping,表示对象-关系映射的缩写ORM完成面向对象的编程语言到关系数据库的映射。
当ORM框架完成映射后，程序员既可以利用面向对象程序设计语言的简单易用性，又可以利用关系数据库的技术优势。
ORM把关系数据库包装成面向对象的模型。ORM框架是面向对象设计语言与关系数据库发展不同步时的中间解决方案。
采用ORM框架后，应用程序不再直接访问底层数据库，而是以面向对象的放松来操作持久化对象，而ORM框架则将这些面向对象的操作转换成底层SQL操作。ORM框架实现的效果：把对持久化对象的保存、修改、删除 等操作，转换为对数据库的操作。
上面一堆话总结下来，可以理解为 直接操作对象，不用关心数据库细节 。
Mybatis历史
原是apache的一个开源项目iBatis, 2010年6月这个项目由apache software foundation 迁移到了google code，随着开发团队转投Google Code旗下，ibatis3.x正式更名为Mybatis ，代码于2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)
Mybatis优势
半自动化,对开发人员开说，核心sql还是需要自己进行优化。
sql和java编码进行分离，功能边界清晰，一个专注业务，一个专注数据。
基本使用
我们通过写一个用户表的增删查改进行入门
快速入门
开发步骤如下:
- 添加MyBatis的坐标
- 创建user数据表
- 编写User实体类
- 编写映射文件UserMapper.xml
- 编写核心文件SqlMapConfig.xml
- 编写测试类
新建maven项目并导入依赖
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<java.version>1.8</java.version>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties> <!--mybatis坐标-->
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency> <!--mysql驱动坐标-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency> <!--单元测试坐标-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency> <!--日志坐标-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>创建user数据表录入数据，并编写实体
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;public class User {
private Integer id;
private String username;
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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
'}';
}
}编写UserMapper映射文件UserMapper.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="user">
<select id="findAll" resultType="com.yqy.pojo.User">
select * from user
</select>
</mapper>编写MyBatis核心文件sqlMapConfig.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>
<environments default="development">
<environment id="development">
<!-- 当前事务交由jdbc管理-->
<transactionManager type="JDBC"></transactionManager>
<!-- 当前使用mybatis提供的连接池-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///zyd_mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!-- 引入映射配置文件-->
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>测试代码
@Test
public void test1() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
//获得sqlSession工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
//获得sqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();
//执行sql语句,这里的user.findAll其实是通过xml中namespace和id的组合，
//mybatis是通过namespace和id的组合来定位到具体的sql语句的
List<User> userList = sqlSession.selectList("user.findAll");
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}结果输入
增删改查操作
以上我们做了一个简单查询，接下来来个把增删改也来一套!
插入数据
基于之前编写UserMapper映射文件，追加insert
<mapper namespace="user">
<insert id="insert" parameterType="com.yqy.pojo.User">
insert into user values(#{id},#{username},#{password})
</insert>
</mapper>编写测试代码
@Test
public void testInsert() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = new User();
user.setId(3);
user.setUsername("打工人");
int insert = sqlSession.insert("user.insert", user);
System.out.println(insert);
//提交事务
sqlSession.commit();
sqlSession.close();
}总结
- 插入语句使用insert标签
- 在映射文件中使用parameterType属性指定要插入的数据类型
- Sql语句中使用#{实体属性名}方式引用实体中的属性值
- 插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);
- 插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()
修改数据
基于之前编写UserMapper映射文件，追加insert
<mapper namespace="user">
<update id="update" parameterType="com.yqy.pojo.User">
update user set username=#{username} where id=#{id}
</update>
</mapper>编写测试代码
@Test
public void testUpdate() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
User user = new User();
user.setId(3);
user.setUsername("打工人yqy");
sqlSession.update("user.update", user);
//提交事务
sqlSession.commit();
sqlSession.close();
}总结
? 修改语句使用update标签
? 修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);
删除数据
基于之前编写UserMapper映射文件，追加delete
<mapper namespace="user">
<delete id="delete" parameterType="java.lang.Integer">
delete from user where id=#{id}
</delete>
</mapper>编写测试代码
@Test
public void testDelete() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.delete("user.delete",3);
//提交事务
sqlSession.commit();
sqlSession.close();
}总结
除语句使用delete标签
?Sql语句中使用#{任意字符串}方式引用传递的单个参数
?删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);
常用配置解析
environments标签
数据库环境的配置，支持多环境配置
事务管理器（ transactionManager ）类型有两种：
JDBC：这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。
数据源（ dataSource ）类型有三种：
?UNPOOLED：每次被请求时打开和关闭连接。
?POOLED：利用“池”的概念将 JDBC 连接对象组织起来。
?JNDI：为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
mapper标签
该标签的作用是加载映射的，加载方式有如下几种：
?使用相对于类路径的资源引用，例如：
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
?使用完全限定资源定位符（URL），例如：
<mapper url="file:///var/mappers/AuthorMapper.xml"/>
?使用映射器接口实现类的完全限定类名，例如：
<mapper class="org.mybatis.builder.AuthorMapper"/>
?将包内的映射器接口实现全部注册为映射器，例如：
<package name="org.mybatis.builder"/>相应API介绍
SqlSession工厂构建器SqlSessionFactoryBuilder
常用API：SqlSessionFactory build(InputStream inputStream)
通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象
String resource = "org/mybatis/builder/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(inputStream);其中， Resources 工具类，这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文件系统或一个 web URL 中加载资源文件。
SqlSession工厂对象SqlSessionFactory
SqlSessionFactory 有多个个方法创建SqlSession 实例。常用的有如下两个：
SqlSession会话对象
SqlSession中提供了所有执行语句、提交或回滚事务和获取映射器实例的方法。
执行语句主要有:
<T> T selectOne(String statement, Object parameter)
<E> List<E> selectList(String statement, Object parameter)
int insert(String statement, Object parameter)
int update(String statement, Object parameter)
int delete(String statement, Object parameter)操作失事务方法有:
void commit()
void rollback()Mybatis的Dao层实现
实现dao层方式有两种，传统开发和代理开发方式,代理开发的有点是不用编写具体实现类
传统开发方式
传统方式即自己编写Dao层接口的实现类
先定义接口
public interface UserDao {
List<User> findAll() throws IOException;
}编写UserDaoImpl实现
public class UserDaoImpl implements UserDao {
public List<User> findAll() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
List<User> userList = sqlSession.selectList("userMapper.findAll");
sqlSession.close();
return userList;
}
}测试
@Test
public void testTraditionDao() throws IOException {
UserDao userDao = new UserDaoImpl();
List<User> all = userDao.findAll();
System.out.println(all);
}代理开发方式
采用 Mybatis 的代理开发方式实现 DAO 层的开发，这是主流的方式。
Mapper 接口开发方法只需要编写Mapper 接口（相当于Dao 接口）,由Mybatis 框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。
Mapper 接口开发需要遵循以下规范：
- Mapper.xml文件中的namespace与mapper接口的全限定名相同
- Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
- Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
- Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同
编写UserMapper接口
import com.yqy.pojo.User;
public interface UserDao {
User findById(int id);
}<mapper namespace="com.yqy.mapper.UserDao">
<select id="findById" resultType="com.yqy.pojo.User" parameterType="int">
select * from user where id = #{id}
</select>
</mapper>测试
@Test
public void testMapper() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
//获得MyBatis框架生成的UserMapper接口的实现类
UserDao userDao = sqlSession.getMapper(UserDao.class);
User user = userDao.findById(1);
System.out.println(user);
}配置文件深入
核心配置文件层次关系如下
常用配置
Properties标签
实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties文件
typeAliases标签
类型别名是为Java 类型设置一个短的名字。原来的类型名称配置如下
配置typeAliases，为com.lagou.domain.User定义别名为user
上面我们是自定义的别名，mybatis框架已经为我们设置好的一些常用的类型的别名
映射配置文件mapper.xml
动态sql语句
根据实体类的不同取值，使用不同的 SQL语句来进行查询。比如在 id如果不为空时可以根据id查询，如果username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。
<select id="findByCondition" parameterType="user" resultType="user">
select * from User
<where>
<if test="id!=0"> and id=#{id} </if>
<if test="username!=null"> and username=#{username} </if>
</where>
</select>当查询条件id和username都存在时，控制台打印的sql语句如下：
当查询条件只有id存在时，控制台打印的sql语句如下：
看下循环执行sql的拼接操作，例如：SELECT * FROM USER WHERE id IN (1,2,5)。
<select id="findByIds" parameterType="list" resultType="user">
select * from User
<where>
<foreach collection="list" open="id in(" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>测试代码如下:
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
int[] ids = new int[]{2,5};
List<User> userList = userMapper.findByIds(ids);
System.out.println(userList);foreach标签的属性含义如下：
标签用于遍历集合，它的属性：
?collection：代表要遍历的集合元素，注意编写时不要写#{}
?open：代表语句的开始部分
?close：代表结束部分
?item：代表遍历集合的每个元素，生成的变量名
?sperator：代表分隔符
SQL片段抽取
Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
<!--抽取sql片段简化编写-->
<sql id="selectUser" select * from User</sql>
<select id="findById" parameterType="int" resultType="user">
<include refid="selectUser"></include> where id=#{id}
</select>
<select id="findByIds" parameterType="list" resultType="user">
<include refid="selectUser">
</include>
<where>
<foreach collection="array" open="id in(" close=")" item="id" separator=",">#{id} </foreach>
</where>
</select>复杂映射开发
复杂映射开发主要是对象之间一对一，一对多，多对多关系的处理
一对一查询
一对一查询的模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询的语句
对应的sql语句：select * from orders o,user u where o.uid=u.id;
查询的结果如下：
创建Order和User实体
public class Order {
private int id;
private Date ordertime;
private double total;
//代表当前订单从属于哪一个客户
private User user;
}
public class User {
private int id;
private String username;
private String password;
private Date birthday;
}创建OrderMapper接口并配置
public interface OrderMapper {
List<Order> findAll();
}<mapper namespace="com.lagou.mapper.OrderMapper">
<resultMap id="orderMap" type="com.lagou.domain.Order">
<result column="uid" property="user.id"></result>
<result column="username" property="user.username"></result>
<result column="password" property="user.password"></result>
<result column="birthday" property="user.birthday"></result>
</resultMap>
<select id="findAll" resultMap="orderMap"> select * from orders o,user u where o.uid=u.id </select>
</mapper>还可以配置如下：
<resultMap id="orderMap" type="com.lagou.domain.Order">
<result property="id" column="id"></result>
<result property="ordertime" column="ordertime"></result>
<result property="total" column="total"></result>
<association property="user" javaType="com.lagou.domain.User">
<result column="uid" property="id"></result>
<result column="username" property="username"></result>
<result column="password" property="password"></result>
<result column="birthday" property="birthday"></result>
</association>
</resultMap>测试结果
OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
List<Order> all = mapper.findAll();
for(Order order : all){
System.out.println(order);
}一对多查询
一对多查询的模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单
一对多查询的语句
对应的sql语句：select *,o.id oid from user u left join orders o on u.id=o.uid;
查询的结果如下：
public class Order
{
private int id;
private Date ordertime;
private double total;
//代表当前订单从属于哪一个客户
private User user;
}
public class User
{
private int id;
private String username;
private String password;
private Date birthday;
//代表当前用户具备哪些订单
private List < Order > orderList;
}创建UserMapper接口
public interface UserMapper {
List<User> findAll();
}配置UserMapper.xml
<mapper namespace="com.lagou.mapper.UserMapper">
<resultMap id="userMap" type="com.lagou.domain.User">
<result column="id" property="id"></result>
<result column="username" property="username"></result>
<result column="password" property="password"></result>
<result column="birthday" property="birthday"></result>
<collection property="orderList" ofType="com.lagou.domain.Order">
<result column="oid" property="id"></result>
<result column="ordertime" property="ordertime"></result>
<result column="total" property="total"></result>
</collection>
</resultMap>
<select id="findAll"
resultMap="userMap">
select *,o.id oid from user u left join orders o on u.id=o.uid
</select>
</mapper>测试结果
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List < User > all = mapper.findAll();
for(User user: all)
{
System.out.println(user.getUsername());
List < Order > orderList = user.getOrderList();
for(Order order: orderList)
{
System.out.println(order);
}
System.out.println("----------------------------------");
}多对多查询
多对多查询的模型
用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的需求：查询用户同时查询出该用户的所有角色
多对多查询的语句
对应的sql语句：select u.,r.,r.id rid from user u left join user_role ur on u.id=ur.user_id inner join role r on ur.role_id=r.id;
查询的结果如下：
创建Role实体，修改User实体
public class User
{
private int id;
private String username;
private String password;
private Date birthday;
//代表当前用户具备哪些订单
private List < Order > orderList;
//代表当前用户具备哪些角色
private List < Role > roleList;
}
public class Role
{
private int id;
private String rolename;
}添加UserMapper接口方法
List<User> findAllUserAndRole();配置UserMapper.xml
<resultMap id="userRoleMap" type="com.lagou.domain.User">
<result column="id" property="id"></result>
<result column="username" property="username"></result>
<result column="password" property="password"></result>
<result column="birthday" property="birthday"></result>
<collection property="roleList" ofType="com.lagou.domain.Role">
<result column="rid" property="id"></result>
<result column="rolename" property="rolename"></result>
</collection>
</resultMap>
<select id="findAllUserAndRole"
resultMap="userRoleMap">
select u.*,r.*,r.id rid from user u left join user_role ur on u.id=ur.user_id inner join role r on ur.role_id=r.id
</select>测试结果
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List < User > all = mapper.findAllUserAndRole();
for(User user: all)
{
System.out.println(user.getUsername());
List < Role > roleList = user.getRoleList();
for(Role role: roleList)
{
System.out.println(role);
}
System.out.println("----------------------------------");
}Mybatis注解开发
MyBatis的常用注解
这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。
我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。
@Insert：实现新增
@Update：实现更新
@Delete：实现删除
@Select：实现查询
@Result：实现结果集封装
@Results：可以与@Result 一起使用，封装多个结果集
@One：实现一对一结果集封装
@Many：实现一对多结果集封装
MyBatis的增删改查
我们完成简单的user表的增删改查的操作
private UserMapper userMapper;
@Before
public void before() throws IOException {
InputStream resourceAsStream =
Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new
SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
userMapper = sqlSession.getMapper(UserMapper.class);
}
@Test
public void testAdd() {
User user = new User();
user.setUsername("测试数据");
user.setPassword("123");
user.setBirthday(new Date());
userMapper.add(user);
}
@Test
public void testUpdate() throws IOException {
User user = new User();
user.setId( 16 );
user.setUsername("测试数据修改");
user.setPassword("abc");
user.setBirthday(new Date());
userMapper.update(user);
}
public void testDelete() throws IOException {
userMapper.delete(16);
}
@Test
public void testFindById() throws IOException {
User user = userMapper.findById(1);
System.out.println(user);
}
@Test
public void testFindAll() throws IOException {
List<User> all = userMapper.findAll();
for (User user : all) {
System.out.println(user);
}
}修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可
<mappers>
<!--扫描使用注解的类-->
<mapper class="com.lagou.mapper.UserMapper">
</mapper>
</mappers>或者指定扫描包含映射关系的接口所在的包也可以
<mappers>
<!--扫描使用注解的类所在的包-->
<package name="com.lagou.mapper">
</package>
</mappers>注解实现复杂映射开发
实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置
一对一查询
一对一查询的模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询的语句
对应的sql语句：
select * from orders;
select * from user where id=查询出订单的uid;查询的结果如下：
public class Order {
private int id;
private Date ordertime;
private double total;
private User user;
}
public class User {
private int id;
private String username;
private String password;
private Date birthday;
}创建OrderMapper接口
public interface OrderMapper {
List<Order> findAll();
}使用注解配置Mapper
public interface OrderMapper {
@Select("select * from orders")
@Results({
@Result(id=true,property = "id",column = "id"),
@Result(property = "ordertime",column = "ordertime"),
@Result(property = "total",column = "total"),
@Result(property = "user",column = "uid",
javaType = User.class,
one = @One(select = "com.lagou.mapper.UserMapper.findById"))
})
List<Order> findAll();
}
public interface UserMapper {
@Select("select * from user where id=#{id}")
User findById(int id);
}测试结果
@Test
public void testSelectOrderAndUser() {
List<Order> all = orderMapper.findAll();
for(Order order : all){
System.out.println(order);
}
}一对多查询
一对多查询的模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单
6.5.2 一对多查询的语句
对应的sql语句：
select * from user;
select * from orders where uid=查询出用户的id;查询的结果如下：
修改User实体
public class Order {
private int id;
private Date ordertime;
private double total;
//代表当前订单从属于哪一个客户
private User user;
}
public class User {
private int id;
private String username;
private String password;
private Date birthday;
//代表当前用户具备哪些订单
private List<Order> orderList;
}创建UserMapper接口
List<User> findAllUserAndOrder();使用注解配置Mapper
public interface UserMapper {
@Select("select * from user")
@Results({
@Result(id = true,property = "id",column = "id"),
@Result(property = "username",column = "username"),
@Result(property = "password",column = "password"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "orderList",column = "id",
javaType = List.class,
many = @Many(select =
"com.lagou.mapper.OrderMapper.findByUid"))
})
List<User> findAllUserAndOrder();
}
public interface OrderMapper {
@Select("select * from orders where uid=#{uid}")
List<Order> findByUid(int uid);
}测试结果
List<User> all = userMapper.findAllUserAndOrder();
for(User user : all){
System.out.println(user.getUsername());
List<Order> orderList = user.getOrderList();
for(Order order : orderList){
System.out.println(order);
}
System.out.println("-----------------------------");
}多对多查询
多对多查询的模型
用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的需求：查询用户同时查询出该用户的所有角色
多对多查询的语句
对应的sql语句：
select * from user;
select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=用户的id查询的结果如下：
创建Role实体，修改User实体
public class User {
private int id;
private String username;
private String password;
private Date birthday;
//代表当前用户具备哪些订单
private List<Order> orderList;
//代表当前用户具备哪些角色
private List<Role> roleList;
}
public class Role {
private int id;
private String rolename;
}添加UserMapper接口方法
List<User> findAllUserAndRole();使用注解配置Mapper
public interface UserMapper {
@Select("select * from user")
@Results({
@Result(id = true,property = "id",column = "id"),
@Result(property = "username",column = "username"),
@Result(property = "password",column = "password"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "roleList",column = "id",
javaType = List.class,
many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid"))
})
List<User> findAllUserAndRole();}
public interface RoleMapper {
@Select("select * from role r,user_role ur where r.id=ur.role_id and
ur.user_id=#{uid}")
List<Role> findByUid(int uid);
}测试结果
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAllUserAndRole();
for(User user : all){
System.out.println(user.getUsername());
List<Role> roleList = user.getRoleList();
for(Role role : roleList){
System.out.println(role);
}
System.out.println("----------------------------------");
}- 上一篇：mybatis一些需要注意的点，看看你有木有遇到过
- 下一篇：MyBatis 鉴别器
相关推荐
- 其实TensorFlow真的很水无非就这30篇熬夜练
-
好的！以下是TensorFlow需要掌握的核心内容，用列表形式呈现，简洁清晰（含表情符号，<300字）：1.基础概念与环境TensorFlow架构（计算图、会话->EagerE...
- 交叉验证和超参数调整:如何优化你的机器学习模型
-
准确预测Fitbit的睡眠得分在本文的前两部分中，我获取了Fitbit的睡眠数据并对其进行预处理，将这些数据分为训练集、验证集和测试集，除此之外，我还训练了三种不同的机器学习模型并比较了它们的性能。在...
- 机器学习交叉验证全指南:原理、类型与实战技巧
-
机器学习模型常常需要大量数据，但它们如何与实时新数据协同工作也同样关键。交叉验证是一种通过将数据集分成若干部分、在部分数据上训练模型、在其余数据上测试模型的方法，用来检验模型的表现。这有助于发现过拟合...
- 深度学习中的类别激活热图可视化
-
作者：ValentinaAlto编译：ronghuaiyang导读使用Keras实现图像分类中的激活热图的可视化，帮助更有针对性...
- 超强，必会的机器学习评估指标
-
大侠幸会，在下全网同名[算法金]0基础转AI上岸，多个算法赛Top[日更万日，让更多人享受智能乐趣]构建机器学习模型的关键步骤是检查其性能，这是通过使用验证指标来完成的。选择正确的验证指...
- 机器学习入门教程-第六课:监督学习与非监督学习
-
1.回顾与引入上节课我们谈到了机器学习的一些实战技巧，比如如何处理数据、选择模型以及调整参数。今天，我们将更深入地探讨机器学习的两大类：监督学习和非监督学习。2.监督学习监督学习就像是有老师的教学...
- Python 模型部署不用愁!容器化实战，5 分钟搞定环境配置
-
你是不是也遇到过这种糟心事：花了好几天训练出的Python模型，在自己电脑上跑得顺顺当当，一放到服务器就各种报错。要么是Python版本不对，要么是依赖库冲突，折腾半天还是用不了。别再喊“我...
- 神经网络与传统统计方法的简单对比
-
传统的统计方法如...
- 自回归滞后模型进行多变量时间序列预测
-
下图显示了关于不同类型葡萄酒销量的月度多元时间序列。每种葡萄酒类型都是时间序列中的一个变量。假设要预测其中一个变量。比如，sparklingwine。如何建立一个模型来进行预测呢？一种常见的方...
- 苹果AI策略:慢哲学——科技行业的“长期主义”试金石
-
苹果AI策略的深度原创分析，结合技术伦理、商业逻辑与行业博弈，揭示其“慢哲学”背后的战略智慧：一、反常之举：AI狂潮中的“逆行者”当科技巨头深陷AI军备竞赛，苹果的克制显得格格不入：功能延期：App...
- 时间序列预测全攻略，6大模型代码实操
-
如果你对数据分析感兴趣，希望学习更多的方法论，希望听听经验分享，欢迎移步宝藏公众号...
欢迎 你 发表评论:
- 一周热门
- 最近发表
- 标签列表
-
- idea eval reset (50)
- vue dispatch (70)
- update canceled (42)
- order by asc (53)
- spring gateway (67)
- 简单代码编程 贪吃蛇 (40)
- transforms.resize (33)
- redisson trylock (35)
- 卸载node (35)
- np.reshape (33)
- torch.arange (34)
- npm 源 (35)
- vue3 deep (35)
- win10 ssh (35)
- vue foreach (34)
- idea设置编码为utf8 (35)
- vue 数组添加元素 (34)
- std find (34)
- tablefield注解用途 (35)
- python str转json (34)
- java websocket客户端 (34)
- tensor.view (34)
- java jackson (34)
- vmware17pro最新密钥 (34)
- mysql单表最大数据量 (35)