面试高频
- Mysql引擎
- InnoDB底层原理
- 索引
- 索引优化
简介:
1.MyBatis 是一款优秀的持久层框架
2.它支持自定义 SQL、存储过程以及高级映射。
3.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
4.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。
持久化
数据持久化
1.持久化就是将程序的数据在持久状态和瞬间状态的转化过程
2.jdbc(数据库),io文件持久化
3.生活例子:冰箱冷藏,鲱鱼罐头.......
为什么要持久化
内存:断电及失,有些对象不能丢掉,如money.....内存也太贵了.
持久层
dao.service.controller.filterl.pojo.util==> javaweb的基础层
1.完成持久化工作的代码块
2.层界限十分清楚
第一个mybatis程序
思路:搭建环境-->导入mybatis-->编写代码-->测试
目录要规范哦
1.先创一个简单的maven夫工程(删除src,没用的就删了)
2.导入相应的maven依赖
(资源导出失败问题,记得在子工程里也加上,以防万一)
<dependencies>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<!-- mysql的驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.24</version>
</dependency>
<!-- 测试代码的工具-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<!--在build中配置resources, 来防止我们资源导出失败问题-->
<build>
<resources>
<resource>
<directory>src/main/resources</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>
3在resources里配置mybatis-config.xml==>configuration核心配置文件
具体的mysql配置根据自己电脑上的来配,mappers也是根据自己相应的mapper.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.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/user?userUnicode=true&characterEncoding=utf8&useSSL=true"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/zhang/Dao/getUserMapper.xml"/>
</mappers>
</configuration>
搭建mybatisUtil==>SqlSessionFactory-->SqlSession
package com.zhang.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 MybatisUtil {
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();
}
}
mybatis简单查询
1.pojo
package com.zhang.pojo;
public class User {
private int id;
private String username;
private String password;
public User() {
}
public User(int id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
2.Dao接口
package com.zhang.Dao;
import com.zhang.pojo.User;
import java.util.List;
public interface UserDao {
List<User> getUserList();
}
3.接口类的实现.由DaoImpl转化为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.zhang.Dao.UserDao">
<!-- id对应相应的方法,resultType返回方法的结果集-->
<select id="getUserList" resultType="com.zhang.pojo.User">
select * from user.userinformation
</select>
</mapper>
4.test
mappers也是根据自己相应的mapper.xml来配==》没有注册的后果
org.apache.ibatis.binding.BindingException: Type interface com.zhang.Dao.UserDao is not known to the MapperRegistry.
MapperRegistry是什么?
核心配置文件中注册的mappers
package com.zhang.UserDaoTest;
import com.zhang.Dao.UserDao;
import com.zhang.pojo.User;
import com.zhang.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void Test(){
//1.获取sqlSession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> userList = userDao.getUserList();
for (User user : userList) {
System.out.println(user.getId());
}
//关闭SqlSession
sqlSession.close();
}
}
mybatis实现简单的增删改查(CRUD)
CRUD(增删改查)
C=Create
R=Read
U=Update
D=Delete
对与接口的方法
package com.zhang.Dao;
import com.zhang.pojo.User;
import java.util.List;
public interface UserMapper {
//查询所有用户
List<User> getUserList();
//添加用户
int addUser(User user);
//改用户信息
int updateUser(User user);
//删除用户
int deleteUser(int id);
}
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">
namespace中的包名要和dao/mapper接口的包名一致
<mapper namespace="com.zhang.Dao.UserMapper">
//id:就是对应的namespace中的方法名
//resultType:sql语句执行的返回值
//paramType:参数类型!可对象,可变量
//#{value}==>value对应的是你方法的参数名
<select id="getUserList" resultType="com.zhang.pojo.User">
select * from user.userinformation
</select>
<insert id="addUser" parameterType="com.zhang.pojo.User">
insert into user.userinformation (id, username, password) values (#{id},#{username},#{password})
</insert>
<update id="updateUser" parameterType="com.zhang.pojo.User">
update user.userinformation
set username =#{username},password=#{password}
where id=#{id};
</update>
<delete id="deleteUser" parameterType="int" >
delete
from user.userinformation
where id=#{id};
</delete>
</mapper>
在测试类里的测试
package com.zhang.UserDaoTest;
import com.zhang.Dao.UserMapper;
import com.zhang.pojo.User;
import com.zhang.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserDaoTest {
@Test
public void Test(){
//1.获取sqlSession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = userMapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
//关闭SqlSession
sqlSession.close();
}
@Test
public void addUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int user = mapper.addUser(new User(5, "wang", "123667"));
sqlSession.commit();
sqlSession.close();
}
// 增删改一定要记得提交事务
@Test
public void updateUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.updateUser(new User(2,"王亚","123456"));
if (i>0){
System.out.println("修改成功");
}
sqlSession.commit();
sqlSession.close();
}
@Test
public void deleteUser(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.deleteUser(5);
sqlSession.commit();
sqlSession.close();
}
}
Map在参数的应用
如果,我们的实体类或者数据库的表,字段或参数太多,我们却只要其中的一些值,这个时候可以考虑用Map
List<User> getUser(Map<String,Object> map);
<select id="getUser" parameterType="map" resultType="com.zhang.pojo.User">
select * from user.userinformation where id=#{something} and password=#{password}
</select>
@Test
public void UserList(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Object> map = new HashMap<>();
map.put("something",1);
map.put("password","123456");
List<User> user = mapper.getUser(map);
for (User user1 : user) {
System.out.println(user1);
}
sqlSession.close();
}
Map传递参数,直接在sql中取出key即可 = parameterType="map" =
对象传递参数,直接在sql中取对象的属性即可= parameterType="Object" =
只有一个基本类型参数时,可以直接在sql中取到,就不用写parameterType=".."了
多个参数用Map,或者注解
关于模糊查询 like
1.方法一=>ava代码执行的时候,传递通配符% %
map.put("name","%张%");
2.方法二=>在sql拼接中使用通配符(注意%一定要和#{name}空格隔开哦)
select * from user.userinformation where id=#{something} and username like '%' #{name} '%'
map.put("name","张");
分页的实现
方法一:limit(推荐使用)
接口:
//分页的实现
List<User> userList(Map<String,Integer> map);
Mapper.xml:
<!-- 结果集映射:数据库字段名password.pojo对应的为pwd-->
<resultMap id="userMap" type="User">
<id property="pwd" column="password"></id>
</resultMap>
<select id="userList" parameterType="map" resultMap="userMap">
select *
from user.userinformation
limit #{startIndex},#{pageSize};
</select>
测试:
//limit分页
@Test
public void limitList(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("startIndex",0);
map.put("pageSize",2);
List<User> userList = mapper.userList(map);
for (User user : userList) {
System.out.println(user);
sqlSession.close();
}
}
方法二:ROWBounds分页
方法三:分页插件https://pagehelper.github.io/(方法二,三了解知道有就可以了,具体可以百度)
1.配置MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下:
- configuration(配置)
- properties(属性)
- settings(设置)
- typeAliases(类型别名)
- typeHandlers(类型处理器)
- objectFactory(对象工厂)
- plugins(插件)
- environments(环境配置)
- environment(环境变量)
- transactionManager(事务管理器)
- dataSource(数据源)
- environment(环境变量)
- databaseIdProvider(数据库厂商标识)
- mappers(映射器)(红色要掌握,蓝色不重要)
2.环境配置
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
mybatis默认的事务管理器:JDBC. 连接池:POOLED
(注意:不是唯一的配置 type="[JDBC|MANAGED]".数据源type="[UNPOOLED|POOLED|JNDI]")
3.属性(properties)
我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置,并可以进行动态替换.这些属性可以在外部进行配置,并可以进行动态替换[db.properties]
(注意:xml中的properties一定要放在最上面哦)
db.properties(放在resources目录下)
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/user?userUnicode=true&characterEncoding=UTF-8&useSSL=true
username=root
password=123456
在核心配置文件中引入
<properties resource="db.properties">
<property name="username" value="root"/>
<property name="password" value="111111111"/>
</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>
1.可以直接引入外部文件
2.可以在其中增加一些属性配置
3.如果两个文件有同一字段,优先使用外部配置文件
4.类型别名(typeAliases)
>类型别名可为 Java 类型设置一个缩写名字。
>它仅用于 XML 配置,意在降低冗余的全限定类名书写。
<typeAliases>
<typeAlias type="com.zhang.pojo.User" alias="user"></typeAlias>
</typeAliases>
也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:填写实体类的包,它的默认别名就是这个类的类名,首字母要小写
(注意:大写也没问题的不容易区分是否为别名在使用resultType时)
<typeAliases>
<package name="com.zhang.pojo"/>
</typeAliases>
在实体类比较少的时候,使用第一种方式.
如果实体类十分多的时候,建议用第二种.
第一种可以自己造别名,第二种<不可以>如果非要改,需要在实体类上加注解
@Alias("user")
public class User {
5.设置(settings)
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。(理解一些即可,如要知晓其他https://mybatis.org/mybatis-3/zh/configuration.html#settings)
6.映射器(mappers)
MapperRegistry:注册绑定我们的Mapper文件
方法一:[推荐使用]
<mappers>
<mapper resource="com/zhang/Dao/UserMapper.xml"/>
</mappers>
方法二:使用class文件绑定注册
<mappers>
<mapper class="com.zhang.Dao.UserMapper"/>
</mappers>
方法三:使用扫描包进行绑定注册
<mappers>
<package name="com.zhang.Dao"/>
</mappers>
注意:
1.接口和它的Mapper配置文件必须同名(方法二,三)
2.接口和它的Mapper配置文件必须在同一包下(方法二,三)
7.作用域(Scope)和生命周期
作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder
1.一旦创建了 SqlSessionFactory,就不再需要它了。
2.局部变量
SqlSessionFactory
1.可以想象成:数据库连接池
2.SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。
3. SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到,最简单的就是使用单例模式或者静态单例模式。
SqlSession
1.连接到连接池的一个请求
2.SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。
3.用完之后要赶紧关闭,否则资源被占用
在里面的每一个mapper都代表一个具体的业务
解决属性名和字段名不一致的问题
数据库的字段和pojo里的属性
结果:(出现这个结果一定要有无参构造器,否则走有参构造器那个会pwd还是会出来{'123456'})
解决办法:
1.在sql语句里加上别名
select id,username,password as pwd
from user.userinformation
where id=#{id};
2.结果映射(ResultMap)
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhang.Dao.UserMapper">
<resultMap id="userMap" type="User">
<id property="pwd" column="password"></id>
</resultMap>
<select id="getUser" parameterType="int" resultMap="userMap">
select *
from user.userinformation
where id=#{id};
</select>
</mapper>
ResultMap元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想是,对简单的语句做到零配置,对于复杂一点的语句,只需要描述语句之间的关系就行了。
你会发现上面的例子没有一个需要显式配置ResultMap,这就是ResultMap 的优秀之处——你完全可以不用显式地配置它们。 虽然上面的例子不用显式配置ResultMap。
如果这个世界总是这么简单就好了
使用注解开发
-
面向接口编程
选择原因:
解耦,可拓展,提高复用,分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得开发变容易,规范性更好
什么叫面向接口编程
在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
关于接口的理解。
1.接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。
2.接口的本身反映了系统设计人员对系统的抽象理解。
3.接口应有两类:第一类是对一个个体的抽象,它可对应为一个抽象体(abstract class);
4.第二类是对一个个体某一方面的抽象,即形成一个抽象面(interface);
5.一个体有可能有多个抽象面。
6.抽象体与抽象面是有区别的。
三个面向区别
- 面向对象,我们考虑问题时,以对象为单位,考虑它的属性及方法
- 面向过程,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现
- 接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题,更多的体现就是对系统整体的架构
注解开发的简单实现
1.注解在接口上实现
//查询用户
@Select("Select * from user.userinformation")
List<User> getUser();
2.核心配置文件应该绑定接口
<mappers>
<mapper class="com.zhang.Dao.UserMapper"></mapper>
</mappers>
3.测试
@Test
public void userList(){
//1.获取sqlSession对象
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> user = userMapper.getUser();
for (User user1 : user) {
System.out.println(user1);
}
//关闭SqlSession
sqlSession.close();
}
本质:反射机制实现
底层:动态代理!
Mybatis执行原理
注解实现->CRUD
我们可以在工具类创建的时候实现自动提交事务(最好不要开启,不易排错..新手)
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession(true);
}
源代码:
public SqlSession openSession(boolean autoCommit) {
return this.sqlSessionFactory.openSession(autoCommit);
}
编写接口,增加注解
//查询用户
@Select("Select * from user.userinformation")
List<User> getUser();
//添加用户
//方法存在多个参数,所有的参数前面必须加上@Param()注解
@Insert("INSERT INTO userinformation (ID, USERNAME, PASSWORD) VALUES (#{id},#{username},#{password})")
int addUser(User user);
//改用户信息
@Update("update userinformation set password = '222222' where id=#{uid};")
int updateUser(@Param("uid") int id);
//删除用户
@Delete("delete from userinformation where id=#{id} and username=#{username}")
int deleteUser(@Param("id") int id,@Param("username") String username);
测试类(注意:我们必须要将注册绑定到我们的核心配置文件中)
public class UserDaoTest {
@Test
public void userList(){
//1.获取sqlSession对象,查
SqlSession sqlSession = MybatisUtil.getSqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
int i=0;
List<User> user = userMapper.getUser();
for (User user1 : user) {
System.out.println(user1);
}
//增
i = userMapper.addUser(new User(6, "王五", "12345"));
//删
i= userMapper.deleteUser(2, "王亚");
//改
i= userMapper.updateUser(1);
if (i>0){
System.out.println("ok");
}
//关闭SqlSession
sqlSession.close();
}
关于@Param()注解
- 基本类型的参数或者String类型,需要加上
- 引用类型不需要加
- 如果只有一个基本类型的话,可以忽略,但是建议大家加上
- 我们在SQL中引用的就是我们的@Param()中设定的属性名
使用注解来映射简单语句会使代码显得更加简洁,但对于稍微复杂一点的语句,Java 注解不仅力不从心,还会让你本就复杂的 SQL 语句更加混乱不堪。 因此,如果你需要做一些很复杂的操作,最好用 XML 来映射语句。
复杂查询
多对一与一对多
association
– 一个复杂类型的关联;许多结果将包装成这种类型- 嵌套结果映射 – 关联可以是
resultMap
元素,或是对其它结果映射的引用
- 嵌套结果映射 – 关联可以是
collection
– 一个复杂类型的集合- 嵌套结果映射 – 集合可以是
resultMap
元素,或是对其它结果映射的引用
- 嵌套结果映射 – 集合可以是
环境搭建
1.数据库的准备
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);
2.其他class的准备工作
TeacherMapper.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.zhang.Dao.TeacherMapper">
</mapper>
1.导入lombok
2.新建实体类Teacher,Student
3.建立mapper接口
4.建立mapper.xml
5.在核心配置文件中绑定注册我们的mapper接口或者文件
6.测试查询是否可行
复杂的属性,我们需要单独处理 对象:association 集合:collection
多对一的简单应用=>查询学生及其对应的老师
实体类及接口
@Data
@ToString
public class Teacher {
private int id;
private String name;
}
@Data
@ToString
public class Student {
private int id;
private String name;
private Teacher teacher;
}
public interface StudentMapper {
// 查询所有学生及其对应的老师
List<Student> studentList();
}
按照结果嵌套处理 StudentMapper.xml
<select id="studentList" resultMap="TeacherStudent">
select t.name tname,s.id sid,s.name sname from user.student s,user.teacher t where s.tid=t.id
</select>
<resultMap id="TeacherStudent" type="com.zhang.pojo.Student">
<result column="sid" property="id"/>
<result column="sname" property="name"/>
<association property="teacher" javaType="com.zhang.pojo.Teacher">
<result column="tname" property="name"/>
</association>
</resultMap>
结果:
按照查询嵌套处理 StudentMapper.xml
思路:
1.查询所有的学生信息
2.根据查询出来的学生的tid,寻找对应的老师/ 子查询
<select id="studentList" resultMap="TeacherStudent2">
select * from user.student
</select>
<select id="getTeacher" resultType="com.zhang.pojo.Teacher">
select * from user.teacher
</select>
<resultMap id="TeacherStudent2" type="com.zhang.pojo.Student">
<result column="id" property="id"/>
<result column="name" property="name"/>
<association property="teacher" column="tid" javaType="com.zhang.pojo.Teacher" select="getTeacher"/>
</resultMap>
结果 :
mysql多对一的查询方式
1.联表查询
2.子查询
一对多的简单应用
比如:一个老师对多个学生
对于老师而言就是一对多
实体类和接口
@Data
@ToString
public class Teacher {
private int id;
private String name;
private List<Student> students;
}
@Data
@ToString
public class Student {
private int id;
private String name;
private int tid;
}
public interface TeacherMapper {
//一个老师查询多个学生
List<Teacher> teacherList(@Param("tid") int tid);
}
按照结果嵌套处理
<resultMap id="TeacherStudent" type="com.zhang.pojo.Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="com.zhang.pojo.Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
<select id="teacherList" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.id tid,t.name tname
from user.teacher t,user.student s where s.tid=t.id and t.id=#{tid}
</select>
结果:
Teacher(id=1, name=张老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])
按照查询嵌套处理
<select id="teacherList" resultMap="TeacherStudent">
select * from user.teacher where id=#{tid}
</select>
<select id="studentList" resultType="com.zhang.pojo.Student">
select * from user.student where tid=#{id}
</select>
<resultMap id="TeacherStudent" type="com.zhang.pojo.Teacher">
<collection property="students" javaType="ArrayList" ofType="com.zhang.pojo.Student" select="studentList" column="id" />
</resultMap>
Teacher(id=0, name=张老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])
小结:
1.关联:association
2.集合:collection
3.javaType & ofType
- javaType 用来指定实体类中的属性类型
- ofType 用来指定映射到List或者集合中的pojo类型,泛型中的约束类型
注意点:
- 保证SQL的可读性,尽量保证通俗易懂
- 注意一对多和多对一中,属性名和字段名的问题
- 如果问题不好排查错误,可以使用日志,建议使用Log4j
动态SQL
什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句
本质还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码
动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
- 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
创建一个基础工程
导包
<dependencies>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
<scope>provided</scope>
</dependency>
编写配置文件
mapUnderscoreToCamelCase | 是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn |
<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="db.properties">
<property name="username" value="root"/>
</properties>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<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>
<mappers>
<mapper class="com.zhang.Dao.BlogMapper"/>
</mappers>
</configuration>
编写实体类
@Data
@ToString
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
}
编写实体类对应Mapper接口和Mapper.xml文件
public interface BlogMapper {
int addBlog(Blog blog);
}
<?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.zhang.Dao.BlogMapper">
<insert id="addBlog" parameterType="com.zhang.pojo.Blog">
insert into user.blog (id, title, author, create_time, views) values (#{id}, #{title},#{author}, #{createTime}, #{views})
</insert>
</mapper>
对于随机id的处理
public class IdUtil {
public static String getId(){
return UUID.randomUUID().toString().replaceAll("-","");
}
}
测试类
public class MyTest {
@Test
public void addBlogTest(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
Blog blog = new Blog();
blog.setId(IdUtil.getId());
blog.setTitle("Mybatis is easy");
blog.setAuthor("张三");
blog.setCreateTime(new Date());
blog.setViews(9999);
int i=mapper.addBlog(blog);
blog.setId(IdUtil.getId());
blog.setTitle("Java is easy");
i=mapper.addBlog(blog);
blog.setId(IdUtil.getId());
blog.setTitle("Spring is easy");
i=mapper.addBlog(blog);
blog.setId(IdUtil.getId());
blog.setTitle("微服务 is easy");
i=mapper.addBlog(blog);
sqlSession.close();
}
}
文件结构
IF
接口
//根据文章或者作者查询相应记录
List<Blog> queryBlogByIf(Map map);
xml
where 1=1(不正规)可以换成<where></where>标签哦
<resultMap id="Blog" type="com.zhang.pojo.Blog"/>
<select id="queryBlogByIf" parameterType="map" resultMap="Blog">
select *
from user.blog where 1=1
<if test="title != null">
and title like '%' #{title} '%'
</if>
<if test="author != null">
and author like '%' #{author} '%'
</if>
</select>
测试类
@Test
public void queryBlogByIf(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
map.put("title","java");
map.put("author","张三");
List<Blog> blogs = mapper.queryBlogByIf(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
}
choose、when、otherwise
MyBatis 提供了 choose 元素,它有点像 Java 中的 switch 语句
它满足一个条件就直接结束,不会再走下去了
xml配置文件:
<select id="queryBlogByChoose" parameterType="map" resultMap="Blog">
select *
from user.blog
<where>
<choose>
<when test="title != null">
title like '%' #{title} '%'
</when>
<when test="author != null">
and author like '%' #{author} '%'
</when>
<otherwise>
and views>=#{}
</otherwise>
</choose>
</where>
</select>
测试类:
@Test
public void queryBlogByChoose(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
map.put("title","java");
map.put("author","张三");
map.put("views",999);
List<Blog> blogs = mapper.queryBlogByChoose(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
}
结果:
trim、where、set
if中xml的改进方法
where :
元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。
<resultMap id="Blog" type="com.zhang.pojo.Blog"/>
<select id="queryBlogByIf" parameterType="map" resultMap="Blog">
select *
from user.blog
<where>
<if test="title != null">
title like '%' #{title} '%'
</if>
<if test="author != null">
and author like '%' #{author} '%'
</if>
</where>
</select>
set:
元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号(这些逗号是在使用条件语句给列赋值时引入的)。
接口:
//更新博客信息
int updateBlog(Map map);
xml配置文件:
<update id="updateBlog" parameterType="map">
update user.blog
<set>
<if test="title != null">
title=#{title},
</if>
<if test="author != null">
author=#{author}
</if>
where id=#{id}
</set>
</update>
测试类及结果:
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
map.put("title","java");
map.put("author","李四");
map.put("id","7a544fffbb3a45bd8da95ffe17cfb6b5");
mapper.updateBlog(map);
trim:
trim就是自定义一些元素(要想知道更多,百度上详细去了解)
和 where 元素等价的自定义 trim 元素为:
<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
</trim>
prefixOverrides 属性会忽略通过管道符分隔的文本序列(注意此例中的空格是必要的)。上述例子会移除所有 prefixOverrides 属性中指定的内容,并且插入 prefix 属性中指定的内容。
与 set 元素等价的自定义 trim 元素吧:
<trim prefix="SET" suffixOverrides=",">
...
</trim>
SQL片段
有的时候,我们可能会将一些公共的部分抽取出来,方便复用
1.使用SQL标签抽取公共的部分
<sql id="queryBlogByIf-title-author">
<if test="title != null">
title like '%' #{title} '%'
</if>
<if test="author != null">
and author like '%' #{author} '%'
</if>
</sql>
2.在需要使用的地方使用include标签引用即可
<select id="queryBlogByIf" parameterType="map" resultMap="Blog">
select *
from user.blog
<where>
<include refid="queryBlogByIf-title-author"></include>
</where>
</select>
注意事项:
- 最好基于单表来定义SQL片段
- 不要存在where标签(这样用的范围会变小的哦)
foreach
动态 SQL 的另一个常见使用场景是对集合进行遍历(尤其是在构建 IN 条件语句的时候)
WHERE ID in (1,2,3) ==> where (id=1 or id=2 or id=3)
简单实现:
接口
List<Blog> queryBlogByForEach(Map map);
xml配置文件
<resultMap id="Blog" type="com.zhang.pojo.Blog"/>
<select id="queryBlogByForEach" parameterType="map" resultMap="Blog">
select * from user.blog
<where>
<foreach collection="ids" item="id" open="(" close=")" separator="or">
id= #{id}
</foreach>
</where>
</select>
测试类及结果
@Test
public void queryByForEach(){
SqlSession sqlSession = MybatisUtil.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap map = new HashMap();
ArrayList<String> ids = new ArrayList<>();
ids.add("1");
ids.add("2");
ids.add("5");
map.put("ids",ids);
List<Blog> blogs = mapper.queryBlogByForEach(map);
for (Blog blog : blogs) {
System.out.println(blog);
}
}
缓存
简介
1.什么是缓存(cache)
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决高并发系统的性能问题
2.为什么使用缓存?
- 减少和数据库的交互次数,减少系统开销,提高系统效率
3.怎么样的数据能使用缓存?
- 经常查询并且不经常改变的数据
Mybatis缓存
- Mybatis 包含一个非常强大的查询缓存特性,它可以非常方便地制定和配置缓存,缓存可以极大的提升查询效率
- Mybaatis系统中默认定义了两级缓存:一级缓存和二级缓存
-
默认情况下,只启用了本地的会话缓存(SqlSession级别的缓存),它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存(基于namespace级别的缓存)
- 为了提高扩展性,Mybatis定义了缓存接口Cache,我们可以通过实现Cache接口来自定义二级缓存
一级缓存
一级缓存也叫本地缓存:
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库
测试步骤:
1.开启日志!
2.测试在一个Sesion中查询两次相同记录
3.查看日志输出
缓存失效的情况:
1.查询不同的东西
2.增删改操作,可能会改变原来的数据,所以必定会刷新缓存!
3.查询不同的Mapper.xml
4.手动清理缓存
小结:
一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段
一级缓存相当于一个Map
二级缓存
- 二级缓存也叫全局缓存,一级缓存作用域太低了,所有诞生了二级缓存
- 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
- 工作机制
- 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的时候,会话闭关了,一级缓存中的数据被保存到了二级缓存中;
- 新的会话查询信息,就可以从二级缓存中获取内容
- 不同的mapper查出的数据会放在自己对应的缓存(map)中
步骤:
1.开启全局缓存==>mybatis-config.xml
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false | true |
默认开启了,但还要手动开启,方便别人知道
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="cacheEnabled" value="true"/>
</settings>
2.在当前的Mapper.xml中使用二级缓存(cache还有些配置可以自己搞,但没必要哦,useCache默认true)
<mapper namespace="com.zhang.Dao.UserMapper">
<cache/>
<select id="userList" resultType="User" useCache="true">
select * from user.userinformation where id=#{id}
</select>
3.测试
问题:我们需要将实体类序列化,否则会报错.
Error serializing object. Cause: java.io.NotSerializableException: com.zhang.pojo.User
小结:
- 只要开启了二级缓存,在同一个Mapper下就是有效的
- 所有的数据都会先放在一级缓存中
- 只有当会话提交,或者关闭的时候,才会提交到二级缓存中
缓存原理:
Mybatis-日志
SLF4J | LOG4J(掌握) | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING(掌握) | NO_LOGGING |
日志工厂
如果一个数据库操作,出现了异常,我们需要排错,日志就是最好的助手
曾经:sout,debug
现在:日志工厂
1.STDOUT_LOGGING
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
标准的日志工厂实现,在设置里设定( STDOUT_LOGGING标准日志输出)
(name和value的值一定要注意了,一模一样哦)
2.Log4j
什么是Log4j?
1.通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
2.我们也可以控制每一条日志的输出格式
3.通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程
4.通过一个配置文件来灵活地进行配置,而不需要修改应用的代码
1.先导入log4j的包
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
2.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/zhang.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
3.配置log4j为日志的实现
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
直接测试运行刚才的查询
简单的使用
1.在要使用Log4j的类中.导入包
2.日志对象,参数要为当前类的class
public class UserDaoTest {
static Logger logger = Logger.getLogger(UserDaoTest.class);
3.日志级别
@Test
public void log4j(){
logger.debug("debug进入了log4jTest");
logger.error("error进入了log4jTest");
logger.info("info进入了log4jTest");
}
[DEBUG][21-06-01][UserDaoTest]debug进入了log4jTest
[ERROR][21-06-01][UserDaoTest]error进入了log4jTest
[INFO][21-06-01][UserDaoTest]info进入了log4jTest
Lombok的使用
简介:
Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.
使用
(公司用你们就用,公司不用你们就别用)
setting中下载Lombok的插件
导入lombok的jar包
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
<scope>provided</scope>
</dependency>
说明:
@Data:无参构造,get,set,tostring,hashcode,equals
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Getter
ps:根据狂神视频+自己所理解(min)笔记