一、了解orm框架
1.什么是ORM框架：对象关系映射（Object Relational Mapping，简称ORM），该模式是为了解决面向对象与关系数据库互补匹配的现象的技术；orm框架是连接数据库的桥梁，主要提供了人持久化与表之间的映射关系,ORM框架在运行时就能参照映射文件的信息，把对象持久化到数据建库中；
2.ORM框架的主要作用：为了解决面向对象关系与关系数据库互补匹配的问题；
3.ORM常用框架：
（1）Hibernate全自动映射框架，需要些hql语句
（2）iBATIs半自动框架，自己编写sql语句，可操作性强
（3）mybits半自动ORM映射框架
（4）eclipseLink
（5）JFinal
4. ORM的优缺点：
优点：
（1）提高开发效率，降低开发成本
（2）使开发更加对象化
（3）可移植
（4）可以很方便地引入数据缓存之类的附加功能
缺点：
（1）自动化进行关系数据库的映射需要消耗系统性能。其实这里的性能消耗还好啦，一般来说都可以忽略之。
（2）在处理多表联查、where条件复杂之类的查询时，ORM的语法会变得复杂。
二、半自动与全自动的区别
Hibrnate和mybatis是当前流行的ORM框架。hibernate对数据库结构提供了较为完整的封装。mybatis主要着力点在于java对象与SQL之间的映射关系。
Hibrnate：使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以Hibernate是全自动ORM映射框架；
Mybits：在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以Mybits是半自动ORM映射框架；
三、动态sql一对一、一对多、多对多的理解
前提：创建user表和orders表
package com.itheima.domain;
import java.util.Date;
import java.util.List;
public class User {
private int id;
private String username;
private String password;
private Date birthday;
//当前用户具备哪些角色
private List<Role> roleList;
public List<Role> getRoleList() {
return roleList;
}
public void setRoleList(List<Role> roleList) {
this.roleList = roleList;
}
//描述的是当前用户具有的订单
private List<Order> orderList;
public List<Order> getOrderList() {
return orderList;
}
public void setOrderList(List<Order> orderList) {
this.orderList = orderList;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", birthday=" + birthday +
", roleList=" + roleList +
'}';
}
}
package com.itheima.domain;
import java.util.Date;
public class Order {
private int id;
private Date ordertime;
private double total;
//当前订单属于哪一个用户
private User user;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Date getOrdertime() {
return ordertime;
}
public void setOrdertime(Date ordertime) {
this.ordertime = ordertime;
}
public double getTotal() {
return total;
}
public void setTotal(double total) {
this.total = total;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
public String toString() {
return "Order{" +
"id=" + id +
", ordertime=" + ordertime +
", total=" + total +
", user=" + user +
'}';
}
}
在sqlMapConfig.xml中加载映射关系
<!--加载映射关系-->
<mappers>
<!--指定接口所在的包-->
<!--<mapper resource="com.itheima.mapper/UserMapper.xml"></mapper>-->
<package name="com.itheima.mapper"></package>
</mappers>在web层中应用
package com.itheima.test;
import com.itheima.domain.Order;
import com.itheima.domain.User;
import com.itheima.mapper.OrderMapper;
import com.itheima.mapper.UserMapper;
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.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyBatisTest2 {
private OrderMapper mapper;
@Before
public void before() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
mapper = sqlSession.getMapper(OrderMapper.class);
}
}
1.一对一：
orders—>user：一个订单只由一个用户创建，一对一
在测试类中实现测试一对一方法
package com.itheima.test;
import com.itheima.domain.Order;
import com.itheima.domain.User;
import com.itheima.mapper.OrderMapper;
import com.itheima.mapper.UserMapper;
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.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyBatisTest2 {
private OrderMapper mapper;
@Before
public void before() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
mapper = sqlSession.getMapper(OrderMapper.class);
}
@Test
public void test(){
Order orders = mapper.findByOid(1);
System.out.println(orders);
}
}
OrderMapper
接口实现代码：
@Select("select * from orders o,user u where o.id=#{id} and o.uid=u.id")
@Results({
@Result(column = "id",property = "id"),
@Result(column = "ordertime",property = "ordertime"),
@Result(column = "total",property = "total"),
@Result(
property = "user", //要封装的属性名称
column = "uid", //根据那个字段去查询user表的数据
javaType = User.class, //要封装的实体类型
//select属性 代表查询那个接口的方法获得数据
one = @One(select = "com.itheima.mapper.UserMapper.findById")
)
})
public Order findByOid(int id);
2.一对多：
user---->orders：一个用户可以创建多个订单，一对多
测试类实现代码：
package com.itheima.test;
import com.itheima.domain.Order;
import com.itheima.domain.User;
import com.itheima.mapper.OrderMapper;
import com.itheima.mapper.UserMapper;
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.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyBatisTest2 {
private OrderMapper mapper;
@Before
public void before() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession(true);
mapper = sqlSession.getMapper(OrderMapper.class);
}
@Test
public void test(){
Order orders = mapper.findByOid(1);
System.out.println(orders);
}
@Test
public void test1(){
List<Order> orders = mapper.findByUid(1);
for (Order order : orders) {
System.out.println(order);
}
}
}
OrderMapper
接口实现代码：
@Select("select * from orders o,user u where uid=#{uid} and o.uid=u.id")
@Results({
@Result(column = "id",property = "id"),
@Result(column = "ordertime",property = "ordertime"),
@Result(column = "total",property = "total"),
@Result(
property = "user", //要封装的属性名称
column = "uid", //根据那个字段去查询user表的数据
javaType = User.class, //要封装的实体类型
//select属性 代表查询那个接口的方法获得数据
one = @One(select = "com.itheima.mapper.UserMapper.findById")
)
})
public List<Order> findByUid(int uid);
3.多对多：
完善一个中间类Role
package com.itheima.domain;
public class Role {
private int id;
private int roleId;
private String roleName;
private String roleDesc;
private Order order;
private User user;
public int getRoleId() {
return roleId;
}
public void setRoleId(int roleId) {
this.roleId = roleId;
}
public Order getOrder() {
return order;
}
public void setOrder(Order order) {
this.order = order;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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{" +
"id=" + id +
", roleId=" + roleId +
", order=" + order +
", user=" + user +
'}';
}
}
Role---> user---->orders：一个配送员对应多个订单号和客户信息
测试类实现代码：
@Test
public void test(){
List<Role> list = roleMapper.findAll();
for (Role role:list){
System.out.println(role);
}
}接口实现代码：
@Select("select * from sys_user_role ur,user u,orders o where ur.userID=u.id and ur.roleId=o.id")
@Results({
@Result(column = "userID",property = "id"),
@Result(column = "roleId",property = "roleId"),
@Result(
property = "user", //要封装的属性名称
column = "userID", //根据那个字段去查询user表的数据
javaType = User.class, //要封装的实体类型
//select属性 代表查询那个接口的方法获得数据
many = @Many(select = "com.itheima.mapper.UserMapper.findById")
),
@Result(
property = "order",
column = "roleId",
javaType = Role.class,
many = @Many(select = "com.itheima.mapper.OrderMapper.findByOid")
)
})
List<Role> findAll();Role{id=1, roleId=1, order=Order{id=1, ordertime=Sat Oct 29 03:12:21 CST 2022, total=3000.0, user=User{id=1, username='张三', password='123456', birthday=null, roleList=null}}, user=User{id=1, username='张三', password='123456', birthday=null, roleList=null}}
Role{id=1, roleId=2, order=Order{id=2, ordertime=Fri Oct 28 08:00:00 CST 2022, total=5800.0, user=User{id=1, username='张三', password='123456', birthday=null, roleList=null}}, user=User{id=1, username='张三', password='123456', birthday=null, roleList=null}}
Role{id=2, roleId=2, order=Order{id=2, ordertime=Fri Oct 28 08:00:00 CST 2022, total=5800.0, user=User{id=1, username='张三', password='123456', birthday=null, roleList=null}}, user=User{id=2, username='李四', password='123456', birthday=null, roleList=null}}
Role{id=2, roleId=3, order=Order{id=3, ordertime=Sat Oct 29 03:13:20 CST 2022, total=323.0, user=User{id=2, username='李四', password='123456', birthday=null, roleList=null}}, user=User{id=2, username='李四', password='123456', birthday=null, roleList=null}}
四、一级缓存、二级缓存
1.mybatis中为什么会存在缓存：
缓存的意义是将用户查询的数据放入缓存（内存）中，用户再去查询相应的数据就不会直接从关系数据库中查询，直接从缓存中查询，从而提高了并发开发中的系统的性能问题
2.Mybits的一级缓存是一个sqlSession级别的缓存，只能访问自己的一级缓存数据，而二级缓存是Mapper级别的缓存，是跨SQL Session的不同sqlSession是可以共享的缓存数据；
3.一级缓存的原理：
第一次发出查询请求，sql 查询的结果写入SqlSession的一级缓存当中，缓存使用的数据结构是一个map<key, value>
key : hashcode + sql + sql输入参数 + 输出参数 (sql的唯一标识)
value : 用户信息
同一个SqlSession再次发出相同的sql，就会从缓存中读取而不走数据库，如果两次操作之间出现commit（修改、输出、添加）操作，那么本SqlSession中一级缓存区域全部清空，下次再去缓存中查不到所以要从数据库中查询，从数据库再写入一级缓存。
https://blog.csdn.net/zy_zhangruichen/article/details/122592504
http://一级缓存原理
Mybatis 中一级缓存需要注意的点 ：
Mybatis 中一级缓存是默认开启的，不需要手动配置。
Mybatis 和 Spring 整合后进行 mapper 代理开发后，不支持一级缓存。Mybatis 和 Spring 整合，Spring 按照 mapper 的模板去生成 mapper 代理对象，模板中在最后会统一关闭 SqlSession。
4.二级缓存原理：
二级缓存的范围是mapper级别（mapper同一个命名空间），mapper以命名空间为单位创建缓存数据结构，结构是map<key, value>。每次查询前看是否开启了二级缓存，如果开启则从二级缓存的数据结构中取缓存数据，如果二级缓存中没有取到，再从一级缓存中取，如果一级缓存也没有，那就从数据库中查询。
（1）需要在Mybatis的配置文件中<settings>标签中配置二级缓存：
<settings>
<setting name="cacheEnabled" value="true"/> <!--Mybatis的二级缓存配置-->
</settings> （2）Mybatis的二级缓存的范围是mapper级别的，因此我们mapper如果想要使用二级缓存，还需要在对应的映射文件中配置<cache>标签
<mapper namespace="com.snow.xml.SnowOracle">
<cache></cache> <!--Mybatis的二级缓存配置-->
</mapper>五、Mybatis和Hibrnate区别
1.Hibrnate：使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以Hibernate是全自动ORM映射框架；
2. Mybits：在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以Mybits是半自动ORM映射框架；但mybits可以通过xml或注解方式灵活配置要运行的sql语句并将java对象和sql语句映射成最终执行的sql，最后将sql执行的结果在映射生成java对象
3.Mybits学习门槛低，简单易学，程序员直接编写原生态sql，可以严格控制sql执行性灵活；但是mybits无法做到与数据库无关性，如果要实现支持多种数据库软件则需要自定义多套sql映射文件，工作量较大
4.Hibernate 对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如
需求固定的定制化软件）如果用 hibernate 开发可以节省很多代码，提高效率。但是Hibernate 的缺点是学习门槛高，要精通门槛更高，而且怎么设计 O/R 映射，在性能和对象模型之间如何权衡，以及怎样用好 Hibernate 需要具有很强的经验和能力才行。总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。
六、分页查询插件
1.需要在pom.xml文件中导入依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>3.7.5</version>
</dependency>
<dependency>
<groupId>com.github.jsqlparser</groupId>
<artifactId>jsqlparser</artifactId>
<version>0.9.1</version>
</dependency>2.配置分页插件： 在sqlMapConfig.xml文件中配置
<!--配置分页助手插件-->
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql"></property>
</plugin>
</plugins>3.分页插件的使用
测试类中的代码实现：
@Test
public void test3() throws IOException {
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//设置分页相关参数 当前页+每页显示的条数
PageHelper.startPage(1,3);
List<User> userList = mapper.findAll();
for (User user : userList) {
System.out.println(user);
}
//获得与分页相关参数
PageInfo<User> pageInfo = new PageInfo<User>(userList);
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示条数："+pageInfo.getPageSize());
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
System.out.println("上一页："+pageInfo.getPrePage());
System.out.println("下一页："+pageInfo.getNextPage());
System.out.println("是否是第一页："+pageInfo.isIsFirstPage());
System.out.println("是否是最后一页："+pageInfo.isIsLastPage());
sqlSession.close();
}
测试结果：
pageNum：当前页的页码
pageSize：每页显示的条数
size：当前页显示的真实条数
total：总记录数
pages：总页数
prePage：上一页的页码
nextPage：下一页的页码
isFirstPage/isLastPage：是否为第一页/最后一页
hasPreviousPage/hasNextPage：是否存在上一页/下一页
navigatePages：导航分页的页码数
navigatepageNums：导航分页的页码，[1,2,3,4,5]
七、延时加载
1.什么是延迟加载：Mybatis中的延迟加载，也称为懒加载，是指在进行表的关联查询时，按照设置延迟规则推迟对关联对象的select查询，例如进行一对多查询时，之查询出一方数据，当程序中需要多方数据时，mybatis在发出sql语句进行查询，这样延迟加载就可以减少对数据库压力。Mybatis的延迟加载只是对关联对象的查询有延迟设置，对于主加载对象都是直接执行查询语句
2.加载时机：直接加载：执行完对主加载对象的 select 语句，马上执行对关联对象的 select 查询。侵入式延迟： 执行对主加载对象的查询时，不会执行对关联对象的查询。但当要访问主加载对象的详情属性时，就会马上执行关联对象的select查询。深度延迟： 执行对主加载对象的查询时，不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时，才会执行对关联对象的 select 查询。
注意：延迟加载的应用要求：关联对象的查询与主加载对象的查询必须是分别进行的select语句，不能是使用多表连接所进行的select查询。因为，多表连接查询，实质是对一张表的查询，对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。
3.入侵式延迟加载
①、sqlMapConfig.xml配置文件，首先开启延迟加载，然后再配置侵入式加载
八、Mybits中#与$的区别
<!--开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--配置侵入式延迟加载 默认为false（深度加载）
侵入式：默认只会执行主加载SQL，那么当访问主加载对象的详细信息时才会执行关联对象的SQL查询
深度延迟：默认只执行主加载SQL，那么当调用到主加载对象中关联对象的信息时才会执行关联对象的SQL查询
-->
<setting name="aggressiveLazyLoading" value="true"/>4.深入式延迟加载
sqlMapConfig.xml配置文件，首先开启延迟加载，然后再配置深度加载
<!--开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--配置侵入式延迟加载 默认为false（深度加载）
侵入式：默认只会执行主加载SQL，那么当访问主加载对象的详细信息时才会执行关联对象的SQL查询
深度延迟：默认只执行主加载SQL，那么当调用到主加载对象中关联对象的信息时才会执行关联对象的SQL查询
-->
<setting name="aggressiveLazyLoading" value="false"/>延迟加载
