Mybatis
1.mybatis基本使用
1.1简介
MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录
1.2第一个mybatis应用
1.21创建一个maven-web
删除src重新再建一个web
1.22pol.xml配置
<!-- mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<!-- 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>
1.23.java、resources目录结构
1.24.resources目录下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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!-- mysql连接信息-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root123"/>
</dataSource>
</environment>
</environments>
<!-- mapper文件配置-->
<mappers>
<mapper resource="com/xiaozhi/dao/User/UserMapper.xml"/>
</mappers>
</configuration>
1.23.util下MybatisUtil.java
package com.xiaozhi.util;
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 {
//获取sqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
1.24.pojo下的实体类User.java
需要创建一个数据库mybatis,和一个表user,字段为id,name,pwd
package com.xiaozhi.pojo;
public class User {
private int id;
private String name;
private String pwd;
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
public User() {
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name=‘" + name + ‘\‘‘ +
", pwd=‘" + pwd + ‘\‘‘ +
‘}‘;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
1.25.dao下的UserDao接口
package com.xiaozhi.dao.User;
import com.xiaozhi.pojo.User;
import java.util.List;
public interface UserDao {
List<User> getUserlist();
}
1.26.dao下的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.xiaozhi.dao.User.UserDao">
<!-- id接口的方法-->
<!-- resultType实体类-->
<select id="getUserlist" resultType="com.xiaozhi.pojo.User">
select * from mybatis.user
</select>
</mapper>
1.27.使用Test测试(在test下新建一个test.java)
package com.xiaozhi.dao;
import com.xiaozhi.dao.User.UserDao;
import com.xiaozhi.pojo.User;
import com.xiaozhi.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void test(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
List<User> userlist = mapper.getUserlist();
for (User user : userlist) {
System.out.println(user.getName());
}
//关闭sqlsession
sqlSession.close();
}
}
1.3增删改查
1.31查询数据
//查询数据
User getUserByid(int id);
<!-- 查询数据-->
<select id="getUserByid" resultType="com.xiaozhi.pojo.User">
select * from mybatis.user where id = #{id}
</select>
测试
//查询数据
@Test
public void getUserbyid(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
User userByid = mapper.getUserByid(1);
System.out.println(Arrays.toString(new User[]{userByid}));
//关闭sqlsession
sqlSession.close();
}
注意:插入数据、修改数据、删除数据都需要提交事务
1.32插入数据
//插入数据
int AddUser(User user);
<!-- 插入数据-->
<insert id="AddUser" parameterType="com.xiaozhi.pojo.User">
insert into mybatis.user(id,name,pwd) value (#{id},#{name},#{pwd})
</insert>
测试
//插入数据
@Test
public void InsertUser(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
int addUser = mapper.AddUser(new User(4, "小欧", "123456"));
sqlSession.commit();
if (addUser>0){
System.out.println("插入成功");
}
//关闭sqlsession
sqlSession.close();
}
1.33修改数据
//修改数据
int UpdateUser(User user);
<!-- 修改数据-->
<update id="UpdateUser" parameterType="com.xiaozhi.pojo.User">
update mybatis.user set name=#{name} where id=#{id};
</update>
测试
//修改数据
@Test
public void UpdateUser(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
int updateUser = mapper.UpdateUser(new User(4,"小欧欧"));
sqlSession.commit();
if (updateUser>0){
System.out.println("修改成功");
}
//关闭sqlsession
sqlSession.close();
}
1.34删除数据
//删除数据
int DeletUser(int id);
<!-- 删除数据-->
<delete id="DeletUser" parameterType="int">
delete from mybatis.user where id = #{id}
</delete>
测试
//删除数据
@Test
public void DeletUser(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
int updateUser = mapper.DeletUser(4);
sqlSession.commit();
if (updateUser>0){
System.out.println("删除成功");
}
//关闭sqlsession
sqlSession.close();
}
1.4万能map
1.1例子1
//map查询数据(可以自定义sql属性)
List<User> getUserName(Map<String,Object> map);
<!-- map插入数据-->
<insert id="getUserName" parameterType="map">
insert into mybatis.user (name, pwd) values (#{name},#{passWord})
</insert>
测试
//map查询
@Test
public void getUserName(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
//执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
Map<String, Object> map = new HashMap<>();
map.put("name","小智");
List<User> userName = mapper.getUserName(map);
for (User user : userName) {
System.out.println(user);
}
sqlSession.close();
}
1.42例子2
//map查询数据(可以自定义sql属性)
int InsertToUser(Map<String,Object> map);
<!-- map插入数据-->
<insert id="InsertToUser" parameterType="map">
insert into mybatis.user (name, pwd) values (#{name},#{passWord})
</insert>
测试
// map插入数据
@Test
public void InsertInto(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
//执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
Map<String, Object> map = new HashMap<>();
map.put("name","小欧");
map.put("passWord","123645");
//执行sql
int i = mapper.InsertToUser(map);
//提交事务
sqlSession.commit();
if (i>0){
System.out.println("插入数据成功");
}
sqlSession.close();
}
1.5模糊查询map
1.51安全sql
//map like模糊查询d第一种
List<User> getLike(Map<String,Object> map);
<!-- map like查询1(防止sql注入)-->
<select id="getLike" parameterType="map" resultType="com.xiaozhi.pojo.User">
select * from mybatis.user where name like #{name}
</select>
测试
//like查询
@Test
public void getLikeUuser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserDao mapper = sqlSession.getMapper(UserDao.class);
HashMap<String, Object> map = new HashMap<>();
map.put("name","%张%");
List<User> users = mapper.getLike(map);
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
1.52不安全sql
//map like模糊查询d第二种
List<User> getLikeUser(Map<String,Object> map);
<!-- map like查询2(存在sql注入)-->
<select id="getLikeUser" parameterType="map" resultType="com.xiaozhi.pojo.User">
select * from mybatis.user where name like "%"#{name}"%"
</select>
测试
//like查询存在sql注入
@Test
public void getLeUuser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserDao mapper = sqlSession.getMapper(UserDao.class);
HashMap<String, Object> map = new HashMap<>();
map.put("name","张");
List<User> users = mapper.getLikeUser(map);
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
2.配置解析
- properties(属性)
- settings(设置)
- typeAliases(类型别名)
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- environments(环境配置)
- environment(环境变量)
- transactionManager(事务管理器)
- dataSource(数据源)
- environment(环境变量)
- databaseIdProvider(数据库厂商标识)
- mappers(映射器
2.1.environments
连接数据库有dbcp、c3p0、druid
<!--default选择的环境-->
<environments default="development">
<!-- id环境名称-->
<environment id="development">
<!-- transactionManager下的type事务管理器 JDBC和MANAGED-->
<!-- MANAGED的不常用-->
<transactionManager type="JDBC"/>
<!-- dataSource下的type连接池 有POOLED和UNPOOLED、JNDI-->
<dataSource type="POOLED">
<!-- mysql连接信息-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis? useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root123"/>
</dataSource>
</environment>
</environments>
2.2.properties
编写db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456
需要在配置文件前导入
<!--引入外部配置文件-->
<properties resource="db.properties"/>
<!--default选择的环境-->
<environments default="development">
<!-- id环境名称-->
<environment id="development">
<!-- transactionManager下的type事务管理器 JDBC和MANAGED-->
<!-- MANAGED的不常用-->
<transactionManager type="JDBC"/>
<!-- dataSource下的type连接池 有POOLED和UNPOOLED、JNDI-->
<dataSource type="POOLED">
<!-- mysql连接信息-->
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
可以直接在引用配置文件是配置username和password
<!--引入外部配置文件-->
<properties resource="db.properties">
<property name="username" value="dev_user"/>
<property name="password" value="F2Fa3!33TYyg"/>
</properties>
2.3.类型别名(typeAliases)
- 类型别名是为 Java 类型设置一个短的名字。
- 存在的意义:仅在于用来减少类完全限定名的冗余。
2.31在配置环境中引入
<!--可以给实体类起别名-->
<typeAliases>
<typeAlias type="com.xiaozhi.pojo.User" alias="User"/>
</typeAliases>
2.32. 指定一个包名
MyBatis 会在包名下面搜索需要的 Java Bean,比如:扫描实体类的包,它的默认别名就为这个类的类名,首字母小写
<!--可以给实体类起别名-->
<typeAliases>
<package name="com.xiaozhi.pojo"/>
</typeAliases>
也可以自己定义实体类的名称,方法如下
@Alias("hello")
public class UserDaoTest {}
常见的 Java 类型内建的类型别名。它们都是不区分大小写的,注意,为了应对原始类型的命名重复,采取了特殊的命名风格。
别名 | 映射的类型 |
---|---|
_byte | byte |
_long | long |
_short | short |
_int | int |
_integer | int |
_double | double |
_float | float |
_boolean | boolean |
string | String |
byte | Byte |
long | Long |
short | Short |
int | Integer |
integer | Integer |
double | Double |
float | Float |
boolean | Boolean |
date | Date |
decimal | BigDecimal |
bigdecimal | BigDecimal |
object | Object |
map | Map |
hashmap | HashMap |
list | List |
arraylist | ArrayList |
collection | Collection |
iterator | Iterator |
2.4.设置(settings)
设置名 | 描述 | 有效值 | 默认值 |
---|---|---|---|
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false | true |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 |
true | false | false |
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING | 未设置 |
2.5其他配置
-
plugins插件
-
- mybatis-generator-core(自动生成代码)
- mybatis-plus
- 通用mapper
Mybatis-Plus(简称MP)是一个 Mybatis 的增强工具,在 Mybatis 的基础上只做增强不做改变,为简化开发、提高效率而生
通用 Mapper4 是一个可以实现任意 MyBatis 通用方法的框架,项目提供了常规的增删改查操作以及Example
相关的单表操作
2.6映射器(mappers)
直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用,或完全限定资源定位符(包括 file:///
形式的 URL),或类名和包名等
2.61.方式一(推荐使用)使用相对于类路径的资源引用:
<!--使用相对于类路径的资源引用-->
<mappers>
<mapper resource="com/xiaozhi/dao/User/UserMapper.xml"/>
</mappers>
2.62.使用完全限定资源定位符(URL)(不使用)
<mappers>
<mapper url="file:///var/mappers/AuthorMapper.xml"/>
<mapper url="file:///var/mappers/BlogMapper.xml"/>
<mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
2.63.使用映射器接口实现类的完全限定类名(可以使用)
<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
</mappers>
2.64.将包内的映射器接口实现全部注册为映射器(可以使用)
<mappers>
<package name="org.mybatis.builder"/>
</mappers>
2.63和2.64注意:
- 接口和他的Mapper配置文件必须同名!
- 接口和他的Mapper配置文件必须在同一个包下!
2.7生命周期和作用域
2.71.SqlSessionFactoryBuilder
- 一旦创建了 SqlSessionFactory,就不再需要它,
- 是局部方法变量
2.72.SqlSessionFactory
- 说简单就是连接池
- 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例
- 是应用作用域
- 最简单的就是使用单例模式或者静态单例模式。
2.73.SqlSession
- 连接到连接池的一个请求
- 请求或方法作用域
- 用完之后需要赶紧关闭,不然浪费资源
mappper代表一个业务
2.8. resultMap 的使用
为了解决实体类属性名与数据库字段名不一致的问题
实体类
package com.xiaozhi.pojo;
public class User1 {
private int id;
private String name;
private String password;
public User1(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public User1() {
}
@Override
public String toString() {
return "User1{" +
"id=" + id +
", name=‘" + name + ‘\‘‘ +
", password=‘" + password + ‘\‘‘ +
‘}‘;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
接口
//查询数据
List<User1> getUserListgo(Map<String,Object> map);
UserMapper.xml
<select id="getUserListgo" resultType="user1" parameterType="map">
select * from mybatis.user where name like #{name}
</select>
测试数据
//查询数据
@Test
public void getUsergo(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserDao mapper = sqlSession.getMapper(UserDao.class);
HashMap<String, Object> map = new HashMap<>();
map.put("name","%张%");
List<User1> userListgo = mapper.getUserListgo(map);
for (User1 listgo : userListgo) {
System.out.println(listgo);
}
sqlSession.close();
}
结果
为什么会出现这样的结果?
实体类属性名与数据库字段名不对应
- 可以查询语句添加as
- 使用resultMap进行映射
2.81使用resultMap进行映射
只需要在UserMapper.xml中修改为下面即可
<resultMap id="getlist" type="user1">
<result column="pwd" property="password"/>
</resultMap>
<!-- //查询数据-->
<select id="getUserListgo" resultMap="getlist" parameterType="map">
select * from mybatis.user where name like #{name}
</select>
3.日志
3.1日志工厂
是为了在操作数据时出现错误,运用日志
- SLF4J
- LOG4J 【掌握】
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING 【掌握】
- NO_LOGGING
3.2.STDOUT_LOGGING(标准日志)
在配置文件中加入settings
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
3.3.Log4j
-
我们也可以控制每一条日志的输出格式;
-
通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。
-
通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。
-
导入log4j的包
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
- log4j.properties
#将等级为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/log.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{yyyy-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
- 配置log4j为日志的实现
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
3.31.lo4j的使用
在UserDaoTest.java中
//导入包
import org.apache.log4j.Logger;
import org.junit.Test;
public class UserDaoTest {
//日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserDaoTest.class);
@Test
public void getLog4j(){
logger.info("info:进入了testLog4j");//提示信息
logger.debug("debug:进入了testLog4j");//debug信息
logger.error("error:进入了testLog4j");//错误信息
}
}
也可以在数据操作中使用
//查询数据
@Test
public void test(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
logger.info("test:进入test");//提示信息
// 执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
List<User> userlist = mapper.getUserlist();
for (User user : userlist) {
System.out.println(user);
}
//关闭sqlsession
sqlSession.close();
}
4.分页
为什么要分页?
减少数据的处理量
4.1使用limit分页
语法:SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 0,5
表示有五条,从0开始有数五条
接口
//分页limit
List<User> getUserlimit(Map<String,Integer> map);
mapper.xml
<!-- limit查询-->
<select id="getUserlimit" resultType="user" parameterType="map">
select * from mybatis.user limit #{start},#{end}
</select>
实现测试
//limit查询
@Test
public void getUserLimit(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
//执行sql
UserDao mapper = sqlSession.getMapper(UserDao.class);
HashMap<String, Integer> map = new HashMap<>();
map.put("start",0);
map.put("end",5);
List<User> userlimit = mapper.getUserlimit(map);
for (User user : userlimit) {
System.out.println(user);
}
//关闭sqlsession
sqlSession.close();
}
4.2.RowBounds
接口
//RowBounds
List<User> getUserAlist();
mapper.xml
<!-- RowBounds分页-->
<select id="getUserAlist" resultType="user">
<!-- 查询数据-->
select * from mybatis.user
</select>
实现测试
//RowBounds分页
@Test
public void getUserRowBounds(){
//获取sqlsession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
//RowBounds实现 limit一样
RowBounds rowBounds = new RowBounds(0, 5);
//通过Java代码层面实现分页
List<User> userList = sqlSession.selectList("com.xiaozhi.dao.User.UserDao.getUserAlist",null,rowBounds);
for (User user : userList) {
System.out.println(user);
}
//关闭sqlsession
sqlSession.close();
}
4.3.PageHelper分页
pom.xml
<!-- pagehelper插件分页-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.4</version>
</dependency>
</dependencies>
mybatis-config.xml(配置文件)
<!-- 配置分页插件 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<!--设置数据可类型Oracle,Mysql,MariaDB,SQLite,Hsqldb,PostgreSQL六种数据库-->
<property name="dialect" value="mysql"/>
</plugin>
</plugins>
接口
/**
* 查询所有用户(分页插件)
*/
List<Map<String, Object>> findAll();
mapper.xml
<!-- PageHelper分页-->
<select id="findAll" resultType="user">
<!-- 查询数据-->
select * from mybatis.user
</select>
完成测试
//PageHelper分页插件
@Test
public void getAll(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserDao mapper = sqlSession.getMapper(UserDao.class);
// 1表示第一页,5表示一页的个数
PageHelper.startPage(1, 5);
List<Map<String, Object>> userList = mapper.findAll();
PageInfo<Map<String, Object>> page = new PageInfo<Map<String, Object>>(userList);
System.out.println("总数量:" + page.getTotal());
System.out.println("当前页查询记录:" + page.getList().size());
System.out.println("当前页码:" + page.getPageNum());
System.out.println("每页显示数量:" + page.getPageSize());
System.out.println("总页:" + page.getPages());
sqlSession.close();
}
5.使用注解开发
面向接口编程
- 学过面向对象编程,也学习过接口,但在真正的开发中,很多时候我们会选择面向接口编程
- 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
- 在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;
- 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
关于接口的理解
- 接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
- 接口的本身反映了系统设计人员对系统的抽象理解。
- 接口应有两类:
- 第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);
- 第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);
- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。
三个面向区别
- 面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法 .
- 面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现 .
- 接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题.更多的体现就是对系统整体的架构
5.1使用注解开发
接口 UserMapper
@Select("select * from user")
List<User> getUserList();
mybatis-config.xml
<!--可以给实体类起别名-->
<typeAliases>
<package name="com.xiaozhi.pojo"/>
</typeAliases>
<mappers>
<!--绑定类-->
<mapper class="com.xiaozhi.dao.UserMapper"/>
</mappers>
测试
@Test
public void getUserList(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
5.2注解的本质
本质:反射机制实现
底层:动态代理
例子:
你要结婚,你去找婚庆公司。找和不找都是为了结婚。
5.3.mybatis执行流程
5.4CRUD
可以设置自动提交事务(在工具类中)
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
5.5使用注解,开发增删查改
编写接口
// 查询
@Select("select * from user where id=#{id}")
List<User> getUserByid(@Param("id")int id);
//插入数据
@Insert("insert into user(name,pwd) values (#{name},#{pwd})")
int insertintoUser(@Param("name") String name,@Param("pwd") String pwd);
//修改数据
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int updateUser(User user);
//删除数据
@Delete("delete from user where id=#{id}")
int deleteUser(@Param("id") int id);
测试类
//查询数据
@Test
public void getUserByid(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userByid = mapper.getUserByid(2);
for (User user : userByid) {
System.out.println(user);
}
sqlSession.close();
}
@Test
//插入数据
public void insertintoUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.insertintoUser("月亮","12345682");
sqlSession.commit();
sqlSession.close();
}
@Test
//修改数据
public void updateUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.updateUser(new User(111,"太阳","666666"));
sqlSession.commit();
sqlSession.close();
}
@Test
//删除数据
public void deleteUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.deleteUser(111);
sqlSession.commit();
sqlSession.close();
}
5.51@Param注解注意事项
- 基本类型的参数或者String类型,需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话,可以忽略,但是建议大家都加上!
- 我们在SQL中引用的就是我们这里的 @Param() 中设定的属性名!
5.52mybatis中#「」和$「」的区别
- #将传入的数据都当成一个字符串,会对自动传入的数据加一个双引号。如:order by #user_id#,如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id,则解析成的sql为order by "id".
- $将传入的数据直接显示生成在sql中。如:order by $user_id$,如果传入的值是111,那么解析成sql时的值为order by user_id, 如果传入的值是id,则解析成的sql为order by id.
-
方式能够很大程度防止sql注入。
- $方式无法防止Sql注入。
- $方式一般用于传入数据库对象,例如传入表名.
- 一般能用#的就别用$.
结论:
在编写MyBatis的映射语句时,尽量采用“#{xxx}”这样的格式。若不得不使用“${xxx}”这样的参数,要手工地做好过滤工作,来防止SQL注入攻击
5.6Lombok
5.61安装Lombok
IDEA的安装
打开IDEA的Setting –> 选择Plugins选项 –> 选择Browse repositories –> 搜索lombok –> 点击安装 –> 安装完成重启IDEA –> 安装成功
配置pom.xml
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.2</version>
</dependency>
注解类
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger
@Data
@Builder
@Singular
@Delegate
@Value
@Accessors
@Wither
@SneakyThrows
常用注解:
@Data:无参构造,get、set、tostring、hashcode,equals
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@ToString
@Getter
6.子查询和连表查询
6.1多对一处理
多对一:
- 多个学生,对应一个老师
- 对于学生这边而言, 关联 .. 多个学生,关联一个老师 【多对一】
- 对于老师而言, 集合 , 一个老师,有很多学生 【一对多】
mysql:
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, ‘小智老师‘);
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (‘1‘, ‘小明‘, ‘1‘);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (‘2‘, ‘小红‘, ‘1‘);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (‘3‘, ‘小张‘, ‘1‘);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (‘4‘, ‘小李‘, ‘1‘);
INSERT INTO `student` (`id`, `name`, `tid`) VALUES (‘5‘, ‘小王‘, ‘1‘);
6.1.1环境搭建
- 导入lombok
- 创建实体类Teacher、Student
- 建立Mapper接口
- 建立Mapper.xml文件
实体类Student
package com.xiaozhi.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
private int id;
private String name;
private int tid;
//多个学生可以是同一个老师,即多对一
private Teacher teacher;
}
实体类Teacher
package com.xiaozhi.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
private int id;
private String name;
}
StudentMapper.java
//子查询
public List<Student> getStudent();
//连表查询
public List<Student> getStudent2();
Student.xml
<!--
思路:
1. 查询所有的学生信息
2. 根据查询出来的学生的tid,寻找对应的老师! 子查询
-->
<!-- 子查询需要利用resultMap进行映射-->
<!--复杂的属性,我们需要单独处理 对象: association 集合: collection -->
<!-- teacher集合根据tid去查询 -->
<!-- property集合名
column需要根据的字段名
javaType实例类名
select查询sql名-->
<select id="getStudent" resultMap="getStudentTeacher">
select * from student
</select>
<resultMap id="getStudentTeacher" type="Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<result property="tid" column="tid"/>
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="Teacher">
select * from teacher where id =#{id}
</select>
<!-- 连表查询-->
<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
select s.id sid,s.name sname,s.tid,t.name tname
from student s,teacher t
where s.tid = t.id;
</select>
<resultMap id="StudentTeacher2" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
<result property="id" column="tid"/>
</association>
</resultMap>
测试
//子查询
@Test
public void getStudentTeacher(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> studentTeacher = mapper.getStudent();
for (Student student : studentTeacher) {
System.out.println(student);
}
System.out.println("hello world");
sqlSession.close();
}
//连表查询
@Test
public void getStudentTeacher1(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> studentTeacher = mapper.getStudent2();
for (Student student : studentTeacher) {
System.out.println(student);
}
System.out.println("hello world");
sqlSession.close();
}
6.2一对多处理
一个老师拥有多个学生,就是一对多的关系!
实体类Student1.java
package com.xiaozhi.pojo;
import lombok.Data;
//GET,SET,ToString,有参,无参构造
@Data
public class Student1 {
private int id;
private String name;
private int tid;
}
实体类Teacher1.java
package com.xiaozhi.pojo;
import lombok.Data;
import java.util.List;
@Data
public class Teacher1 {
private int id;
private String name;
// 一个老师拥有多个学生
private List<Student1> students;
}
TeacherMapp.java
package com.xiaozhi.dao;
import com.xiaozhi.pojo.Teacher1;
import java.util.List;
public interface TeacherMapper {
//子查询
List<Teacher1> getTeacher();
// 联表查询
List<Teacher1> getTeacher1();
}
Teacher.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.xiaozhi.dao.TeacherMapper">
<!-- 子查询-->
<select id="getTeacher" resultMap="getTeacherStudent">
select * from teacher
</select>
<resultMap id="getTeacherStudent" type="Teacher1">
<result property="id" column="id"/>
<result property="name" column="name"/>
<collection property="students" column="id" javaType="ArrayList" ofType="Student" select="getStudent"/>
</resultMap>
<select id="getStudent" resultType="Student1">
select * from student where tid =#{id}
</select>
<!--连表查询-->
<select id="getTeacher1" resultMap="StudentTeacher2">
SELECT t.name tname,t.id tid,s.tid stid,s.name sname
from teacher t,student s
where t.id=s.tid;
</select>
<resultMap id="StudentTeacher2" type="Teacher1">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="Student1">
<result property="name" column="sname"/>
<result property="id" column="stid"/>
</collection >
</resultMap>
</mapper>
测试类
package com.xiaozhi;
import com.xiaozhi.dao.TeacherMapper;
import com.xiaozhi.pojo.Student1;
import com.xiaozhi.pojo.Teacher1;
import com.xiaozhi.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class TeacherTest {
//子查询
@Test
public void getTeacher(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
List<Teacher1> teacher1s = mapper.getTeacher();
for (Teacher1 teacher : teacher1s) {
for (int i = 0; i < teacher.getStudents().size(); i++) {
System.out.println(teacher.getId());
System.out.println(teacher.getName());
System.out.println(teacher.getStudents().get(i));
}
}
sqlSession.close();
}
// 连表查询
@Test
public void getTeacher1(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
List<Teacher1> teacher1s = mapper.getTeacher1();
for (Teacher1 teacher1 : teacher1s) {
System.out.println(teacher1);
}
sqlSession.close();
}
}
小结
-
关联 - association 【多对一】
-
集合 - collection 【一对多】
-
javaType & ofType
-
- JavaType 用来指定实体类中属性的类型
- ofType 用来指定映射到List或者集合中的 pojo类型,泛型中的约束类型!
注意点:
- 保证SQL的可读性,尽量保证通俗易懂
- 注意一对多和多对一中,属性名和字段的问题!
- 如果问题不好排查错误,可以使用日志 , 建议使用 Log4j
面试高频
- Mysql引擎
- InnoDB底层原理
- 索引
- 索引优化
7.动态sql
什么是动态SQL? 动态SQL就是指根据不同的条件生成不同的SQL语句
动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中,有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类,现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。
if
choose (when, otherwise)
trim (where, set)
foreach
7.1搭建环境
mysql数据库Blog表创建
CREATE TABLE `blog` (
`id` varchar(50) NOT NULL COMMENT ‘博客id‘,
`title` varchar(100) NOT NULL COMMENT ‘博客标题‘,
`author` varchar(30) NOT NULL COMMENT ‘博客作者‘,
`create_time` datetime NOT NULL COMMENT ‘创建时间‘,
`views` int(30) NOT NULL COMMENT ‘浏览量‘
) ENGINE=InnoDB DEFAULT CHARSET=utf8
Blog实体类
import lombok.Data;
import java.util.Date;
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date create_time;
private int views;
}
BlogMapper接口
int addBlog(Blog blog);
BlogMapper.xml
<insert id="addBlog" parameterType="Blog">
insert into blog (id,title,author,create_time,views)
values (#{id},#{title},#{author},#{create_time},#{views})
</insert>
需要设置自动提交
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
Id生成工具类
import java.util.UUID;
public class IDutils {
public static String getId(){
return UUID.randomUUID().toString().replaceAll("-","");
}
}
生成数据
@Test
public void addBlogTest(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
Blog blog = new Blog();
blog.setId(IDutils.getId());
blog.setTitle("servlet如此简单");
blog.setAuthor("狂神说");
blog.setCreate_time(new Date());
blog.setViews(9999);
mapper.addBlog(blog);
blog.setId(IDutils.getId());
blog.setTitle("jap如此简单");
mapper.addBlog(blog);
blog.setId(IDutils.getId());
blog.setTitle("jstl如此简单");
mapper.addBlog(blog);
blog.setId(IDutils.getId());
blog.setTitle("mysql如此简单");
mapper.addBlog(blog);
sqlSession.close();
}
7.2.if
使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分
接口
List<Blog> getBlog(Map map);
xml
<select id="getBlog" resultType="Blog" parameterType="map">
SELECT * FROM BLOG
<where>
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null">
AND author = #{author}
</if>
</where>
</select>
测试
@Test
public void getBlog(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap<Object, Object> map = new HashMap<>();
map.put("title","%如此简单%");
map.put("author","小智说");
List<Blog> blog = mapper.getBlog(map);
for (Blog blog1 : blog) {
System.out.println(blog1);
}
sqlSession.close();
}
7.3.choose、when、otherwise(类似于java switch)
不想使用所有的条件,而只是想从多个条件中选择一个使用。针对这种情况,MyBatis 提供了 choose 元素,它有点像 Java 中的 switch 语句。
接口
List<Blog> queryBlog(Map map);
xml
<select id="queryBlog" parameterType="map" resultType="Blog">
select * from blog
<where>
<choose>
<when test="title != null">
AND title like #{title}
</when>
<when test="author != null">
AND author = #{author}
</when>
<otherwise>
AND views = #{views}
</otherwise>
</choose>
</where>
</select>
测试
@Test
public void queryBlog(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap<Object, Object> map = new HashMap<>();
// map.put("title","%如此简单%");
map.put("author","小智说");
// map.put("views",9999);
List<Blog> blog = mapper.queryBlog(map);
for (Blog blog1 : blog) {
System.out.println(blog1);
}
sqlSession.close();
}
7.4.trim、where、set
7.41.set
接口
int updayeBlog(Map map);
xml
<update id="updayeBlog" parameterType="map">
update blog
<set>
<if test="title != null">title=#{title},</if>
<if test="author != null">author=#{author},</if>
</set>
where id=#{id}
</update>
测试
@Test
public void updateBlog(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap<Object, Object> map = new HashMap<>();
map.put("id","5145b92b3d904c4ebd857b47f0961715");
map.put("title","java认真学如此简单");
mapper.updayeBlog(map);
sqlSession.close();
}
7.42.where
接口
List<Blog> getBlog(Map map);
xml
<select id="getBlog" resultType="Blog" parameterType="map">
SELECT * FROM BLOG
<where>
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null">
AND author = #{author}
</if>
</where>
</select>
测试
@Test
public void getBlog(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap<Object, Object> map = new HashMap<>();
map.put("title","%如此简单%");
map.put("author","小智说");
List<Blog> blog = mapper.getBlog(map);
for (Blog blog1 : blog) {
System.out.println(blog1);
}
sqlSession.close();
}
7.4SQL片段
有的时候,我们可能会将一些功能的部分抽取出来,方便复用!
使用SQL标签抽取公共的部分
<sql id="if-title-author">
<if test="title != null">
title = #{title}
</if>
<if test="author != null">
and author = #{author}
</if>
</sql>
需要使用的地方使用Include标签引用即可
<select id="queryBlogIF" parameterType="map" resultType="blog">
select * from mybatis.blog
<where>
<include refid="if-title-author"></include>
</where>
</select>
注意事项:
- 最好基于单表来定义SQL片段!
- 不要存在where标签
7.5Foreach
<!-- -- select * from blog WHERE ( id=? or id=? or id=? )-->
<!-- collection循环的列表名,item单个属性名,open以什么开始包裹separator中间用什么连接close以什么关闭-->
<select id="queryBloForeach" parameterType="map" resultType="Blog">
select * from blog
<where>
<foreach collection="ids" item="id" open="and (" separator="or" close=")">
id=#{id}
</foreach>
</where>
</select>
接口
List<Blog> queryBloForeach(Map map);
测试
@Test
public void queryBlogForeach(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
Map map = new HashMap();
List<String> ids = new ArrayList<String>();
ids.add("5145b92b3d904c4ebd857b47f0961715");
ids.add("0b5c8f81a60a4c2f81ee6ee493f51dca");
ids.add("39bee7fa8c4b4e2da3599bcf3650ea49");
map.put("ids",ids);
List<Blog> blogs = mapper.queryBloForeach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}