标签：equal 外部文件 输出 tst 并且 不同的 关系 个数 写代码
（MyBatis中文文档：https://mybatis.org/mybatis-3/zh/index.html）
? 思路：搭建环境 --> 导入MyBatis --> 编写代码 --> 测试
? 搭建数据库
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>MyBatis-study</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!--导入依赖-->
<dependencies>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
<!--build中配置resources，来放置我们资源导出失败的问题-->
<build>
<resources>
<resource>
<directory>src/main/resource</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
<?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">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>
</configuration>
package com.mybatis.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;
//SqlSessionFactory --> SqlSession
public class MyBatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
try {
//使用mybatis第一步，获取SqlSessionFactory对象
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
// SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
// 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
package com.mybatis.pojo;
//实体类
public class user {
private int id;
private String name;
private String pwd;
public user() { }
public user(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.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;
}
}
package com.mybatis.dao;
import com.mybatis.pojo.User;
import java.util.List;
public interface UserDao {
List<User> getUserList();
}
接口实现类由原来的UserDaoImpl转变为一个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绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.mybatis.dao.UserDao">
<!--查询语句-->
<select id="getUserList" resultType="com.mybatis.pojo.User">
select * from mybatis
</select>
</mapper>
package com.mybatis.dao;
import com.mybatis.pojo.User;
import com.mybatis.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void test(){
//第一步：获取SqlSession对象
SqlSession sqlSession=MyBatisUtils.getSqlSession();
//执行SQL
//方式一：getMapper
UserDao userDao=sqlSession.getMapper(UserDao.class);
List<User> userList=userDao.getUserList();
for (User user : userList) {
System.out.println(user);
}
//关闭SqlSession
sqlSession.close();
}
}
? 解决方法：https://www.cnblogs.com/phpdragon/p/7216626.html
? 解决方法：检查数据库版本与Driver版本是否一致
org.apache.ibatis.binding.BindingException: Type interface com.mybatis.dao.UserDao is not known to the MapperRegistry.
? MapperRegistry是什么？
? 核心配置文件中注册mappers
? 解决方法：在MyBatis的核心配置文件mybatis-config.xml中添加注册
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>
? 解决方法：在pom.xml中添加build
<!--build中配置resources，来放置我们资源导出失败的问题-->
<build>
<resources>
<resource>
<directory>src/main/resource</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
? 解决方法：在pom.xml中加以下代码
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
? 解决方法：注释或删除pom.xml中的
<packaging>pom</packaging>
? 1、增删改需要提交事务！
? 2、namespace中的包名要和Dao/Mapper接口的包名一致！
? 3、id：就是对应的namespace中的方法名；
? resultType：Sql语句执行的返回值；
? parameterType：参数类型
//根据用户id查询
User getUserById(int id);
<!--根据id查询-->
<select id="getUserById" resultType="com.mybatis.pojo.User" parameterType="int">
select * from users where id = #{id}
</select>
//按id查询
@Test
public void getUserById(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userList=sqlSession.getMapper(UserDao.class);
User user=userList.getUserById(1);
System.out.println(user);
sqlSession.close();
}
//插入用户
int addUser(User user);
<!--插入用户-->
<insert id="addUser" parameterType="com.mybatis.pojo.User">
insert into users (id,name,psw) values(#{id},#{name},#{psw})
</insert>
//增加
@Test
public void addUser(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userList=sqlSession.getMapper(UserDao.class);
int res=userList.addUser(new User(4,"王五","123"));
if(res>0)
System.out.println("插入成功");
//提交事务
sqlSession.commit();
sqlSession.close();
}
//修改用户
int updateUser(User user);
<!--修改用户-->
<update id="updateUser" parameterType="com.mybatis.pojo.User">
update users set name=#{name},psw=#{psw} where id=#{id}
</update>
//修改
@Test
public void updateUser(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userList=sqlSession.getMapper(UserDao.class);
int res=userList.updateUser(new User(4,"汪玲","12345"));
if(res>0)
System.out.println("修改成功");
sqlSession.commit();
sqlSession.close();
}
//删除用户
int deleteUser(int id);
<!--删除用户-->
<delete id="deleteUser" parameterType="int">
delete from users where id=#{id}
</delete>
//删除
@Test
public void deleteUser(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userList=sqlSession.getMapper(UserDao.class);
int res=userList.deleteUser(4);
if(res>0)
System.out.println("删除成功");
sqlSession.commit();
sqlSession.close();
}
? 1、标签对应匹配
? 2、resource绑定mapper需要使用路径
? 3、程序配置文件必须符合规范
? 4、NullPointException,没有注册到资源
? 5、输出的xml存在中文乱码问题
? 6、maven资源没有导出问题
? 假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map!
? Map传递参数，直接在sql中取出key即可 【parameterType="map"】
? 对象传递参数，直接在sql中取对象的属性即可 【parameterType="Object"】
? 只有一个基本类型参数的情况下，可以直接在sql中取到！
? 多个参数用Map，或者注解！
//万能的Map
int addUser2(Map<String,Object> map);
<!--万能的Map
传递Map的key
-->
<insert id="addUser2" parameterType="map">
insert into users (id,name,psw) values(#{userId},#{userName},#{userPsw})
</insert>
@Test
public void addUser2(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userList=sqlSession.getMapper(UserDao.class);
Map<String,Object> map=new HashMap<String, Object>();
map.put("userId",5);
map.put("userName","英诺华");
map.put("userPsw","12345");
int res=userList.addUser2(map);
if(res>0)
System.out.println("插入成功");
//提交事务
sqlSession.commit();
sqlSession.close();
}
模糊查询怎么写？
? 1、Java代码执行时，传递通配符% %；
//模糊查询
@Test
public void getUserLike(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserDao userDao=sqlSession.getMapper(UserDao.class);
List<User> userLists=userDao.getUserLike("%李%");
for (User user : userLists) {
System.out.println(user);
}
sqlSession.close();
}
? 2、在sql拼接中使用通配符！
<!--模糊查询-->
<select id="getUserLike" resultType="com.mybatis.pojo.User">
select * from users where name like "%"#{value}"%"
</select>
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：
configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
? 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">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>
</configuration>
MyBatis 可以配置成适应多种环境
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：
如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
学会使用多套环境
MyBatis默认事务管理器：JDBC，连接池：POOLED
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】
编写配置文件
db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=root
在核心配置文件中引入
<!--核心配置文件-->
<configuration>
<!--引入外部配置文件-->
<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="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>
</configuration>
1、可以直接引入外部文件
2、可以在其中增加一些属性配置
3、如果两个文件有同一个字段，优先使用外部配置文件！
1、类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。
<typeAliases>
<!--可以给实体类起别名-->
<typeAlias type="com.mybatis.pojo.User2" alias="User2"/>
</typeAliases>
2、也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean
扫描实体类的包，他的默认别名就是这个类的类名，首字母建议小写！
<typeAliases>
<!--扫描包-->
<package name="com.mybatis.pojo" />
</typeAliases>
在实体类比较少时使用第一种方式；
如果实体类较多，建议使用第二种方式；
第一种方式可以DIY（自定义）别名，第二种方式则不行，如果非要改，需要在实体类上增加注解
//实体类
@Alias("hello")
public class User2 {
private int id;
private String name;
private String psw;
}
这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
? mybatis-generator-core
? mybatis-plus
? 通用mapper
? MapperRegistry：注册绑定我们 的Mapper文件；
? 方式一：使用相对于类路径的资源引用
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<!-- 方式一：使用相对于类路径的资源引用 -->
<mapper resource="com/mybatis/dao/UserMapper.xml"/>
</mappers>
? 方式二：使用class文件绑定注册
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<!-- 方式一：使用相对于类路径的资源引用 -->
<!--<mapper resource="com/mybatis/dao/UserMapper.xml"/>-->
<!-- 方式二：使用class文件绑定注册-->
<mapper resource="com.mybatis.dao.UserMapper"/>
</mappers>
? 注意点：
? 1、接口和他的Mapper配置文件必须同名！
? 2、接口和他的Mapper配置文件必须在同一个包下！
? 方式三：将包内的映射器接口实现全部注册为映射器
<!--每一个Mapper.xml都需要在MyBatis核心配置中注册-->
<mappers>
<!-- 方式一：使用相对于类路径的资源引用 -->
<!--<mapper resource="com/mybatis/dao/UserMapper.xml"/>-->
<!-- 方式二：使用class文件绑定注册-->
<!-- <mapper class="com.mybatis.dao.UserMapper"/>-->
<!-- 方式三：将包内的映射器接口实现全部注册为映射器-->
<package name="com.mybatis.dao"/>
</mappers>
? 注意点：
? 使用扫描包进行注入绑定，注意点同方式二使用class文件绑定注册。
? 1、接口和他的Mapper配置文件必须同名！
? 2、接口和他的Mapper配置文件必须在同一个包下！
作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题！
SqlSessionFactoryBuilder
? 一旦创建了 SqlSessionFactory，就不再需要它了
? 局部变量
SqlSessionFactory
? 说白了就是可以想象为：数据库连接池
? SqlSessionFactory*一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
? SqlSessionFactory 的最佳作用域是应用作用域
? 最简单的就是使用单例模式或者静态单例模式
SqlSession
? 连接到连接池的一个请求
? SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
? 用完之后需要赶紧关闭，否则资源被占用
这里面的每一个Mapper，就代表一个具体的业务！
数据库中的字段
新建一个项目，拷贝之前的，测试实体类字段不一致的
//实体类
public class User {
private int id;
private String name;
private String password;
解决方法：
1、起别名
2、resultMap
? 结果集映射
数据库字段：id name psw
实体类属性：id name password
<!--namespace绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.mybatis.dao.UserMapper">
<!--结果集映射-->
<resultMap id="UserMap" type="User">
<!--column数据库中的字段 property实体类中的属性-->
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="psw" property="password"/>
</resultMap>
<!--根据id查询-->
<select id="getUserById" resultMap="UserMap">
select * from users where id = #{id}
</select>
resultMap 元素是 MyBatis 中最重要最强大的元素
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
ResultMap 的优秀之处——你完全可以不用显式地配置它们
如果一个数据库操作出现异常，需要拍错，日志就是最好的助手
曾经：sout,debug
现在：日志工厂
SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING
在MyBatis中具体使用那一个日志实现，在设置中设置
STDOUT_LOGGING标准日志输出
? 在MyBats核心配置文件中配置我们的日志
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
什么是Log4j？
Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件。
我们也可以控制每一条日志的输出格式
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
通过一个配置文件来灵活地进行配置，而不需要修改应用的代码
6.2.1、先导入LOG4J的包
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
6.2.2、log4j.properties
### 配置根 ###
log4j.rootLogger = DEBUG,console ,file
### 设置输出sql的级别，其中logger后面的内容全部为jar包中所包含的包名 ###
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
### 配置输出到控制台 ###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.Threshold = DEBUG
log4j.appender.console.layout.ConversionPattern = [%c] -%m%n
### 配置输出到文件 ###
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = ./logs/mybatis.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
6.2.3、配置log4j为日志的实现
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
6.2.4、log4j的使用，直接测试运行刚才的查询
简单使用
1、在要是用log4j的类中导入包 import org.apache.log4j.Logger;
2、日志对象，加载参数为当前类的class
static Logger logger= Logger.getLogger(UserDaoTest.class);
3、日志级别
@Test
public void testLog4j(){
logger.info("info:进入了testLog4j");
logger.debug("debug:进入了testLog4j");
logger.error("error:进入了testLog4j");
}
思考，为什么分页？
减少数据的处理量
使用limit分页
语法：select * from users limit startIndex,pagesize ;
select * from users limit n; //[0,n]
1、接口
//分页
List<User> getUserByLimit(Map<String,Integer> map);
2、Mybatis.xml
<select id="getUserByLimit" parameterType="map" resultType="User">
select *from users limit #{startIndex},#{pageSize};
</select>
3、测试
@Test
public void getUserByLimit(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
UserMapper userMapper= sqlSession.getMapper(UserMapper.class);
Map<String,Integer> map=new HashMap<String,Integer>();
map.put("startIndex",0);
map.put("pageSize",2);
List<User> userList=userMapper.getUserByLimit(map);
for(User user:userList){
System.out.println(user);
}
sqlSession.close();
}
1、接口
//分页2
List<User> getUserByRowBounds(Map<String,Integer> map);
2、mapper.xml
<select id="getUserByRowBounds" resultType="User">
select *from users ;
</select>
3、测试
@Test
public void getUserByRowBounds(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(1, 2);
//通过JAVA代码层面实现分页
List<User> userList=sqlSession.selectList("com.mybatis.dao.UserMapper.getUserByRowBounds",null,rowBounds);
for(User user:userList){
System.out.println(user);
}
sqlSession.close();
}
1、注解在接口上实现
//获取全部查询
@Select("select * from users")
List<User> getUserList();
2、在核心配置文件中绑定接口
<mappers>
<mapper class="com.mybatis.dao.UserMapper"/>
</mappers>
3、测试
本质：反射机制实现
底层：动态代理
MyBatis详细执行流程
关于@Param()注解
? 基本类型参数或者String类型，需要加上
? 引用类型不用
? 如果只有一个基本类型，可以忽略，但是建议使用
? 我们在SQL中引用的就是这里@Param()中设定的属性名！
#{}和${}区别
? #{}能防止SQL注入
1、在工具类创建时实现自动提交事务
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
2、编写接口，增加注解
//获取全部查询
@Select("select * from users")
List<User> getUserList();
//方法存在多个参数，参数前面必须添加@Param("uid")注解
@Select("select * from users where id=#{uid}")
User getUserById(@Param("uid") int id);
@Insert("insert into users(name,psw,id) values(#{name},#{password},#{id})")
int addUser(User user);
3、测试类
【注意：必须要将接口注册绑定到核心配置文件中！】
//查询
@Test
public void getUserList() {
//第一步：获取SqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
//底层主要用运反射
//第二步执行SQL
//getMapper
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> users = userMapper.getUserList();
for (User user : users) {
System.out.println(user);
}
//关闭SqlSession
sqlSession.close();
}
@Test
public void getUserById() {
//第一步：获取SqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
//底层主要用运反射
//第二步执行SQL
//getMapper
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = userMapper.getUserById(2);
System.out.println(user);
//关闭SqlSession
sqlSession.close();
}
@Test
public void addUser() {
//第一步：获取SqlSession对象
SqlSession sqlSession = MyBatisUtils.getSqlSession();
//底层主要用运反射
//第二步执行SQL
//getMapper
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
int result = userMapper.addUser(new User(10,"哈萨克","1234"));
if(result>0)
System.out.println("插入成功！");
//关闭S
qlSession
sqlSession.close();
}
java library、plugs、build tools
//常用注解
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
说明：
@Data:无参构造、get、set、toString、hashCode、equals
@AllArgsConstructor：有参构造
@NoArgsConstructor：无参构造
使用步骤
? 1、在IDEA中安装lombok插件
? 2、在项目中导入lombok的jar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
<scope>provided</scope>
</dependency>
? 3、在实体类上加注解
//实体类
@Data
@AllArgsConstructor
public class User {
private int id;
private String name;
private String password;
}
多个学生对应一个老师
对于学生这边而言，关联..多个学生，关联一个老师【多对一】
对于老师而言，集合..一个老师，有很多学生【一对多】
create table teacher(
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY(`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `teacher` 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);
1、导入lombok
2、建立实体类Teacher，Student
@Data
@NoArgsConstructor
public class Student {
private int id;
private String name;
//学生需要关联一个老师
private Teacher teacher;
}
@Data
@NoArgsConstructor
public class Teacher {
private int id;
private String name;
}
3、建立Mapper接口
public interface StudentMapper {
//查询所有的学生的信息以及对应的老师的信息
public List<Student> getStudent();
public List<Student> getStudent2();
}
public interface TeacherMapper {
@Select("select * from teacher where id = #{tid}")
Teacher getTeacher(@Param("tid") int id);
}
4、建立Mapper.xml文件
5、在核心配置文件中绑定注册Mapper接口或文件
<mappers>
<!--<package name="com.mybatis.dao"/>-->
<mapper class="com.mybatis.dao.TeacherMapper"/>
<mapper class="com.mybatis.dao.StudentMapper"/>
</mappers>
6、测试能否成功
【注意】Error instantiating class com.mybatis.pojo.Student with invalid types (int,String,Teacher) or values (1,小明,1). Cause: java.lang.IllegalArgumentException: argument type mismatch
解决方法：设置无参的构造函数
回顾 Mysql多对一查询方式：
? 子查询
? 连表查询
<!--
思路：按照查询嵌套处理
1、查询所有的学生信息
2、根据查询出来的学生的tid，寻找对应的老师 子查询
-->
<select id="getStudent" resultMap="StudentTeacher">
select * from student;
</select>
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!--复杂的属性我们需要单独处理 对象：association 集合：collection-->
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="Teacher">
select * from teacher where id = #{tid};
</select>
<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
select s.id sid,s.name sname,t.name tname
from student s,teacher t
where s.id=t.id
</select>
<resultMap id="StudentTeacher2" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
</association>
</resultMap>
比如一个老师拥有多个学生
对于老师而言就是一对多
1、导入lombok
2、建立实体类Teacher，Student
@Data
@NoArgsConstructor
public class Teacher {
private int id;
private String name;
//一个老师拥有多个学生
private List<Student> students;
}
@Data
@NoArgsConstructor
public class Student {
private int id;
private String name;
private int tid;
}
3、建立Mapper接口
public interface TeacherMapper {
//获取老师
List<Teacher> getTeacher();
//获取指定老师下的学生及老师信息
Teacher getTeacher2(@Param("tid") int id);
Teacher getTeacher3(@Param("tid") int id);
}
4、建立Mapper.xml文件
5、在核心配置文件中绑定注册Mapper接口或文件
<mappers>
<!--<package name="com.mybatis.dao"/>-->
<mapper class="com.mybatis.dao.TeacherMapper"/>
<mapper class="com.mybatis.dao.StudentMapper"/>
</mappers>
6、测试能否成功
【注意】：出现java.lang.ExceptionInInitializerError
解决方法：看看属性名和property名是否一致
<!--按结果嵌套查询 -->
<select id="getTeacher2" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.id tid,t.name tname
from student s,teacher t
where s.tid=t.id and t.id=#{tid}
</select>
<resultMap id="TeacherStudent" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<!--复杂的属性我们需要单独处理 对象：association 集合：collection javaType="" 指定属性类型 ofType="" 集合中的泛型信息-->
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
<!--按查询嵌套处理-->
<select id="getTeacher3" resultMap="TeacherStudent2">
select * from teacher where id=#{tid};
</select>
<resultMap id="TeacherStudent2" type="Teacher">
<collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
select * from student where tid=#{tid};
</select>
1、关联 association【多对一】
2、集合 collection 【一对多】
3、javaType & ofType
? javaType：用来指定实体类中的属性类型
? ofType：用来指定映射到List或集合中的pojo类型，泛型中的约束类型
4、注意点：
? 保证sql的可读性，尽量保证通俗易懂
? 注意一对多和多对一中的属性名和字段问题
? 如果问题不好排查，可以使用日志，建议使用Log4j
5、面试高频
? MySql引擎
? InnoDB底层原理
? 索引
? 索引优化
什么是动态SQL：动态SQL就是指根据不同的条件生成不同的SQL语句
如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。
if
choose (when, otherwise)
trim (where, set)
foreach
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
创建一个基础工程
1、导包
2、编写配置文件
3、编写实体类
@Data
public class blog {
private int id;
private String title;
private String author;
private Date createTime;
private int views;
}
4、编写实体类对应的Mapper接口和Mapper.xml文件
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from blog
<where>
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author=#{author}
</if>
</where>
</select>
<select id="queryBlogChoose" parameterType="map" resultType="Blog">
select * from blog
<where>
<choose>
<when test="title!=null">
title=#{title}
</when>
<when test="author!=null">
and author=#{author}
</when>
<otherwise>
and views=#{views}
</otherwise>
</choose>
</where>
</select>
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from blog
<where>
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author=#{author}
</if>
</where>
</select>
<update id="updateBlog" parameterType="map">
update blog
<set>
<if test="title!=null">
title=#{title},
</if>
<if test="author!=null">
author=#{author}
</if>
</set>
where id=#{id}
</update>
所谓的动态SQL，本质还是SQL语句，只是可以在SQL层面，去执行一个逻辑代码
有的时候，我们可能会将一些公共部分抽取出来，方便复用
1、使用sql标签抽取公共部分
<sql id="if-title-author">
<if test="title!=null">
and title=#{title}
</if>
<if test="author!=null">
and author=#{author}
</if>
</sql>
2、在需要使用的地方使用include标签引用即可
<select id="queryBlogIf" parameterType="map" resultType="Blog">
select * from blog
<where>
<include refid="if-title-author"></include>
</where>
</select>
注意事项：
? 最好基于单表来定义sql片段！
? 不要存在where标签
<!--现在传递一个万能的map，这map中传递一个集合ids
select * from blog where 1=1 and ( id=1 or id=2 or id=3)-->
<select id="queryBlogByForeach" parameterType="map" resultType="Blog">
select * from blog
<where>
<foreach collection="ids" item="id" open="and (" separator="or" close=")">
id=#{id}
</foreach>
</where>
</select>
@Test
public void queryBlogByForeach(){
SqlSession sqlSession=MyBatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map=new HashMap();
ArrayList<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
ids.add(3);
map.put("ids",ids);
List<Blog> blogs = mapper.queryBlogByForeach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
动态SQL就是在拼接SQL语句，我们只要保证SQL语句的正确性，按照SQL的格式，去排列组合就可以了
建议：
? 先在Mysql中写出完整的SQL，再对应去修改为动态SQL实现通用即可！
查询：连接数据库，耗资源！
一次查询的结果，给他暂存在一个可以直接取到的地方！-->内存：缓存
我们再次查询相同数据的时候，直接走缓存，就不用走数据库了
1、什么是缓存[Cache]？
? 存在内存中的临时数据。
? 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
2、为什么使用缓存？
? 减少和数据库的交互次数，减少系统开销，提高系统效率。
3、什么样的数据能使用缓存？
? 经常查询并且不经常改变的数据。
MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
? 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
? 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
? 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
一级缓存也叫本地缓存：
与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；
测试步骤：
? 1、开启日志
? 2、测试在一个Session中查询两次相同的记录
? 3、查看日志输出
缓存失效情况：
? 1、查询不同的东西
? 2、增删改操作，可能会改变原来的数据，所以必定会刷新缓存
@Test
public void queryUserById(){
SqlSession sqlSession= MyBatisUtils.getSqlSession();
UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
Users user = mapper.queryUserById(1);
System.out.println(user);
System.out.println("========================");
mapper.updateUser(new Users(2,"jiasda","1213"));
System.out.println("========================");
Users user2 = mapper.queryUserById(1);
System.out.println(user2);
System.out.println(user==user2);
sqlSession.close();
}
? 3、查询不同的Mapper.xml
? 4、手动清理缓存
@Test
public void queryUserById(){
SqlSession sqlSession= MyBatisUtils.getSqlSession();
UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
Users user = mapper.queryUserById(1);
System.out.println(user);
System.out.println("========================");
//mapper.updateUser(new Users(2,"jiasda","1213"));
sqlSession.clearCache();//手动清理缓存
System.out.println("========================");
Users user2 = mapper.queryUserById(1);
System.out.println(user2);
System.out.println(user==user2);
sqlSession.close();
}
小结：一级缓存是默认开启的，只在一次Sqlsession中有效，也就是拿到连接到关闭连接这个区间段
一级缓存相当于一个map
二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
工作机制：
? 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
? 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
? 新的会话查询信息，就可以从二级缓存中获取内容；
? 不同的mapper查出的数据会放在自己对应的缓存（map）中；
步骤：
? 1、开启全局缓存
<!--显示开启全局缓存-->
<setting name="cacheEnabled" value="true"/>
? 2、在要使用二级缓存的Mapper.xml中开启二级缓存
<!--在当前Mapper.xml中开启二级缓存-->
<cache/>
? 也可以自定义参数
<!--在当前Mapper.xml中开启二级缓存-->
<cache eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
? 3、测试
? 问题：需要将实体类序列化！否则会报错！
Cause: java.io.NotSerializableException: com.mybatis.pojo.Users
? 小结：
? 只要开启了二级缓存，在同一个Mapper下就有效
? 所有的数据都会先放在一级缓存中
? 只有当会话提交或者关闭的时候，才会提交到二级缓存中
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存。
要在程序中使用ehcache：
1、先导包
<!-- 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>
2、在mapper中指定使用ehcache缓存实现
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
3、导入配置文件ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation = "http://ehcache.org/ehcache.xsd"
updateCheck = "false">
<!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->
<diskStore path = "./tmpdir/Tmp_Ehcache"/>
<!-- 默认的管理策略 -->
<defaultCache
eternal = "false"
maxElementsInMemory = "10000"
overflowToDisk = "false"
diskPersistent = "false"
timeToIdleSeconds = "1800"
timeToLiveSeconds = "259200"
memoryStoreEvictionPolicy = "LRU"/>
<!--demo，10小时-->
<cache
name = "cloud_user"
eternal = "false"
maxElementsInMemory = "5000"
overflowToDisk = "false"
diskPersistent = "false"
timeToIdleSeconds = "1800"
timeToLiveSeconds = "1800"
memoryStoreEvictionPolicy = "LRU"/>
<!-- maxElementsInMemory 内存中最大缓存对象数，看着自己的heap大小来搞 -->
<!-- eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false -->
<!-- maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大 -->
<!-- overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，
会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。-->
<!-- diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。-->
<!-- diskPersistent：是否缓存虚拟机重启期数据 -->
<!-- diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒 -->
<!-- timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，
如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，
EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，
则表示对象可以无限期地处于空闲状态 -->
<!-- timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，
如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，
EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，
则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义 -->
<!-- memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，
Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、
FIFO（先进先出）、LFU（最少访问次数）。-->
</ehcache>
本文是学习B站“遇见狂神说”的课程所做的笔记，有需要的可以去B站关注这个宝藏男孩
标签：equal 外部文件 输出 tst 并且 不同的 关系 个数 写代码
原文地址：https://www.cnblogs.com/P935074243/p/13052829.html
