myBatis-07 案例实践
案例表结构：
1、用户表
2、订单表
3、订单明细表
4、商品表
表结构关系相对比较清楚。
0、项目代码结构
1、表结构创建
客户表
-- ----------------------------
-- Table structure for ex_customer
-- ----------------------------
DROP TABLE IF EXISTS `ex_customer`;
CREATE TABLE `ex_customer` (
`custId` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`custName` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`telephone` varchar(11) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`sex` char(2) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`custId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of ex_customer
-- ----------------------------
INSERT INTO `ex_customer` VALUES ('C001', '顾问', '15345187579', '男', '顾问');
INSERT INTO `ex_customer` VALUES ('C002', '曹阳', '15345187577', '男', '曹阳');
SET FOREIGN_KEY_CHECKS = 1;
订单表
-- ----------------------------
-- Table structure for ex_order
-- ----------------------------
DROP TABLE IF EXISTS `ex_order`;
CREATE TABLE `ex_order` (
`orderId` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`custId` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`orderDate` datetime NULL DEFAULT NULL,
`totalMoney` decimal(10, 2) NULL DEFAULT NULL,
`remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`orderId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of ex_order
-- ----------------------------
INSERT INTO `ex_order` VALUES ('T0001', 'C001', '2021-01-01 00:00:00', 7000.00, '测试订单');
SET FOREIGN_KEY_CHECKS = 1;
订单明细表
-- ---------------------------- -- Table structure for ex_orderdetail -- ---------------------------- DROP TABLE IF EXISTS `ex_orderdetail`; CREATE TABLE `ex_orderdetail` ( `detailId` bigint(20) NOT NULL AUTO_INCREMENT, `orderId` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL, `prodId` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, `buyPrice` decimal(10, 2) NULL DEFAULT NULL, `buyCount` int(11) NULL DEFAULT NULL, `remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, PRIMARY KEY (`detailId`) USING BTREE ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic; -- ---------------------------- -- Records of ex_orderdetail -- ---------------------------- INSERT INTO `ex_orderdetail` VALUES (1, 'T0001', 'P001', 2000.00, 2, NULL); INSERT INTO `ex_orderdetail` VALUES (2, 'T0001', 'P002', 3000.00, 1, NULL); SET FOREIGN_KEY_CHECKS = 1;
商品表
-- ----------------------------
-- Table structure for ex_product
-- ----------------------------
DROP TABLE IF EXISTS `ex_product`;
CREATE TABLE `ex_product` (
`prodId` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`prodName` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`sellPrice` decimal(10, 2) NULL DEFAULT NULL,
`imgUrl` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`remark` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`prodId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of ex_product
-- ----------------------------
INSERT INTO `ex_product` VALUES ('P001', '手机', 2000.00, NULL, NULL);
INSERT INTO `ex_product` VALUES ('P002', '平板', 3000.00, NULL, NULL);
SET FOREIGN_KEY_CHECKS = 1;
2、模型类定义
2.1、用户模型
package rui.db.Model;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.List;
//客户模型
@Component
public class ex_Customer implements Serializable {
private String custId;
private String custName;
private String telephone;
private String sex;
private String remark;
//用户采购订单列表 1对多
private List<ex_Order> orderList;
//用户采购商品列表 多对多
private List<ex_Product> prodList;
public String getCustId() {
return custId;
}
public void setCustId(String custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public List<ex_Product> getProdList() {
return prodList;
}
public void setProdList(List<ex_Product> prodList) {
this.prodList = prodList;
}
@Override
public String toString() {
String result = "ex_customer{" + "custId='" + custId + '\'' + ", custName='" + custName + '\'' + ", telephone='" + telephone + '\'' + ", sex='" + sex + '\'' + ", remark='" + remark + '\'' + '}';
if (prodList != null) {
result += "\n采购商品列表";
for (ex_Product item : prodList) {
result += "\n" + item.toString();
}
}
if (orderList != null) {
result += "\n采购订单列表";
for (ex_Order item : orderList) {
result += "\n" + item.toString();
}
}
return result;
}
}
2.2、订单模型
package rui.db.Model;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
//订单模型
@Component
public class ex_Order implements Serializable {
private String orderId;
private String custId;
private Date orderDate;
private double totalMoney;
private String remark;
//包含客户表引用
private ex_Customer orderCust;
//包含订单明细
private List<ex_OrderDetail> detailList;
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getCustId() {
return custId;
}
public void setCustId(String custId) {
this.custId = custId;
}
public Date getOrderDate() {
return orderDate;
}
public void setOrderDate(Date orderDate) {
this.orderDate = orderDate;
}
public double getTotalMoney() {
return totalMoney;
}
public void setTotalMoney(double totalMoney) {
this.totalMoney = totalMoney;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public ex_Customer getOrderCust() {
return orderCust;
}
public void setOrderCust(ex_Customer orderCust) {
this.orderCust = orderCust;
}
public List<ex_OrderDetail> getDetailList() {
return detailList;
}
public void setDetailList(List<ex_OrderDetail> detailList) {
this.detailList = detailList;
}
@Override
public String toString() {
String result = "ex_order{" +
"orderId='" + orderId + '\'' +
", cusId='" + custId + '\'' +
", orderDate=" + orderDate +
", totalMoney=" + totalMoney +
", remark='" + remark + '\'' +
'}';
if (orderCust != null)
result += "\n" + orderCust.toString();
if (detailList != null) {
result += "\n订单包含如下的订单明细数据";
for (ex_OrderDetail detail : detailList) {
result += "\n" + detail.toString();
}
}
return result;
}
}
2.3、订单明细模型
package rui.db.Model;
import org.springframework.stereotype.Component;
import java.io.Serializable;
//订单明细
@Component
public class ex_OrderDetail implements Serializable {
private long detailId;
private String orderId;
private String prodId;
private double buyPrice;
private int buyCount;
private String remark;
//包含订单商品引用
private ex_Product orderProd;
public long getDetailId() {
return detailId;
}
public void setDetailId(long detailId) {
this.detailId = detailId;
}
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getProdId() {
return prodId;
}
public void setProdId(String prodId) {
this.prodId = prodId;
}
public double getBuyPrice() {
return buyPrice;
}
public void setBuyPrice(double buyPrice) {
this.buyPrice = buyPrice;
}
public int getBuyCount() {
return buyCount;
}
public void setBuyCount(int buyCount) {
this.buyCount = buyCount;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public ex_Product getOrderProd() {
return orderProd;
}
public void setOrderProd(ex_Product orderProd) {
this.orderProd = orderProd;
}
@Override
public String toString() {
String result = "ex_Orderdetail{" +
"detailId=" + detailId +
", orderId='" + orderId + '\'' +
", prodId='" + prodId + '\'' +
", buyPrice=" + buyPrice +
", buyCount=" + buyCount +
", remark='" + remark + '\'' +
'}';
if (orderProd != null) {
result += "\n" + orderProd.toString();
}
return result;
}
}
2.4、商品模型
package rui.db.Model;
import org.springframework.stereotype.Component;
import java.io.Serializable;
//产品模型
@Component
public class ex_Product implements Serializable {
private String prodId;
private String prodName;
private double sellPrice;
private String imgUrl;
private String remark;
public String getProdId() {
return prodId;
}
public void setProdId(String prodId) {
this.prodId = prodId;
}
public String getProdName() {
return prodName;
}
public void setProdName(String prodName) {
this.prodName = prodName;
}
public double getSellPrice() {
return sellPrice;
}
public void setSellPrice(double sellPrice) {
this.sellPrice = sellPrice;
}
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
@Override
public String toString() {
return "ex_product{" +
"prodId='" + prodId + '\'' +
", prodName='" + prodName + '\'' +
", sellPrice=" + sellPrice +
", imgUrl='" + imgUrl + '\'' +
", remark='" + remark + '\'' +
'}';
}
}
3、访问层接口
定义两个数据访问接口：
3.1、订单Dao
从订单角度查询数据，包含订单用户，订单明细列表，订单明细商品
package rui.db.Dao;
import rui.db.Model.ex_Order;
import org.springframework.stereotype.Repository;
import java.util.List;
//订单接口
@Repository(value = "ex_OrderDao")
public interface ex_OrderDao {
public ex_Order findByKey(String orderId);
public List<ex_Order> findAll();
}
3.2、订单Mapper
<?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">
<!--自动代理生成模式，namespace值必须和接口保证一致-->
<mapper namespace="rui.db.Dao.ex_OrderDao">
<!--查询单条数据-->
<select id="findByKey" resultMap="orderResult">
Select ex_order.*,
custName,
telephone,
sex,
ex_customer.remark as ex_customer_remark,
detailId,
ex_orderdetail.prodId,
buyCount,
buyPrice,
prodName,
sellPrice,
imgUrl
from ex_order
left join ex_customer on ex_order.custId = ex_customer.custId
left join ex_orderdetail on ex_order.orderId = ex_orderdetail.orderId
left join ex_product on ex_orderdetail.prodId = ex_product.prodId
where ex_order.orderId = #{orderId}
</select>
<!--查询多条数据-->
<select id="findAll" resultMap="orderResult">
Select ex_order.*,
custName,
telephone,
sex,
ex_customer.remark as ex_customer_remark,
detailId,
ex_orderdetail.prodId,
buyCount,
buyPrice,
prodName,
sellPrice,
imgUrl
from ex_order
left join ex_customer on ex_order.custId = ex_customer.custId
left join ex_orderdetail on ex_order.orderId = ex_orderdetail.orderId
left join ex_product on ex_orderdetail.prodId = ex_product.prodId
where 1 = 1
</select>
<!-- 定义订单查询结果映射 -->
<resultMap id="orderResult" type="rui.db.Model.ex_Order">
<id property="orderId" column="orderId"/>
<result property="custId" column="custId"/>
<result property="orderDate" column="orderDate"/>
<result property="totalMoney" column="totalMoney"/>
<result property="remark" column="remark"/>
<!--客户关联,通过javaType设置映射的类型-->
<association property="orderCust" javaType="rui.db.Model.ex_Customer" resultMap="customerResult">
</association>
<!--订单明细集合，通过ofType设置映射的类型-->
<collection property="detailList" ofType="rui.db.Model.ex_OrderDetail" resultMap="orderDetailResult">
</collection>
</resultMap>
<!--客户映射-->
<resultMap id="customerResult" type="rui.db.Model.ex_Customer">
<id property="custId" column="custId"/>
<result property="custName" column="custName"/>
<result property="telephone" column="telephone"/>
<result property="sex" column="sex"/>
<!--列明重复时解决方案-->
<result property="remark" column="ex_customer_remark"/>
</resultMap>
<!--订单明细映射-->
<resultMap id="orderDetailResult" type="rui.db.Model.ex_OrderDetail">
<id property="detailId" column="detailId"/>
<result property="orderId" column="orderId"/>
<result property="prodId" column="prodId"/>
<result property="buyPrice" column="buyPrice"/>
<result property="buyCount" column="buyCount"/>
<result property="remark" column="remark"/>
<!--商品关联-->
<association property="orderProd" javaType="rui.db.Model.ex_Product" resultMap="productResult">
</association>
</resultMap>
<!--商品映射-->
<resultMap id="productResult" type="rui.db.Model.ex_Product">
<id property="prodId" column="prodId"></id>
<result property="prodName" column="prodName"/>
<result property="sellPrice" column="sellPrice"/>
<result property="imgUrl" column="imgUrl"/>
</resultMap>
</mapper>
3.3、用户Dao
从用户角度查询数据，包含商品列表，订单列表
package rui.db.Dao;
import rui.db.Model.ex_Customer;
import org.springframework.stereotype.Repository;
//用户接口
@Repository(value = "ex_CustomerDao")
public interface ex_CustomerDao {
//主键查询
public ex_Customer findByKey(String custId);
}
3.4、用户Mapper
<?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">
<!--自动代理生成模式，namespace值必须和接口保证一致-->
<mapper namespace="rui.db.Dao.ex_CustomerDao">
<cache/>
<!--查询单条数据-->
<select id="findByKey" resultMap="customerResult">
SELECT ex_customer.*,
ex_order.orderId,
ex_order.orderDate,
ex_order.totalMoney,
ex_orderdetail.detailId,
ex_orderdetail.prodId,
ex_orderdetail.buyPrice,
ex_orderdetail.buyCount,
ex_product.prodName,
ex_product.sellPrice,
ex_product.imgUrl
FROM ex_customer
LEFT JOIN ex_order ON ex_customer.custId = ex_order.custId
LEFT JOIN ex_orderdetail ON ex_order.orderId = ex_orderdetail.orderId
LEFT JOIN ex_product ON ex_orderdetail.prodId = ex_product.prodId
where ex_customer.custId = #{custId}
</select>
<!-- 定义客户结果映射 -->
<resultMap id="customerResult" type="rui.db.Model.ex_Customer">
<id property="custId" column="custId"/>
<result property="custName" column="custName"/>
<result property="telephone" column="telephone"/>
<result property="sex" column="sex"/>
<result property="remark" column="remark"/>
<!--商品集合，通过ofType设置映射的类型-->
<collection property="prodList" ofType="rui.db.Model.ex_Product" resultMap="productResult">
</collection>
<!--订单集合，通过ofType设置映射的类型-->
<collection property="orderList" ofType="rui.db.Model.ex_Order" resultMap="orderResult">
</collection>
</resultMap>
<!--订单映射-->
<resultMap id="orderResult" type="rui.db.Model.ex_Order">
<id property="orderId" column="orderId"/>
<result property="custId" column="custId"/>
<result property="orderDate" column="orderDate"/>
<result property="totalMoney" column="totalMoney"/>
<result property="remark" column="remark"/>
<!--订单明细集合-->
<collection property="detailList" ofType="rui.db.Model.ex_OrderDetail" resultMap="orderDetailResult">
</collection>
</resultMap>
<!--订单明细映射-->
<resultMap id="orderDetailResult" type="rui.db.Model.ex_OrderDetail">
<id property="detailId" column="detailId"/>
<result property="orderId" column="orderId"/>
<result property="prodId" column="prodId"/>
<result property="buyPrice" column="buyPrice"/>
<result property="buyCount" column="buyCount"/>
<result property="remark" column="remark"/>
<!--商品关联-->
<association property="orderProd" javaType="rui.db.Model.ex_Product" resultMap="productResult">
</association>
</resultMap>
<!--商品映射-->
<resultMap id="productResult" type="rui.db.Model.ex_Product">
<id property="prodId" column="prodId"></id>
<result property="prodName" column="prodName"/>
<result property="sellPrice" column="sellPrice"/>
<result property="imgUrl" column="imgUrl"/>
</resultMap>
</mapper>
5、测试查询
5.1、测试1
//从订单角度查询数据，获取订单明细，订单明细关联商品 - 单记录查询
@Test
public void TestMyBatis_01() throws IOException {
//1 读取配置文件
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
//2 构建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3 构建SqlSession,并执行mapper内操作
try (SqlSession session = sqlSessionFactory.openSession()) {
//获取接口代理实现
ex_OrderDao dao = session.getMapper(ex_OrderDao.class);
ex_Order entry = dao.findByKey("T0001");
System.out.println(entry.toString());
}
System.out.println("测试完成1");
}
5.2、测试2
//从订单角度查询数据，获取订单明细，订单明细关联商品 - 多记录查询
@Test
public void TestMyBatis_02() throws IOException {
//1 读取配置文件
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
//2 构建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3 构建SqlSession,并执行mapper内操作
try (SqlSession session = sqlSessionFactory.openSession()) {
//获取接口代理实现
ex_OrderDao dao = session.getMapper(ex_OrderDao.class);
List<ex_Order> list = dao.findAll();
for (ex_Order item : list) {
System.out.println("--------------");
System.out.println(item);
}
}
System.out.println("测试完成2");
}
5.3、测试3
//从客户角度查询，能够获取客户采购的商品列表和订单列表
@Test
public void TestMyBatis_03() throws IOException {
//1 读取配置文件
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
//2 构建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3 构建SqlSession,并执行mapper内操作
try (SqlSession session = sqlSessionFactory.openSession()) {
//获取接口代理实现
ex_CustomerDao dao = session.getMapper(ex_CustomerDao.class);
ex_Customer item = dao.findByKey("C001");
System.out.println(item.toString());
}
System.out.println("测试完成3");
}
7、延迟加载
延迟加载，就是关联表数据推迟加载，如果需要关联表数据时再进行数据加载。
而Mapper内的association、collection就具备延迟加载功能。
延迟需要先从单表查询数据，关联表数据通过另一个Select再取获取。
这里以用户表为例介绍延迟加载。
7.1、开启延迟加载
myBatis全局配置文件
<!-- 全局配置参数，相关的参数参照myBatis文档 -->
<settings>
<!-- 是否开启缓存 -->
<setting name="cacheEnabled" value="true"/>
<!-- 是否开启延迟加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!--将积极加载修改成消极加载-->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
7.2、延迟加载的Mapper配置
<?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">
<!--自动代理生成模式，namespace值必须和接口保证一致-->
<mapper namespace="rui.db.Dao.ex_CustomerDao">
<cache/>
<!--延迟加载的方法-->
<select id="findByKey" resultMap="customerResult">
SELECT ex_customer.*
FROM ex_customer
where ex_customer.custId = #{custId}
</select>
<!-- 定义客户结果映射 -->
<resultMap id="customerResult" type="rui.db.Model.ex_Customer">
<id property="custId" column="custId"/>
<result property="custName" column="custName"/>
<result property="telephone" column="telephone"/>
<result property="sex" column="sex"/>
<result property="remark" column="remark"/>
<!--商品集合，通过ofType设置映射的类型-->
<collection property="prodList" ofType="rui.db.Model.ex_Product" >
</collection>
<!--订单集合，通过ofType设置映射的类型-->
<!--延迟加载订单 调用外部select，并指定要传入的字段列-->
<collection property="orderList" ofType="rui.db.Model.ex_Order" select="lazyOrderResult" column="custId" >
</collection>
</resultMap>
<!--延迟加载订单数据-->
<select id="lazyOrderResult" resultMap="orderResult">
Select ex_order.*,
detailId,
ex_orderdetail.prodId,
buyCount,
buyPrice,
prodName,
sellPrice,
imgUrl
from ex_order
left join ex_customer on ex_order.custId = ex_customer.custId
left join ex_orderdetail on ex_order.orderId = ex_orderdetail.orderId
left join ex_product on ex_orderdetail.prodId = ex_product.prodId
where ex_order.custId = #{custId}
</select>
<!--订单映射-->
<resultMap id="orderResult" type="rui.db.Model.ex_Order">
<id property="orderId" column="orderId"/>
<result property="custId" column="custId"/>
<result property="orderDate" column="orderDate"/>
<result property="totalMoney" column="totalMoney"/>
<result property="remark" column="remark"/>
<!--订单明细集合-->
<collection property="detailList" ofType="rui.db.Model.ex_OrderDetail" resultMap="orderDetailResult">
</collection>
</resultMap>
<!--订单明细映射-->
<resultMap id="orderDetailResult" type="rui.db.Model.ex_OrderDetail">
<id property="detailId" column="detailId"/>
<result property="orderId" column="orderId"/>
<result property="prodId" column="prodId"/>
<result property="buyPrice" column="buyPrice"/>
<result property="buyCount" column="buyCount"/>
<result property="remark" column="remark"/>
<!--商品关联-->
<association property="orderProd" javaType="rui.db.Model.ex_Product" resultMap="productResult">
</association>
</resultMap>
<!--商品映射-->
<resultMap id="productResult" type="rui.db.Model.ex_Product">
<id property="prodId" column="prodId"></id>
<result property="prodName" column="prodName"/>
<result property="sellPrice" column="sellPrice"/>
<result property="imgUrl" column="imgUrl"/>
</resultMap>
</mapper>
7.3、通过日志验证延迟
mybatis对接log4J
1）pom导入包
<!--单元测试-->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
2）mybatis主配置文件
log4j.properties配置内容
## 设置Logger输出级别和输出目的地 ### log4j.rootLogger=DEBUG,CONSOLE,LOGFILE log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConversionPattern=%5p [%t] - %m%n log4j.appender.LOGFILE=org.apache.log4j.FileAppender log4j.appender.LOGFILE.file=log4j.log log4j.appender.LOGFILE.appand=true log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout log4j.appender.LOGFILE.layout.ConversionPattern=%5p [%t] - %m%n
执行非加载模式日志输出：
执行懒加载模式日志输出：
浙公网安备 33010602011771号