Mybatis-03
(mybatis 关系映射，缓存机制, spring 与 mybatis 的整合,分页插件配置)
一、 映射关系的问题
1.数据库的分类(2类)
1.1关系型数据库: Mysql Oracle
表与表之前的关系:
(1) 1 VS 1 主外键
(2) 1 VS 多 使用中间表
(3) 多 VS 多 拆成两个1对多,再使用中间表
(4)
1.2非关系型数据库: Redis MongoDB...
特征就是: key - value 存储
#
2.一对一关系
实现方式 resultType/resultMap
注意: VO(value object)
DTO(data transfer object)
数据传输对象,主要用于远程调用等需要大量传输对象的地方.一般接受多表联查结果.
image.png
2.1--1对1关联查询,1个user对应1个card
1)UserMapper.xml中配置,利用resultMap方式实现
SELECT
u.id,
u.user_name,
u.user_pwd,
u.real_name,
u.nation,
u.card_id,
c.id as cid,
c.card_num
FROM
`user` AS u
LEFT JOIN card AS c ON c.id = u.card_id
2)userMapper中添加方法
public interface UserMapper {
/*
1对1关系映射
*/
public List queryUserCard();
3)mybatis中加包扫描
4)Mybatis中加测试方法
public class MyBatisTest {
UserMapper userMapper;
@Before
public void init() throws IOException {
InputStream is = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
SqlSession session = build.openSession();
userMapper = session.getMapper(UserMapper.class);
}
/*
测试1对1映射关系
*/
@Test
public void queryUserCard() {
List userDtoList = userMapper.queryUserCard();
userDtoList.stream().forEach(System.out::println);
}
测试一对一查询结果
image.png
3.一对多关系
实现方式:resultMap 实现
resultType 有局限，无法去重，需手动处理。
模拟一对多操作
1)UserMapper.xml配置 resultMap继承上例
SELECT
u.id,
u.user_name,
u.user_pwd,
u.real_name,
u.nation,
u.card_id,
c.id AS cid,
c.card_num,
a.id AS aid,
a.aname,
a.type,
a.money,
a.user_id,
a.create_time,
a.update_time,
a.remark
FROM
`user` AS u
LEFT JOIN card AS c ON c.id = u.card_id
LEFT JOIN account AS a ON a.user_id = u.id
2)UseMapper中添加一对多关联查询方法
public interface UserMapper {
/* 一对多关联查询
*/
public List queryUserCardAccount();
3)PO中UserDto中存储查询信息
注意一对多查询时,不能使用user对象,因为new两个不同user,引用地址不一致,会造成结果无法去重.
image.png
**
* 接收多表联查的结果(注意一对多查询时,不能使用user对象,因为new两个不同user,引用地址不一致)
*/
public class UserDto {
private Integer id;
private String userName;
private String userPwd;
private String realName;
private String nation;
private Integer cardId;
private User user;//代表user对象
private Integer cid;
private Integer cardNum;
private Card card;//代表card对象
private List accounts; //多个账户
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Card getCard() {
return card;
}
public void setCard(Card card) {
this.card = card;
}
public List getAccounts() {
return accounts;
}
public void setAccounts(List accounts) {
this.accounts = accounts;
}
@Override
public String toString() {
return "UserDto{" +
"id=" + id +
", userName='" + userName + '\'' +
", userPwd='" + userPwd + '\'' +
", realName='" + realName + '\'' +
", nation='" + nation + '\'' +
", cardId=" + cardId +
", user=" + user +
", cid=" + cid +
", cardNum=" + cardNum +
", card=" + card +
", accounts=" + accounts +
'}';
}
}
4)mybatisTest测试类
public class MyBatisTest {
UserMapper userMapper;
AccountDao accountDao;
@Before
public void init() throws IOException {
InputStream is = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
SqlSession session = build.openSession();
userMapper = session.getMapper(UserMapper.class);
accountDao =session.getMapper(AccountDao.class);
}
/*
测试一对多关联查询
*/
@Test
public void queryUserCardAccount() {
List userDtoList = userMapper.queryUserCardAccount();
userDtoList.stream().forEach(System.out::println);
}
测试一对多查询结果
image.png
二、 Mybatis 缓存
正如大多数持久层框架一样，MyBatis
同样提供了一级缓存和二级缓存的支持；
一级缓存
基于 PerpetualCache 的 HashMap 本地缓存(mybatis 内部实现 cache
接口)，
其存储作用域为 Session，当 Session flush 或 close 之后，该 Session
中的所有 Cache
就将清空；
二级缓存
一级缓存其机制相同，默认也是采用 PerpetualCache 的 HashMap 存储，不同在
于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache；
对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存
Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被
clear。
如果二缓存开启，首先从二级缓存查询数据，如果二级缓存有则从二级缓存中获取数据，
如果二级缓存没有，从一级缓存找是否有缓存数据，如果一级缓存没有，查询数据库。
二级缓存局限性
mybatis
二级缓存对细粒度的数据级别的缓存实现不好，对同时缓存较多条数据的缓
存，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用
户每次都能查询最新的商品信息，此时如果使用 mybatis
的二级缓存就无法实现当一
个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为 mybaits
的二
级缓存区域以 mapper
为单位划分，当一个商品信息变化会将所有商品信息的缓存数
据全部清空.
1.一级缓存
Mybatis 默认提供一级缓存，缓存范围是一个 sqlSession。在同一个
SqlSession
中，两次执行相同的 sql 查询，第二次不再从数据库查询。
原理:一级缓存采用 Hashmap 存储，mybatis
执行查询时，从缓存中查询，如果缓存中没有从数据库查询。如果该
**SqlSession 执行 clearCache()提交 或者增加 删除 修改操作，
清除缓存。
**
a.缓存存在情况 (session 未提交)
1)创建MyBatisCacheTest.java类
image.png
只有一次查询
image.png
b.刷新缓存
Session 提交 此时缓存数据被刷新
1)session.clearCahe(),清空缓存,两条sql.两次查询
2)在做增,删,改时,会清除缓存,保证查询的数据与数据库一致.
3)测试,在UserMapper.xml中插入一条sql语句
INSERT into user (`user_name`, `user_pwd`) VALUES (#{userName}, #{userPwd})
4)UserMapper中加方法
public List queryUserCardAccount();
5)MyBatisCacheTest中测试查询添加查询
public class MyBatisCacheTest {
UserMapper userMapper;
SqlSession session;
@Before
public void init() throws IOException {
InputStream is = Resources.getResourceAsStream("mybatis.xml");
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
session = build.openSession();
userMapper = session.getMapper(UserMapper.class);
}
@Test
public void queryUserByUserName() {
User user = new User();
List userList = userMapper.queryUserByUserName(user);
//session.clearCache();// 清空缓存
user.setUserName("abc");
user.setUserPwd("abc123456");
userMapper.addUser(user);
List userList2 = userMapper.queryUserByUserName(user);
List userList3 = userMapper.queryUserByUserName(user);
}
}
image.png
2.二级缓存
一级缓存是在同一个 sqlSession 中，二级缓存是在同一个 namespace
中，因此相
同的 namespace 不同的 sqlsession 可以使用二级缓存。
使用场景
• 1、 对查询频率高， 变化频率低的数据建议使用二级缓存。
• 2、 对于访问多的查询请求且用户对查询结果实时性要求不高， 此时可采用
mybatis 二级缓存技术降低数据库访问量， 提高访问速度， 业务场景比
如： 耗时较高的统计分析 sql、 电话账单查询 sql 等。
注:
cache 标签常用属性
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
说明:\
映射语句文件中的所有 select 语句将会被缓存。\
映射语句文件中的所有 insert，update 和 delete 语句会刷新缓存。\
缓存会使用 Least Recently Used(LRU，最近最少使用的)算法来收回。\
缓存会根据指定的时间间隔来刷新.\
缓存会存储 1024 个对象
1)全局文件配置mybatis.xml中加配置
2)UserMapper.xml中开启改mapper的二级缓存
3)PO对象必须支持序列号
public class Account implements Serializable {
private static final long serialVersionUID = 1L;
刷新二级缓存
操作 CUD 的 statement 时候， 会强制刷新二级缓存 即默认
flushCache="true" ， 如果想关闭设定为 flushCache="false"即可 ，
不建议关闭刷新， 因为操作更新删除修改， 关闭后容易获取脏数据。
4)二级缓存测试:
@Test
public void test03() {
SqlSession sqlSession=sqlSessionFactory.openSession();
AccountDao accountDao=sqlSession.getMapper(AccountDao.class);
Account account=accountDao.queryAccountById(1);
System.out.println(account);
sqlSession.close();
SqlSession sqlSession2=sqlSessionFactory.openSession();
AccountDao accountDao2=sqlSession2.getMapper(AccountDao.class);
accountDao2.queryAccountById(1);
sqlSession.close();
}
image.png
3.分布式缓存 ehcache
如果有多台服务器 ， 不使用分布缓存， 缓存的数据在各个服务器单独存储，
不方便
系统 开发。 所以要使用分布式缓存对缓存数据进行集中管理。
mybatis 本身来说是无法实现分布式缓存的，
所以要与分布式缓存框架进行整合。
EhCache 是一个纯 Java 的进程内缓存框架， 具有快速、 精干等特点;Ehcache
是一种广泛使用的开源 Java 分布式缓存。 主要面向通用缓存,Java EE
和轻量级容器。 它具有内存和磁盘存储，
缓存加载器,缓存扩展,缓存异常处理程序,一个 gzip 缓存 servlet 过滤器,支持
REST 和 SOAP api 等特点。
3.1添加依赖 pom.xml
org.slf4j
slf4j-log4j12
1.7.12
net.sf.ehcache
ehcache-core
2.4.4
org.mybatis.caches
mybatis-ehcache
1.0.3
3.2配置缓存接口
mybatis.xml中配置开启缓存
UserMapper.xml中使用分布式缓存标签
3.3在resources文件夹中新增ehcache.xml
xsi:noNamespaceSchemaLocation="../bin/ehcache.xsd">
3.4测试MyBatisCacheTest
@Test
public void queryUserCardAccount() throws IOException {
userMapper.queryUserCardAccount();
userMapper.queryUserCardAccount();
session.close();
session = build.openSession();
userMapper = session.getMapper(UserMapper.class);
userMapper.queryUserCardAccount();
}
3.4测试结果
image.png
三． Spring 与 Mybatis 集成
1新建 maven webapp 项目
新建 maven 项目 spring_mybatis
目录结构如下:
主目录包:com.shsxt.dao、com.shsxt.mapper、com.shsxt.service、
com.shsxt.service.impl
测试包：spring_mybatis
image.png
2引入依赖包
打开 pom.xml 开始添加依赖包
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.0.0
com.shsxt
mybatis_spring_jc
1.0-SNAPSHOT
mybatis_spring_jc
UTF-8
1.8
1.8
junit
junit
4.12
test
org.springframework
spring-context
4.3.2.RELEASE
org.springframework
spring-test
4.3.2.RELEASE
org.springframework
spring-jdbc
4.3.2.RELEASE
org.springframework
spring-tx
4.3.2.RELEASE
org.aspectj
aspectjweaver
1.8.9
c3p0
c3p0
0.9.1.2
org.mybatis
mybatis
3.4.1
org.mybatis
mybatis-spring
1.3.0
mysql
mysql-connector-java
5.1.39
org.slf4j
slf4j-log4j12
1.7.2
org.slf4j
slf4j-api
1.7.2
com.github.pagehelper
pagehelper
4.1.0
spring_mybatis
src/main/resources
src/main/java
**/*.properties
**/*.xml
**/*.tld
false
3配置资源文件
a) Spring 文件 spring.xml
b) Mybatis 文件 mybatis.xml
c) 数据库连接 properties 文件 db.properties
d) 日志输出文件 log4j.properties
1).spring.xml 文件配置
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
2).mybatis.xml 文件配置
/p>
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
value="pageNum=start;pageSize=limit;pageSizeZero=zero;reasonable=heli;count=countsql" />
--------+
3).db.properties 文件配置(对于其它数据源属性配置， 见 c3p0
配置讲解， 这里采用默认属性配置)
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456
4).log4j.properties便于控制台日志输出
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
4.开始写实体类PO---User类
+----------------------------------------------------------+
package com.shsxt.po;
import java.io.Serializable;
/**
* Created by xlf on 2019/3/4.
*/
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String userName;
private String userPwd;
private String realName;
private String nation;
private Integer cardId;
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 getUserPwd() {
return userPwd;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getNation() {
return nation;
}
public void setNation(String nation) {
this.nation = nation;
}
public Integer getCardId() {
return cardId;
}
public void setCardId(Integer cardId) {
this.cardId = cardId;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", userName='" + userName + '\'' +
", userPwd='" + userPwd + '\'' +
", realName='" + realName + '\'' +
", nation='" + nation + '\'' +
", cardId=" + cardId +
'}';
}
}
5.接口与映射文件定义--UserDao接口
package com.shsxt.dao;
import com.shsxt.po.User;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* Created by xlf on 2019/7/11.
*/
@Repository
public interface UserDao {
public User queryUserById(Integer id);
public List queryUserList();
}
6.UserMapper.xml配置(注意：此时映射文件命名空间定义要符合规则：接口包名.接口类名,否则不按规则出牌，测试会报错，然后你就蒙圈了！！！)
/p>
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
SELECT * from user where id=#{id}
SELECT * from user
7.UserService 接口类与实现类定义
此时直接注入我们的 UserDao 接口即可，然后直接调用
其方法，事已至此，离成功仅差一步！
*/
@Service
public class UserService {
@Autowired
private UserDao userDao;
public User queryUserById(Integer id){
return userDao.queryUserById(id);
}
public PageInfo queryUserList(Integer pageNum, Integer pageSize){
// 1. 设置分页查询参数
PageHelper.startPage(pageNum, pageSize);
// 2. 执行原有查询
List userList = userDao.queryUserList();
// 3. 构建分页查询对象
PageInfo pageInfo = new PageInfo<>(userList);
return pageInfo;
}
}
**8.junit 测试
**因为与 spring 框架集成，我们采用 spring 框架测试 spring Test
/**
* 单元测试,测试环境搭建
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class UserServiceTest {
@Autowired
private UserService userService;
/*
测试查询对象是否成功
*/
@Test
public void queryUserById() throws Exception {
User user =userService.queryUserById(6);
System.out.println(user);
}
}
测试结果
image.png
四． mybatis 分页插件的配置
1.修改 pom 文件， 添加分页 jar 包依赖
com.github.pagehelper
pagehelper
4.1.0
2.修改 mybatis.xml 文件,引入分页插件
value="pageNum=start;pageSize=limit;pageSizeZero=zero;reasonable=heli;count=countsql" />
3.UserDao 接口， UserMapper.xml 添加对应方法与实现
sql(参考上例方法已写入)
@Repository
public interface UserDao {
public User queryUserById(Integer id); //查询用户,根据id
public List queryUserList();
}
UserMapper.xml 添加
SELECT * from user
4.对应 UserService 接口添加分页查询方法
/* *
测试分页查询
*/
public PageInfo queryUserList(Integer pageNUm ,Integer pageSize){
//1.设置分页查询参数
PageHelper.startPage(pageNUm,pageSize);
//2执行原有查询
List userList =userDao.queryUserList();
//3构建分页查询对象
PageInfo pageInfo =new PageInfo<>(userList);
return pageInfo;
}
5.单元测试类
/**
* 测试分页查询
*/
@Test
public void queryUserList() throws Exception {
PageInfo pageInfo = userService.queryUserList(2, 5);
System.out.println("total: "+pageInfo.getTotal());
System.out.println("pages: "+pageInfo.getPages());
List userList = pageInfo.getList();
userList.stream().forEach(System.out::println);
}
6.测试分页效果
image.png
五． Mybatis 代码自动化生成
官网地址: http://generator.sturgeon.mopaas.com/index.html
对于代码自动化生成，我们借助 maven 插件来实现 mybatis crud 基本代码的
生成。
配置步骤如下:
1.Pom.xml 文件的修改
添加 mybatis 插件配置
org.mybatis.generator
mybatis-generator-maven-plugin
1.3.2
src/main/resources/generatorConfig.xml
true
true
2.generatorConfig.xml 配置
需添加到资源包下 src/mian/resources
/p>
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
3.配置运行命令参数
window--->preferences-->java-->installed jres--->edit
在弹出的对话框中 修改
jre 运行参数 -Dmaven.multiModuleProjectDirectory=$**MAVEN_HOME
**MAVEN_HOME 为你配置的环境变量名
image.png
image.png
以上配置如果配置完成
4.选中项目 run as -->maven build 在出现的对话框 Goals 输入框中
输入一下命令:
**mybatis-generator:generate
**然后点击 run 运行 如果你之前额配置没有错误，就会启动插件
自动生成你想要的代
码啦。
结果如下:
image.png
image.png
六． Mybatis Dao 层、 Service 层封装
重复性的劳动，就要通过封装来解决！
image.png
1.Dao 层 BaseMapper 方法定义
package com.shsxt.base;
import org.springframework.dao.DataAccessException;
import java.util.List;
import java.util.Map;
public interface BaseMapper {
/**
* 添加记录不返回主键
* @param entity
* @return
* @throws DataAccessException
*/
public int insert(T entity) throws DataAccessException;
/**
*
* @param entities
* @return
* @throws DataAccessException
*/
public int insertBatch(List entities) throws DataAccessException;
/**
* 查询总记录数
* @param map
* @return
*/
@SuppressWarnings("rawtypes")
public int queryCountByParams(Map map) throws DataAccessException;
/**
* 查询记录 通过id
* @param id
* @return
*/
public T queryById(Integer id) throws DataAccessException;
/**
* 分页查询记录
* @param baseQuery
* @return
*/
public List queryForPage(BaseQuery baseQuery) throws DataAccessException;
/**
* 查询记录不带分页情况
* @param map
* @return
*/
@SuppressWarnings("rawtypes")
public List queryByParams(Map map) throws DataAccessException;
/**
* 更新记录
* @param entity
* @return
*/
public int update(T entity) throws DataAccessException;
/**
* 批量更新
* @param map
* @return
* @throws DataAccessException
*/
public int updateBatch(Map map) throws DataAccessException;
/**
* 删除记录
* @param id
* @return
*/
public int delete(Integer id) throws DataAccessException;
/**
* 批量删除
* @param ids
* @return
*/
public int deleteBatch(int[] ids) throws DataAccessException;
}
2. Service 层 BaseService 定义与实现
package com.shsxt.base;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
import java.util.Map;
public abstract class BaseService {
@Autowired
public BaseMapper baseMapper;
/**
* 添加记录
* @param entity
* @return
* @throws Exception
*/
public int insert(T entity) throws Exception{
int result= baseMapper.insert(entity);
return result;
}
/**
* 批量添加记录
* @param entities
* @return
* @throws Exception
*/
public int insertBatch(List entities) throws Exception{
return baseMapper.insertBatch(entities);
}
/**
* 根据参数统计记录数
* @param map
* @return
* @throws Exception
*/
@SuppressWarnings("rawtypes")
public int queryCountByParams(Map map)throws Exception{
return baseMapper.queryCountByParams(map);
}
/**
* 查询记录通过id
* @param id
* @return
* @throws Exception
*/
public T queryById(Integer id)throws Exception{
AssertUtil.isNull(id, "记录id非空!");
return baseMapper.queryById(id);
}
/**
* 分页查询
* @param baseQuery
* @return
* @throws Exception
*/
public PageInfo queryForPage(BaseQuery baseQuery)throws Exception{
PageHelper.startPage(baseQuery.getPageNum(),baseQuery.getPageSize());
List list= baseMapper.queryForPage(baseQuery);
PageInfo pageInfo=new PageInfo(list);
return pageInfo;
}
/**
*
* @param map
* @return
* @throws Exception
*/
@SuppressWarnings("rawtypes")
public List queryByParams(Map map)throws Exception{
return baseMapper.queryByParams(map);
}
/**
* 查询记录
* @param entity
* @return
* @throws Exception
*/
public int update(T entity)throws Exception{
return baseMapper.update(entity);
}
/**
* 批量更新
* @param map
* @return
* @throws Exception
*/
@SuppressWarnings("rawtypes")
public int updateBatch(Map map) throws Exception{
return baseMapper.updateBatch(map);
}
/**
* 删除记录
* @param id
* @return
* @throws Exception
*/
public int delete(Integer id) throws Exception{
// 判断 空
AssertUtil.isNull(id, "记录id非空！");
AssertUtil.isNull(queryById(id), "待删除的记录不存在!");
return baseMapper.delete(id);
}
/**
* 批量删除
* @param ids
* @return
*/
public int deleteBatch(int[] ids) throws Exception{
AssertUtil.isNull(ids.length==0,"请至少选择一项记录!");
return baseMapper.deleteBatch(ids);
}
}
3. BaseQuery 类封装
package com.shsxt.base;
public class BaseQuery {
/**
* 分页页码
*/
private int pageNum=1;
/**
* 每页记录数
*/
private int pageSize=10;
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
}
4. 参数异常处理AssertUtil
package com.shsxt.base;
public class AssertUtil {
/**
* 表达式结果真时判断
* @param expression
* @param msg
*/
public static void isTrue(Boolean expression,String msg){
if(expression){
throw new ParamException(msg);
}
}
public static void isTure(Boolean expression){
if(expression){
throw new ParamException("参数异常");
}
}
/**
* 参数为空时
* @param object
* @param msg
*/
public static void isNull(Object object,String msg){
if(object==null){
throw new ParamException(msg);
}
}
/**
* 参数不空时
* @param object
* @param msg
*/
public static void notNull(Object object,String msg){
if(object!=null){
throw new ParamException(msg);
}
}
}
5. .异常类定义ParamException
package com.shsxt.base;
/**
* 参数异常类
* @author Administrator
*
*/
public class ParamException extends RuntimeException{
/**
*
*/
private static final long serialVersionUID = -5962296753554846774L;
/**
* 错误状态码
*/
private int errorCode;
public ParamException() {
}
/**
* 错误消息
* @param msg
*/
public ParamException(String msg) {
super(msg);
}
public ParamException(int errorCode,String msg){
super(msg);
this.errorCode=errorCode;
}
public int getErrorCode() {
return errorCode;
}
public void setErrorCode(int errorCode) {
this.errorCode = errorCode;
}
}
6. mybatis-generator:generate自动生成你想要的代码
7.更改UserMapper接口继承BaseMapper
@Repository
public interface UserMapper extends BaseMapper {
}
8.修改UserMapper.xml配置,加入分页配置,修改方法名
id, user_name, user_pwd, real_name, nation, card_id
select
from user
where id = #{id,jdbcType=INTEGER}
delete from user
where id = #{id,jdbcType=INTEGER}
insert into user
id,
user_name,
user_pwd,
real_name,
nation,
card_id,
#{id,jdbcType=INTEGER},
#{userName,jdbcType=VARCHAR},
#{userPwd,jdbcType=VARCHAR},
#{realName,jdbcType=VARCHAR},
#{nation,jdbcType=VARCHAR},
#{cardId,jdbcType=INTEGER},
update user
user_name = #{userName,jdbcType=VARCHAR},
user_pwd = #{userPwd,jdbcType=VARCHAR},
real_name = #{realName,jdbcType=VARCHAR},
nation = #{nation,jdbcType=VARCHAR},
card_id = #{cardId,jdbcType=INTEGER},
where id = #{id,jdbcType=INTEGER}
SELECT * from user
9.新建UserService extends BaseService ,调用UserMapper
@Service
public class UserService extends BaseService {
@Autowired
private UserMapper userMapper;
}
10.新建测试类,测试查询功能,与分页功能.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void queryUserById() throws Exception {
User user = userService.queryById(6);
System.out.println(user);
}
@Test
public void queryUserList() throws Exception {
BaseQuery baseQuery = new BaseQuery();
baseQuery.setPageNum(1);
baseQuery.setPageSize(3);
PageInfo pageInfo = userService.queryForPage(baseQuery);
pageInfo.getList().stream().forEach(System.out::println);
}
结果:
image.png
扫一扫
78
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
