基础知识:
- JDBC
- Mysql
- Java基础
- Maven
- Junit
框架:是有配置文件的。最好的方式:看官网文档
1、简介
1.1、什么是 MyBatis?
- MyBatis 是一款优秀的持久层框架
- 它支持定制化 SQL、存储过程以及高级映射。
- MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
- MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
如何获得MyBatis?
-
Maven仓库
-
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.3</version> </dependency>
-
github:https://github.com/mybatis/mybatis-3/releases
-
中文文档:https://mybatis.org/mybatis-3/zh/index.html
1.2、持久化
数据持久化
- 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
- 内存:断电即失
- 数据库(JDBC),io文件持久化。
- 生活:冷藏、罐头。
为什么需要持久化?
- 有一些对象,不能让他丢掉。
1.3、持久层
Dao层、Service层、Controller层…
- 完成持久化工作的代码块
- 层界限十分明显
1.4、为什么需要Mybatis?
-
帮助程序员将数据存入到数据库中。
-
方便
-
传统的JDBC代码太复杂了。简化、框架、自动化。
-
不用Mybatis也可以。更容易上手。技术没有高低之分
-
优点:
- 简单易学
- 灵活
- sql和代码的分离,提高了可维护性。
- 提供映射标签,支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签,支持对象关系组建维护
- 提供xml标签,支持编写动态sql。
最重要的一点:使用的人多!
Spring SpringMVC SpringBoot
2、第一个mybatis程序
思路 搭建环境----》导入Mybatis–》编写代码—》测试
2.1搭建环境
数据库创建
CREATE DATABASE mybatis;
CREATE table `user`(
`id` INT(10) not NULL,
`name` VARCHAR(30) DEFAULT NULL,
`pass` VARCHAR(30) DEFAULT NULL,
PRIMARY key(id)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO user (id,name,pass) VALUES(1,"小哥","admin")
INSERT INTO user (id,name,pass) VALUES(2,"大哥","admin1")
INSERT INTO user (id,name,pass) VALUES(3,"二哥","admin2")
INSERT INTO user (id,name,pass) VALUES(4,"三哥","admin2")
pom依赖导入
<dependencies>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
2.2、创建一个子模块
编写mybatis核心配置文件
mybatis-config.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核心配置文件-->
<configuration>
<!--environments配置环境组-->
<!--default默认环境-->
<environments default="development">
<!--environment单个环境-->
<environment id="development">
<!--transactionManager配置事务管理器-->
<transactionManager type="JDBC"/>
<!--配置连接池-->
<dataSource type="POOLED">
<!--jdbc驱动-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!--数据库地址-->
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true"/>
<!--账号-->
<property name="username" value="root"/>
<!--密码-->
<property name="password" value="toor"/>
</dataSource>
</environment>
</environments>
<!--映射文件注册-->
<mappers>
<mapper resource="org/mybatis/example/BlogMapper.xml"/>
</mappers>
</configuration>
编写mybatis工具类
package com.x1a0g.utils;
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 java.io.IOException;
import java.io.InputStream;
public class MybatisUtil {
private static SqlSessionFactory sqlSessionFactory;
static {
try {
//这个是mybatis的配置文件的路劲
String source = "mybatis-config.xml";
//Resources.getResourceAsStream(source) 是mmybatis自带的io,拿到输入流
InputStream resourceAsStream = Resources.getResourceAsStream(source);
//最后拿到sqlSessionFactory这个工厂
sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//从sqlSessionFactory这个工厂创建一个SqlSession返回回去
//既然有了 SqlSessionFactory,顾名思义,我们就可以从中获得 SqlSession 的实例了。
// SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。
// 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
public static SqlSession getSqlsession(){
return sqlSessionFactory.openSession();
}
}
编写代码
编写mapper
package com.x1a0g.mapper;
import com.x1a0g.entity.User;
import java.util.List;
public interface UserMapper {
List<User> getAllUser();
}
编写mapper的是实现类(接口实现类由原来的UserImpl转变为一个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是命名空间,就是我映射的usermapper 必须是全限定名-->
<mapper namespace="com.x1a0g.mapper.UserMapper">
<!--id对应usermapper的方法名 resultType去写集合中的泛型 -->
<select id="getAllUser" resultType="com.x1a0g.entity.User">
select * from user;
</select>
</mapper>
编写测试单元
注意在maven项目中test测试单元一定要和开发一一对应 这是一种规范
package com.x1a0g.mapper;
import com.x1a0g.entity.User;
import com.x1a0g.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserMapperTest {
@Test
public void test(){
//第一步:获得SqlSession对象
SqlSession sqlsession = MybatisUtil.getSqlsession();
//执行SQL
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
List<User> allUser = mapper.getAllUser();
for (User user : allUser) {
System.out.println(user);
}
}
}
然后运行时候出现的操蛋问题两个问题
org.apache.ibatis.binding.BindingException 这个异常一定是没有在mybatis-config文件中注册
MapperRegistry是什么?
核心配置文件中注册mappers
java.lang.ExceptionInInitializerError:初始化异常
这种情况是由于在maven中的资源过滤 问题所导致的 解决办法
<!--在build中配置resources,来防止我们资源导出失败的问题-->
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
步骤总结
- 首先编写工具类
- 编写工具类时候发现需要配置文件,去resources中去写mybatis-config.xml 配置文件
- 定义实体类
- 定义mapper接口(相当于jdbc时候的userdao接口)
- 使用xml去写mapper接口的实现(相当于userdaoimpl)
- 写测试单元
- 在pom中需要添加资源过滤
3、增删查改(CRUD)
usermapper接口
package com.x1a0g.mapper;
import com.x1a0g.entity.User;
import java.util.List;
/**
* 原来的userdao
*/
public interface UserMapper {
//获取所有用户
List<User> getUserAll();
//根据id查用户
User queryById(int i);
//增加一个用户
int insertUser(User user);
//修改一个用户的信息
int updateUser(User user);
//根据id删除一个用户
int deleteUser(Integer uid);
}
usermapper的实现
<?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 id resultType parameterType-->
<mapper namespace="com.x1a0g.mapper.UserMapper">
<select id="getUserAll" resultType="com.x1a0g.entity.User">
select * from user;
</select>
<select id="queryById" resultType="com.x1a0g.entity.User" parameterType="int">
select * from user where id=#{id};
</select>
<insert id="insertUser" parameterType="com.x1a0g.entity.User">
insert into user values (#{id},#{name},#{pass});
</insert>
<update id="updateUser" parameterType="com.x1a0g.entity.User" >
update user set name=#{name},pass=#{pass} where id=#{id}
</update>
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id}
</delete>
</mapper>
测试单元编写
package com.x1a0g.mapper;
import com.x1a0g.entity.User;
import com.x1a0g.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserMapperTest {
@Test
public void test01(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
//这句就好比 我的多态 父类的UserMapper调用子类
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
List<User> userAll = mapper.getUserAll();
for (User user : userAll) {
System.out.println(user);
}
sqlsession.close();
}
@Test
public void queryById(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
User user = mapper.queryById(2);
System.out.println(user);
sqlsession.close();
}
//增删改必须提交事务
@Test
public void insertUserTest(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
mapper.insertUser(new User(5,"啊啊啊啊","123456"));
sqlsession.commit();
sqlsession.close();
}
@Test
public void updateUserTest(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
mapper.updateUser(new User(5,"heheheheh","00000"));
sqlsession.commit();
sqlsession.close();
}
@Test
public void deleteUserTest(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
mapper.deleteUser(5);
sqlsession.commit();
sqlsession.close();
}
}
参数说明:
- namespace:就是要实现接口的全限定名 这的话就是com.x1a0g.mapper.UserMapper
- id参数 :就是接口中的方法名 比如 id=“deleteUser” 表示实现的接口中的方法名
- resultType:方法的返回值类型
- parameterType:方法的参数类型
- 当参数为int型的时候可以默认忽略
update user set name=#{name},pass=#{pass} where id=#{id}
在mybatis中 #{} 代表取值 对象中的属性可以直接拿到
注意:增删改 必须提交事务
万能的map参数
假设,我们的实体类,或者数据库中的表,字段或者参数过多,我们应当考虑使用Map!
当接口中的方法出现多个参数的时候 可以考虑使用map,具体看下面的例子
//登陆的方法
User login(Map<String,Object> map);
usermapper实现
<select id="login" parameterType="map" resultType="com.x1a0g.entity.User">
select * from mybatis.user where name=#{name} and pass= #{pass};
</select>
测试单元的写法
//用登陆来测试map集合
@Test
public void loginTest(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
Map<String,Object> map = new HashMap<String, Object>();
map.put("name","小哥");
map.put("pass","admin");
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
User login = mapper.login(map);
System.out.println(login);
sqlsession.close();
}
我在查询时候的参数#{name} #{pass}都是map的key值
Map传递参数,直接在sql中取出key即可!【parameterType=“map”】
对象传递参数,直接在sql中取对象的属性即可!【parameterType=“Object”】
只有一个基本类型参数的情况下,可以直接在sql中取到!
多个参数用Map,或者注解!
模糊查询
有两种实现方式,第一种就是在前面去传%%
//模糊查询
List<User> queryByName(String name);
<select id="queryByName" resultType="com.x1a0g.entity.User">
select * from user where name like #{name};
</select>
//模糊查询
@Test
public void queryByName(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
List<User> userList = mapper.queryByName("%哥%");
userList.forEach(user -> {System.out.println(user);});
sqlsession.close();
}
第二种是在SQL语句写死
select * from mybatis.user where name like "%"#{name}"%"
4、配置解析
核心配置文件
- mybatis-config.xml
- MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息
configuration(配置)
properties(属性)
settings(设置)
typeAliases(类型别名)
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)
databaseIdProvider(数据库厂商标识)
mappers(映射器)
环境配置(environments)
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
学会使用配置多套运行环境!
<environments default="development"> <!--这个default="development" 表示默认选中development这套环境 我们可以改成test就是下面的-->
//这是一套环境 名字是development
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="toor"/>
</dataSource>
</environment>
//这是一套环境 名字是test
<environment id="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/xzsc3"/>
<property name="username" value="root"/>
<property name="password" value="toor"/>
</dataSource>
</environment>
</environments>
MyBatis默认的事务管理器就是JDBC,连接池:POOLED
属性properties
注意在xml中各个标签之间是可以定义先后关系的
所以properties一定是在configuration中一定是在最前面
db.properties定义如下
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis
user=root
pass=toor
在mybaties-config.xml中的使用方式如下
<properties resource="db.properties" />
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${user}"/>
<property name="password" value="${pass}"/>
</dataSource>
</environment>
当这个标签这么使用的时候 文件中定义的优先级一定是高于外面标签中的 比如 外面的密码写错,文件中是对的,那么依旧可以使用,反过来就不行了
类型别名(typeAliases)
- 类型别名是为 Java 类型设置一个短的名字。
- 存在的意义仅在于用来减少类完全限定名的冗余。
两种实现方式 (typeAliases在配置文件中的位置是在第三位,为之一定放对,没有setting的话直接放在前面就ok )
使用typeAliass来完成 ,好处是可以自己定义名字
给com.x1a0g.entity.User 起别名
第二种时使用包名来进行搜索,会把搜到的类的名字默认设置为类名且首字 母小写
<typeAliases> <package name="com.x1a0g.entity"/> </typeAliases>
加入这时候我的entity包下有个User类 他的别名就是user
加入这时候我非要用我自己的名字,可以加注解:
@Alias("hehe") public class User {}
设置(setting)
settting相当重要,应该写在配置文件的第二位
日志这个必须记住
<!-- 开启驼峰映射 ,为自定义的SQL语句服务-->
<!--设置启用数据库字段下划线映射到java对象的驼峰式命名属性,默认为false-->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
映射器(mappers)
官网有四种实现方式
方式一 【推荐使用】
<!-- 使用相对于类路径的资源引用 -->
<mappers>
<mapper resource="com/x1a0g/dao/UserMapper.xml"/>
</mappers>
方式二
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
- 接口和他的mapper配置文件必须同名
- 接口和他的mapper配置文件必须在同一个包下
方式三
<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
<package name="org.mybatis.builder"/>
</mappers>
- 接口和他的mapper配置文件必须同名
- 接口和他的mapper配置文件必须在同一个包下
生命周期和作用域
生命周期,和作用域是至关重要的,因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder
- 一旦创建了SqlSessionFactory,就不再需要它了
- 局部变量
SqlSessionFactory:
- 可以想象为:数据库连接池
- SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。
- 因此SqlSessionFactory的最佳作用域是应用作用域。(application)
- 最简单的就是使用 单例模式 或者静态单例模式
SqlSession
- 连接到连接池的一个请求!
- SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
- 用完之后需要赶紧关闭,否则会占用资源
这里的每一个Mapper,就代表一个具体的业务!
5、解决实体类的属性名和字段名不一样的问题
简单的测试下问题
之前在写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="com.x1a0g.dao.UserMapper">
<select id="queryById" resultType="user">
select * from user where id=#{id};
</select>
</mapper>
假如说我们有一个场景,当我定义的实体类,并不是和数据库中的字段所对应的的,就会出现这种问题
public class User {
private Integer id;
private String username;
private String password;
}
/*
数据库的字段是 id user pass
输出结果:
User{id=1, username='null', password='null'}
*/
有个类型处理器是这么工作的
//select * from mybatis.user where id = #{id} //类型处理器 //select id,name,pwd from mybatis.user where id = #{id}
第一个解决办法 起别名
select id,name as username ,pwd as password from mybatis.user where id = #{id}
这么办是可以的 但是不太行
第二个解决办法 resultMap
专业名词 :结果集映射
我们可以把数据库的字段和我们实体类的属性构建映射关系 例如
id======》id
user===》username
pass====>password
左边是数据库的,右边是实体类的 那么就解决了这个问题
代码如下
<mapper namespace="com.x1a0g.dao.UserMapper">
<resultMap id="userMap" type="user" >
<!--column数据库中的字段,property实体类中的属性-->
<result column="id" property="id" />
<result column="name" property="username" />
<result column="pass" property="password" />
</resultMap>
<select id="queryById" resultMap="userMap">
select * from user where id=#{id};
</select>
</mapper>
-
其实原本对应的可以省略不写 ,只需要给不一样的建立映射关系即可
-
resultMap
元素是 MyBatis 中最重要最强大的元素 -
ResultMap 的设计思想是,对于简单的语句根本不需要配置显式的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。
-
ResultMap
最优秀的地方在于,虽然你已经对它相当了解了,但是根本就不需要显式地用到他们。 -
如果世界总是这么简单就好了。(官网名言)
6、日志
日志工厂
STDOUT_LOGGING
这个东西是自带的标准日志输出形式 配置在mybatis的配置文件中方式如下
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
但是这种方式并不是经常用到的,常用的是log4j
log4j
- Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
- 我们也可以控制每一条日志的输出格式
- 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
- 通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
使用步骤
- 先导入依赖
<dependencies> <!-- https://mvnrepository.com/artifact/log4j/log4j --> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> </dependencies>
- 编辑配置文件
#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码 log4j.rootLogger=DEBUG,console,file #控制台输出的相关设置 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.Threshold=DEBUG log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=[%c]-%m%n #文件输出的相关设置 log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File=./log/x1a0g.log log4j.appender.file.MaxFileSize=10mb log4j.appender.file.Threshold=DEBUG log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n #日志输出级别 log4j.logger.org.mybatis=DEBUG log4j.logger.java.sql=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.ResultSet=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG
简单使用
import org.apache.log4j.Logger; //包千万别搞错
private static Logger logger = Logger.getLogger(UserMapperTes.class); //这在哪类用就写哪个
//日志级别
logger.info("aaaaaaaaa");
logger.error("bbbbbbbbbbbb");
logger.debug("dddddddddddd");
7、分页
limit进行分页
limit本质其实是使用了sql语句实现了分页
- 编写接口
//limit分页,多练习map的用法
List<User> getAllUserByLimit(Map<String,Integer> map);
- 编写mapper.xml
<resultMap id="userMap" type="user">
</resultMap>
<select id="getAllUserByLimit" parameterType="map" resultMap="userMap">
select * from user limit #{startIndex},#{pageSize}
</select>
- 测试
@Test
public void limtTset(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
HashMap<String, Integer> map = new HashMap<>();
map.put("startIndex",0);
map.put("pageSize",2);
List<User> userList = mapper.getAllUserByLimit(map);
userList.forEach(System.out::println);
sqlsession.close();
}
rowbounds进行分页
rowbounds本质是使用java代码的面向对象思想进行了分页
- 编写接口
//rowbounds进行分页
List<User> getAllUserRows(); //拿到全部数据
- 编写mapper.xml配置文件
<select id="getAllUserRows" resultMap="userMap">
select * from user;
</select>
- 测试
@Test
public void rowBonds(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
// UserMapper mapper = sqlsession.getMapper(UserMapper.class);
RowBounds rowBounds = new RowBounds(0,2);//0是起始位置,2是页面大小
List<User> allUserRows = sqlsession.selectList("com.x1a0g.dao.UserMapper.getAllUserRows",null,rowBounds);
allUserRows.forEach(System.out::println);
sqlsession.close();
}
8、使用注解开发
面向接口编程
面向接口编程的根本原因:解耦,可拓展,提高复用,分层开发中、上层不用管具体的实现,大家都遵守共同的标准,使得开发变得容易,规范性好
使用注解进行开发
- 编写接口,不用去写配置文件了
//获取所有员工
@Select("select * from user")
List<User> getAllUser();
这种方式就是注解的方式来进行开发
这种方式的弊端就是必须严格按照数据库表的字段来设计实体类 ,如果有不一样的会出现这种情况
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
==> Preparing: select * from user
==> Parameters:
<== Columns: id, name, pass
<== Row: 1, 小哥, admin
<== Row: 2, 大哥, admin1
<== Row: 3, 二哥, admin2
<== Row: 4, 三哥, admin2
<== Total: 4
User{id=1, name='小哥', password='null'} //和数据库对应不上的字段为null
User{id=2, name='大哥', password='null'}
User{id=3, name='二哥', password='null'}
User{id=4, name='三哥', password='null'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
Returned connection 592617454 to pool.
Process finished with exit code 0
使用注解的增删查改
- 接口的配置
//根据id查询员工
@Select("select * from user where id=#{uid}")
User getUserById(@Param("uid") int id);
//增加一个用户
@Insert("inset into user(id,user,pass) values(#{id},#{user},#{password})")
int addUser(User user);
//修改一个用户
@Update("update user set user=#{user},pass=#{password} where id=#{id}")
int updateUser(User user);
//删除一个用户
@Delete("delete from user where id=#{uid}")
int deleteUser(@Param("uid") int id);
- 测试
public interface UserMapper {
//获取所有员工
@Select("select * from user")
List<User> getAllUser();
//根据id查询员工
@Select("select * from user where id=#{uid}")
User getUserById(@Param("uid") int id);
//增加一个用户
@Insert("insert into user(id,name,pass) values(#{id},#{name},#{password})")
int addUser(User user);
//修改一个用户
@Update("update user set name=#{name},pass=#{password} where id=#{id}")
int updateUser(User user);
//删除一个用户
@Delete("delete from user where id=#{uid}")
int deleteUser(@Param("uid") int id);
}
【注意:我们必须要将接口注册绑定到我们的核心配置文件中!】
对于注解 @Param()注解
-
基本类型和string类型必须加上
-
引用用类型不需要加
-
多个参数时候使用 :
@Select("select * from user where id=#{uid} and name=#{uname}") User getUserById(@Param("uid") int id,@Param("uname")string name);
-
如果只有一个基本类型的话,可以忽略,但是建议都加上
-
在SQL中引用的就是这里的@Param()中设定的属性名
#{} ${}区别
#{} 是安全的 参数与编译的 就是 priperedstatment
${} 是不安全的,不会预编译的 就是 statment
9、lombock常用注解
使用前需要导入依赖
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
<scope>provided</scope>
</dependency>
常用注解
@Data //无参构造,get、set、toSring、hashcode、equals
@AllArgsConstructor //有参
@NoArgsConstructor //无参
@ToString //tostring
@EqualsAndHashCode //hashcode
加入想实现方法重载 自己去实体类里头写就ok
10、复杂查询
多对一
拿欣知三期的来举例子
package com.xzsc.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.io.Serializable;
/**
* (Shop)实体类
*
* @author x1a0g
* @since 2020-03-24 21:09:00
*/
@Data
public class Shop {
private Integer shopId;
private String shopName;
private Double shopPrice;
private Double shopVipPrice;
private Integer shopFlag;
private Integer adminId;
private Integer shopNum;
private Shoptype shoptype;
}
package com.xzsc.entity;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* (Shoptype)实体类
*
* @author x1a0g
* @since 2020-03-24 21:10:10
*/
@Data
public class Shoptype implements Serializable {
private Integer shoptypeId;
private String shopTypename;
private List<Shop> shopList;
}
多个商品对应一个商品类型,所以把商品类型封装到了商品中
然后编写对应的mapper
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xzsc.dao.ShopMapper">
<!-- 正常的给shop去映射结果集
但是shop中封装的shoptype,就去在把shoptype封装一下
关键字association
-->
<resultMap id="shopMap" type="shop">
//id表示主键 其他用result
<id column="shop_id" property="shopId" />
<result column="shop_name" property="shopName" />
<result column="shop_price" property="shopPrice" />
<result column="shop_vip_price" property="shopVipPrice" />
<result column="shop_flag" property="shopFlag" />
<result column="admin_id" property="adminId" />
<result column="shop_num" property="shopNum" />
//这的property 是 shop中的对象名 javaType是shoptype这个对象的类型
<association property="shoptype" javaType="com.xzsc.entity.Shoptype">
<id column="shopType_id" property="shoptypeId" />
<result column="shop_typeName" property="shopTypename" />
</association>
</resultMap>
<select id="queryById" resultMap="shopMap">
select
s.shop_id,
s.shop_name,
s.shop_price,
s.shop_vip_price,
s.shop_flag,
s.admin_id,
s.shop_num ,
st.shopType_id,
st.shop_typeName
from shop s , shoptype st
where s.shop_shopType = st.shopType_id and shop_id=#{id}
</select>
</mapper>
一对多
就是一个商品类型包含多个商品 之国把他们这种关系映射出来
-
实体类还是上头的那俩
-
xml配置如下
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xzsc.dao.ShoptypeMapper">
<resultMap id="typeMap" type="shoptype">
<id column="shoptype_id" property="shoptypeId" />
<result column="shop_typename" property="shopTypename" />
<!--
集合的关键字 collection
ofType 和 javatype
JavaType和ofType都是用来指定对象类型的
但是JavaType是用来指定实体类中属性的类型,而ofType指定的是映射到list集合属性中 实体类的类型。
-->
<collection property="shopList" ofType="com.xzsc.entity.Shop" >
<id column="shop_id" property="shopId" />
<result column="shop_name" property="shopName" />
<result column="shop_price" property="shopPrice" />
<result column="shop_vip_price" property="shopVipPrice" />
<result column="shop_flag" property="shopFlag" />
<result column="admin_id" property="adminId" />
<result column="shop_num" property="shopNum" />
</collection>
</resultMap>
<select id="queryById" resultMap="typeMap">
select
s.shop_id,
s.shop_name,
s.shop_price,
s.shop_vip_price,
s.shop_flag,
s.admin_id,
s.shop_num ,
st.shopType_id,
st.shop_typeName
from shoptype st , shop s
where s.shop_shopType = st.shopType_id and shopType_id=#{tid}
</select>
</mapper>
11、动态sql
就是可以进行拼接的语句 例子:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xin.dao.ShopMapper">
<resultMap id="shopMap" type="com.xin.entity.Shop">
<id column="shop_id" property="shopId" />
<result column="shop_name" property="shopName" />
<result column="shop_price" property="shopPrice" />
</resultMap>
<!--可以通过不同的参数来拼接语句,比如我要通过名字来查,通过flag来查-->
<select id="queryShop" resultMap="shopMap" parameterType="map">
select * from xzsc3.shop where 1=1
<if test="name != null">
and shop_name=#{name}
</if>
<if test="flag != null">
and shop_flag=#{flag}
</if>
<if test="id != null">
and admin_id=#{id}
</if>
</select>
</mapper>
public interface ShopMapper {
//动态查询
List<Shop> queryShop(Map map);
}
import com.xin.dao.ShopMapper;
import com.xin.entity.Shop;
import com.xin.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.HashMap;
import java.util.List;
public class ShopTest {
@Test
public void test(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
HashMap hashMap = new HashMap();
// hashMap.put("name","大料");
// hashMap.put("id",1);
hashMap.put("flag",0);
List<Shop> shops = mapper.queryShop(hashMap);
System.out.println(shops);
sqlsession.close();
}
}
动态sql拼接(choose (when, otherwise))
拼接where条件
<select id="queryShop" resultMap="shopMap" parameterType="map">
select * from xzsc3.shop
<where>
<choose>
<when test="name != null">
shop_name=#{name}
</when>
<when test="flag != null">
and shop_flag=#{flag}
</when>
<otherwise>
and admin_id=#{id}
</otherwise>
</choose>
</where>
</select>
其实where的作用就是当我choose的条件满足了,就会自动拼接一个where 条件到sql语句中
然后这边可以这么理解 choose 就是swicth when就是case otherwise就是default
和switch一样 当一种条件满足就不会再去进行下一个 然后where可以很智能的去匹配是否需要and
关于set的拼接(trim, (where, set))
所谓的动态SQL,本质还是SQL语句,只是我们可以在SQL层面,去执行一些逻辑代码
好比 sql注入时候的那些函数 sub if when 都用过
例子:
<update id="updateShop" parameterType="map">
update shop
<set>
<if test="name != null">
shop_name = #{name},
</if>
<if test="flag!=null">
shop_flag=#{flag},
</if>
</set>
where xzsc3.shop.shop_id=#{id}
</update>
set 会识别是否需要加逗号
下头的例子会移除所有 prefixOverrides 属性中指定的内容,并且插入 prefix 属性中指定的内容。
<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
</trim>
<trim prefix="SET" suffixOverrides=",">
...
</trim>
set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号
注意,我们覆盖了后缀值设置,并且自定义了前缀值
sql片段
<sql id="id-name">
<if test="shopid!=null">
shop_id=#{shopid}
</if>
<if test="name!= null">
and shop_name = #{name}
</if>
</sql>
<select id="queryByShop" resultMap="shopMap" parameterType="map">
select * from xzsc3.shop
<where>
<include refid="id-name" />
</where>
</select>
这个就是sql片段,在mybatis中允许我们去定义这种公共代码块儿,我们只需要include引用即可,就好比我们的php中 include的文件包含一样,可以把它理解为sql包含
- 注意sql片段中不能出现where 标签
- 尽量一张表的信息来抽取sql片段,多表的就没有很大的意义
foreach循环
拿上星期循环删除购物车商品的例子来说,我要实现前端传过来的要删除的商品id产生拼接sql的情况:当时的sql是这么写的
select * from shopingcar where shopingCar_id in (46,47,48);
这个时候如果要执行的话,只能是使用循环来拼接,(46,47,48);这一段东西,那么这个时候foreach的出现解决了这个问题
<select id="getShopId" resultMap="shopMap" parameterType="map">
select * from xzsc3.shopingcar
<where>
shopingCar_id in
<foreach collection="sclist" item="sc"
open="(" close=")" separator=",">
#{sc}
</foreach>
</where>
</select>
- collection 传入的集合名字,这边由于穿的map 所以这里写的是map的key
- item 遍历的迭代项 就和 迭代userlist 的user一个道理
- open="(" 括号开始
- close=")" 括号结束
- separator="," 分割符为
,
这个分割符也可以写 and or 这些个关键字 - #{sc} 最后集合中的内容
12 、mybatis缓存
什么是缓存
缓存的重要性是不言而喻的。 使用缓存, 我们可以避免频繁的与数据库进行交互, 尤其是在查询越多、缓存命中率越高的情况下, 使用缓存对性能的提高更明显
一级缓存(本地缓存)
mybatis是默认开启一级缓存的:一级缓存是对于sqlsession而言
- 同一个sqlsession对象,在参数和sql完全相同的情况下只执行一次sql语句(缓存不过期的情况)
例子:
@Test
public void test01(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
//同一个sqlsession的第一次查询
Shop shop = mapper.queryById(1);
System.out.println(shop);
//同一个sqlsession的第二次查询
Shop shop1 = mapper.queryById(1);
System.out.println(shop1);
System.out.println(shop==shop1);
sqlsession.close();
}
结果
/*
Created connection 1007880005.
==> Preparing: select * from xzsc3.shop WHERE shop_id=?
==> Parameters: 1(Integer)
<== Columns: shop_id, shop_name, shop_shopType, shop_price, shop_vip_price, shop_flag, admin_id, shop_num
<== Row: 1, 面包, 1, 20.00, 16.00, 1, 1, 0
<== Total: 1
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
true
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3c130745]
Returned connection 1007880005 to pool.
*/
- 可以看到sql只是执行了一次,第二次就不需要查询了,其实这东西和redis属实像啊
- 在同一个sqlsession中,mybatis会通过特定算法把执行的方法和参数生成为一个键,然后结果存为值,放在map中
这就是本地缓存 也叫一级缓存
一级缓存失效的情况
- 查询不同的东西
- 增删改操作,可能会改变原来的数据,所以必定会刷新缓存!
- 查询不同的Mapper.xml
- 手动清理缓存 sqlsession.clearCache();
二级缓存
- 二级缓存又叫全局缓存
- 基于namespace级别的,一个名称空间,对应一个二级缓存
使用方式
显示配置二级缓存
<!--显式的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>
再要使用二级缓存的mapper.xml中开启
<!--在当前Mapper.xml中使用二级缓存-->
<cache/>
也可以自定义参数
<cache eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
例子
@Test
public void test02(){
SqlSession sqlsession = MybatisUtil.getSqlsession();
ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
Shop shop = mapper.queryById(1);
System.out.println(shop);
sqlsession.clearCache();
sqlsession.close();
System.out.println("==============开启第二个sqlsession的查询================");
SqlSession sqlsession1 = MybatisUtil.getSqlsession();
ShopMapper mapper1 = sqlsession1.getMapper(ShopMapper.class);
Shop shop1 = mapper1.queryById(1);
System.out.println(shop1);
sqlsession1.close();
}
}
/*
结果:
Created connection 644345897.
==> Preparing: select * from xzsc3.shop WHERE shop_id=?
==> Parameters: 1(Integer)
<== Columns: shop_id, shop_name, shop_shopType, shop_price, shop_vip_price, shop_flag, admin_id, shop_num
<== Row: 1, 面包, 1, 20.00, 16.00, 1, 1, 0
<== Total: 1
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@2667f029]
Returned connection 644345897 to pool.
==============开启第二个sqlsession的查询================
Cache Hit Ratio [com.cahce.dao.ShopMapper]: 0.5 //Cache中有了
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
*/
- 在一个mapper.xml中 当一级缓存关闭时候会提交添加到二级缓存中
缓存的执行流程
<select id="queryById" resultType="shop" useCache="false">
select * from xzsc3.shop
<where>
shop_id=#{sid}
</where>
</select>
useCache=“false” 关闭提交缓存
自定义缓存
EhCache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。
要在程序中使用ehcache,先要导包!
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.1.0</version>
</dependency>
然后在mapper中指定使用ehcache缓存实现
<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
必须导入配置文件
13、mybatis逆向工程
mybatis框架需要 : 实体类,自定义mapper接口,mapper.xml
逆向工程可以自动帮我们生成