持久化
持久化是将程序数据在持久状态和瞬时状态间转换的机制。
即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用
是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。
为什么需要持久化服务呢？那是由于内存本身的缺陷引起的
内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的
是，人们还无法保证内存永不掉电。内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直待在内存中，需要持久化来缓存到外存。
持久层
什么是持久层？
完成持久化工作的代码块 . ----> dao层 【DAO (Data Access Object) 数据访问对象】
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加
以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多
是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许
是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久
单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专著于数据持久
化逻辑的实现.
与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。 【说白了就
是用来操作数据库存在的！】
为什么需要Mybatis
Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等... , 通过框架可以减少重复代码,提高开发效率 .
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别
MyBatis的优点
简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个
sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的
设计思路和实现。
灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统
一管理和优化。通过sql语句可以满足操作数据库的所有需求。
解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设
计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
提供xml标签，支持编写动态sql
MyBatis第一个程序
搭建实验数据库
CREATE DATABASE `mybatis`; USE `mybatis`; DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` int(20) NOT NULL, `name` varchar(30) DEFAULT NULL, `pwd` varchar(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
导入MyBatis相关 jar 包
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency>
编写MyBatis核心配置文件
<?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=utf8"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments> <mappers> <mapper resource="com/kuang/dao/userMapper.xml"/> </mappers> </configuration>
编写MyBatis工具类
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 MybatisUtils { private static SqlSessionFactory sqlSessionFactory; static { try {String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); } catch (IOException e) { e.printStackTrace(); } }//获取SqlSession连接 public static SqlSession getSession(){ return sqlSessionFactory.openSession(); } }
创建实体类
public class User { private int id; //id private String name; //姓名 private String pwd; //密码 //构造,有参,无参 //set/get //toString() }
编写Mapper接口类
import com.kuang.pojo.User; import java.util.List; public interface UserMapper { List<User> selectUser(); }
编写Mapper.xml配置文件
namespace 十分重要，不能写错！
<?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.kuang.dao.UserMapper"> <select id="selectUser" resultType="com.kuang.pojo.User"> select * from user </select> </mapper>
编写测试类
Junit 包测试
public class MyTest { @Test public void selectUser() { SqlSession session = MybatisUtils.getSession(); //方法一: //List<User> users = session.selectList("com.kuang.mapper.UserMapper.selectUser"); //方法二: UserMapper mapper = session.getMapper(UserMapper.class); List<User> users = mapper.selectUser(); for (User user: users){ System.out.println(user); }session.close(); } }
select
select标签是mybatis中最常用的标签之一
select语句有很多属性可以详细配置每一条SQL语句
id
命名空间中唯一的标识符
接口中的方法名与映射文件中的SQL语句ID 一一对应
parameterType
传入SQL语句的参数类型 。【万能的Map，可以多尝试使用】
resultType
SQL语句返回值类型。【完整的类名或者别名】
根据id查询用户
在UserMapper中添加对应方法
public interface UserMapper { //查询全部用户 List<User> selectUser(); //根据id查询用户 User selectUserById(int id); }
在UserMapper.xml中添加Select语句
<select id="selectUserById" resultType="com.kuang.pojo.User"> select * from user where id = #{id} </select>
根据 密码 和 名字 查询用户
思路一：直接在方法中传递参数
1. 在接口方法的参数前加 @Param属性
2. Sql语句编写的时候，直接取@Param中设置的值即可，不需要单独设置参数类型
//通过密码和名字查询用户 User selectUserByNP(@Param("username") String username,@Param("pwd") String pwd); /* <select id="selectUserByNP" resultType="com.kuang.pojo.User"> select * from user where name = #{username} and pwd = #{pwd} </select> */
思路二：使用万能的Map
1. 在接口方法中，参数直接传递Map；
User selectUserByNP2(Map<String,Object> map);
编写sql语句的时候，需要传递参数类型，参数类型为map
<select id="selectUserByNP2" parameterType="map" resultType="com.kuang.pojo.User"> select * from user where name = #{username} and pwd = #{pwd} </select>
在使用方法的时候，Map的 key 为 sql中取的值即可，没有顺序要求！
Map<String, Object> map = new HashMap<String, Object>(); map.put("username","小明"); map.put("pwd","123456"); User user = mapper.selectUserByNP2(map);
insert
我们一般使用insert标签进行插入操作，它的配置和select标签差不多！
给数据库增加一个用户
在UserMapper接口中添加对应的方法
//添加一个用户 int addUser(User user);
在UserMapper.xml中添加insert语句
<insert id="addUser" parameterType="com.kuang.pojo.User"> insert into user (id,name,pwd) values (#{id},#{name},#{pwd}) </insert>
测试
@Test public void testAddUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = new User(5,"王五","zxcvbn"); int i = mapper.addUser(user); System.out.println(i); session.commit(); //提交事务,重点!不写的话不会提交到数据库 session.close(); }
增、删、改操作需要提交事务！
update
我们一般使用update标签进行更新操作，它的配置和select标签差不多！
修改用户的信息
编写接口方法
//修改一个用户 int updateUser(User user);
编写对应的配置文件SQL
<update id="updateUser" parameterType="com.kuang.pojo.User"> update user set name=#{name},pwd=#{pwd} where id = #{id} </update>
测试
@Test public void testUpdateUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.selectUserById(1); user.setPwd("asdfgh"); int i = mapper.updateUser(user); System.out.println(i); session.commit(); //提交事务,重点!不写的话不会提交到数据库 session.close(); }
delete
我们一般使用delete标签进行删除操作，它的配置和select标签差不多
根据id删除一个用户
编写接口方法
//根据id删除用户 int deleteUser(int id);
编写对应的配置文件SQL
<delete id="deleteUser" parameterType="int"> delete from user where id = #{id} </delete>
测试
@Test public void testDeleteUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); int i = mapper.deleteUser(5); System.out.println(i); session.commit(); //提交事务,重点!不写的话不会提交到数据库 session.close(); }
所有的增删改操作都需要提交事务！
接口所有的普通参数，尽量都写上@Param参数，尤其是多个参数时，必须写上！
有时候根据业务的需求，可以考虑使用map传递参数！
为了规范操作，在SQL的配置文件中，我们尽量将Parameter参数和resultType都写上！
核心配置文件
mybatis-confifig.xml 系统核心配置文件
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
能配置的内容如下：
configuration（配置） properties（属性） settings（设置） typeAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） plugins（插件） environments（环境配置） environment（环境变量） transactionManager（事务管理器） dataSource（数据源） databaseIdProvider（数据库厂商标识） mappers（映射器） <!-- 注意元素节点的顺序！顺序不对会报错 -->
environments元素
<environments default="development"> <environment id="development"> <transactionManager type="JDBC"> <property name="..." value="..."/> </transactionManager> <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>
配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，必须指定其中一个为默认运行
环境（通过default指定）
子元素节点：environment
具体的一套环境，通过设置id进行区别，id保证唯一！
子元素节点：transactionManager - [ 事务管理器 ]
<!-- 语法 --> <transactionManager type="[ JDBC | MANAGED ]"/>
这两种事务管理器类型都不需要设置任何属性。
子元素节点：数据源（dataSource）
dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
数据源是必须配置的。
有三种内建的数据源类型
type="[UNPOOLED|POOLED|JNDI]"）
unpooled： 这个数据源的实现只是每次被请求时打开和关闭连接。
pooled： 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来 , 这是一种使得
并发 Web 应用快速响应请求的流行处理方式。
jndi：这个数据源的实现是为了能在如 Spring 或应用服务器这类容器中使用，容器可以
集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。
数据源也有很多第三方的实现，比如dbcp，c3p
mappers
映射器 : 定义映射SQL语句文件
既然 MyBatis 的行为其他元素已经配置完了，我们现在就要定义 SQL 映射语句了。但是首先我们需要告诉 MyBatis 到哪里去找到这些语句。 Java 在自动查找这方面没有提供一个很好的方法，所以最佳的方式是告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用， 或完全限定资源定位符（包括 file:/// 的 URL），或类名和包名等。映射器是MyBatis中最核心的组件之一，在MyBatis 3之前，只支持xml映射器，即：所有的SQL语句都必须在xml文件中配置。而从MyBatis 3开始，还支持接口映射器，这种映射器方式允许以Java代码的方式注解定义SQL语句，非常简洁。
引入资源方式
<!-- 使用相对于类路径的资源引用 --> <mappers> <mapper resource="org/mybatis/builder/PostMapper.xml"/> </mappers>
<!-- 使用完全限定资源定位符（URL） --> <mappers> <mapper url="file:///var/mappers/AuthorMapper.xml"/> </mappers>
<!-- 使用映射器接口实现类的完全限定类名 需要配置文件名称和接口名称一致，并且位于同一目录下 --> <mappers> <mapper class="org.mybatis.builder.AuthorMapper"/> </mappers>
<!-- 将包内的映射器接口实现全部注册为映射器 但是需要配置文件名称和接口名称一致，并且位于同一目录下 --> <mappers> <package name="org.mybatis.builder"/> </mappers>
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"> <mapper namespace="com.x.mapper.UserMapper"> </mapper>
namespace中文意思：命名空间，作用如下：
1. namespace和子元素的id联合保证唯一 , 区别不同的mapper
2. 绑定DAO接口
namespace的命名必须跟某个接口同名
接口中的方法与映射文件中sql语句id应该一一对应
3. namespace命名规则 : 包名+类名
MyBatis 的真正强大在于它的映射语句，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 为聚焦于 SQL 而构建，以尽可能地为你减少麻烦。
Properties优化
数据库这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过properties 元素的子元素来传递
在资源目录下新建一个db.properties
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mybatis? useSSL=true&useUnicode=true&characterEncoding=utf8 username=root password=123456
将文件导入properties 配置文件
<configuration> <!--导入properties文件--> <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> <mappers> <mapper resource="mapper/UserMapper.xml"/> </mappers> </configuration>
typeAliases优化
类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。
<!--配置别名,注意顺序--> <typeAliases> <typeAlias type="com.x.pojo.User" alias="User"/> </typeAliases>
也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如:
<typeAliases> <package name="com.x.pojo"/> </typeAliases>
自动映射
resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC
ResultSets 数据提取代码中解放出来。
实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同
等功能的长达数千行的代码。
ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。
你已经见过简单映射语句的示例了，但并没有显式指定 resultMap 。比如：
<select id="selectUserById" resultType="map"> select id , name , pwd from user where id = #{id} </select>
上述语句只是简单地将所有的列映射到 HashMap 的键上，这由 resultType 属性指定。虽然在
大部分情况下都够用，但是 HashMap 不是一个很好的模型。你的程序更可能会使用 JavaBean 或POJO（Plain Old Java Objects，普通老式 Java 对象）作为模型。
ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。
手动映射
返回值类型为resultMap
<select id="selectUserById" resultMap="UserMap"> select id , name , pwd from user where id = #{id} </select>
编写resultMap，实现手动映射
<resultMap id="UserMap" type="User"> <!-- id为主键 --> <id column="id" property="id"/> <!-- column是数据库表的列名 , property是对应实体类的属性名 --> <result column="name" property="name"/> <result column="pwd" property="password"/> </resultMap>
标准日志实现
指定 MyBatis 应该使用哪个日志记录实现。如果此设置不存在，则会自动发现日志记录实现。
<settings><setting name="logImpl" value="STDOUT_LOGGING"/> </settings>
Log4j
Log4j是Apache的一个开源项目
通过使用Log4j，我们可以控制日志信息输送的目的地：控制台，文本，GUI组件....
我们也可以控制每一条日志的输出格式；
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
导入log4j的包
<dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
配置文件编写
#将等级为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/kuang.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
setting设置日志实现
<settings> <setting name="logImpl" value="LOG4J"/> </settings>
在程序中使用Log4j进行输出！
//注意导包：org.apache.log4j.Logger static Logger logger = Logger.getLogger(MyTest.class); @Test public void selectUser() { logger.info("info：进入selectUser方法"); logger.debug("debug：进入selectUser方法"); logger.error("error: 进入selectUser方法"); SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); List<User> users = mapper.selectUser(); for (User user: users){ System.out.println(user); }session.close(); }
limit实现分页
#语法 SELECT * FROM table LIMIT stratIndex，pageSize SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15 #为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1： SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last. #如果只给定一个参数，它表示返回最大的记录行数目： SELECT * FROM table LIMIT 5; //检索前 5 个记录行 #换句话说，LIMIT n 等价于 LIMIT 0,n。
修改Mapper文件
<select id="selectUser" parameterType="map" resultType="user"> select * from user limit #{startIndex},#{pageSize} </select>
Mapper接口，参数为map
//选择全部用户实现分页 List<User> selectUser(Map<String,Integer> map);
在测试类中传入参数测试
推断：起始位置 = （当前页面 - 1 ） * 页面大小
//分页查询 , 两个参数startIndex , pageSize @Test public void testSelectUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); int currentPage = 1; //第几页 int pageSize = 2; //每页显示几个 Map<String,Integer> map = new HashMap<String,Integer>(); map.put("startIndex",(currentPage-1)*pageSize); map.put("pageSize",pageSize); List<User> users = mapper.selectUser(map); for (User user: users){ System.out.println(user); }session.close(); }
面向接口编程
接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口的本身反映了系统设计人员对系统的抽象理解。
接口应有两类：
第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
一个体有可能有多个抽象面。抽象体与抽象面是有区别的。
三个面向区别
面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构
利用注解开发
mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建
sql 类型主要分成 :
@select ()
@update ()
@Insert ()
@delete ()
利用注解开发就不需要mapper.xml映射文件了 .
添加注解
//查询全部用户 @Select("select id,name,pwd password from user") public List<User> getAllUser();
在mybatis的核心配置文件中注入
<!--使用class绑定接口--> <mappers> <mapper class="com.kuang.mapper.UserMapper"/> </mappers>
测试
@Test public void testGetAllUser() { SqlSession session = MybatisUtils.getSession(); //本质上利用了jvm的动态代理机制 UserMapper mapper = session.getMapper(UserMapper.class); List<User> users = mapper.getAllUser(); for (User user : users){ System.out.println(user); }session.close(); }
注解增删改
改造MybatisUtils工具类的getSession( ) 方法，重载实现。
//获取SqlSession连接 public static SqlSession getSession(){ return getSession(true); //事务自动提交 }public static SqlSession getSession(boolean flag){ return sqlSessionFactory.openSession(flag); }
确保实体类和数据库字段对应
查询
编写接口方法注解
//根据id查询用户 @Select("select * from user where id = #{id}") User selectUserById(@Param("id") int id);
测试
@Test public void testSelectUserById() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.selectUserById(1); System.out.println(user); session.close(); }
新增
编写接口方法注解
//添加一个用户 @Insert("insert into user (id,name,pwd) values (#{id},#{name},#{pwd})") int addUser(User user);
测试
@Test public void testAddUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = new User(6, "秦疆", "123456"); mapper.addUser(user); session.close(); }
修改
编写接口方法注解
//修改一个用户 @Update("update user set name=#{name},pwd=#{pwd} where id = #{id}") int updateUser(User user);
测试
@Test public void testUpdateUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = new User(6, "秦疆", "zxcvbn"); mapper.updateUser(user); session.close(); }
删除
编写接口方法注解
//根据id删除用 @Delete("delete from user where id = #{id}") int deleteUser(@Param("id")int id);
测试
@Test public void testDeleteUser() { SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); mapper.deleteUser(6); session.close(); }
关于@Param
@Param注解用于给方法参数起一个名字。以下是总结的使用原则：
在方法只接受一个参数的情况下，可以不使用@Param。
在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
如果参数是 JavaBean ， 则不能使用@Param。
不使用@Param注解时，参数只能有一个，并且是Javabean。
#与$的区别
#{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】
INSERT INTO user (name) VALUES (#{name}); INSERT INTO user (name) VALUES (?);
${} 的作用是直接进行字符串替换
INSERT INTO user (name) VALUES ('${name}'); INSERT INTO user (name) VALUES ('kuangshen');
多对一的处理
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');
【Lombok的使用】
1. IDEA安装Lombok插件
2. 引入Maven依赖
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.10</version> </dependency>
在代码中增加注解
@Data //GET,SET,ToString，有参，无参构造 public class Teacher { private int id; private String name; }
@Data public class Student { private int id; private String name; //多个学生可以是同一个老师，即多对一 private Teacher teacher; }
编写实体类对应的Mapper接口 【两个】
public interface StudentMapper { }
public interface TeacherMapper { }
编写Mapper接口对应的 mapper.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.kuang.mapper.StudentMapper"> </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"> <mapper namespace="com.kuang.mapper.TeacherMapper"> </mapper>
按查询嵌套处理
给StudentMapper接口增加方法
//获取所有学生及对应老师的信息 public List<Student> getStudents();
编写对应的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"> <mapper namespace="com.kuang.mapper.StudentMapper"> <!-- 需求：获取所有学生及对应老师的信息 思路：1. 获取所有学生的信息 2. 根据获取的学生信息的老师ID->获取该老师的信息 3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般 使用关联查询？ 1. 做一个结果集映射：StudentTeacher 2. StudentTeacher结果集的类型为 Student 3. 学生中老师的属性为teacher，对应数据库中为tid。 多个 [1,...）学生关联一个老师=> 一对一，一对多 4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查 询 --> <select id="getStudents" resultMap="StudentTeacher"> select * from student </select> <resultMap id="StudentTeacher" type="Student"> <!--association关联属性 property属性名 javaType属性类型 column在多 的一方的表中的列名--> <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/> </resultMap> <!-- 这里传递过来的id，只有一个属性的时候，下面可以写任何值 association中column多参数配置： column="{key=value,key=value}" 其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的 字段名。--> <select id="getTeacher" resultType="teacher"> select * from teacher where id = #{id} </select> </mapper>
编写完毕去Mybatis配置文件中，注册Mapper
注意点说明：
<resultMap id="StudentTeacher" type="Student"> <!--association关联属性 property属性名 javaType属性类型 column在多的一方 的表中的列名--> <association property="teacher" column="{id=tid,name=tid}" javaType="Teacher" select="getTeacher"/> </resultMap> <!-- 这里传递过来的id，只有一个属性的时候，下面可以写任何值 association中column多参数配置： column="{key=value,key=value}" 其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段 名。--> <select id="getTeacher" resultType="teacher"> select * from teacher where id = #{id} and name = #{name} </select>
测试
@Test public void testGetStudents(){ SqlSession session = MybatisUtils.getSession(); StudentMapper mapper = session.getMapper(StudentMapper.class); List<Student> students = mapper.getStudents(); for (Student student : students){ System.out.println( "学生名:"+ student.getName() +"\t老师:"+student.getTeacher().getName()); } }
按结果嵌套处理
接口方法编写
public List<Student> getStudents2();
编写对应的mapper文件
<!-- 按查询结果嵌套处理 思路：1. 直接查询出结果，进行结果集的映射 --> <select id="getStudents2" resultMap="StudentTeacher2" > select s.id sid, s.name sname , t.name tname from student s,teacher t where s.tid = t.id </select> <resultMap id="StudentTeacher2" type="Student"> <id property="id" column="sid"/> <result property="name" column="sname"/> <!--关联对象property 关联对象在Student实体类中的属性--> <association property="teacher" javaType="Teacher"> <result property="name" column="tname"/> </association> </resultMap>
去mybatis-config文件中注入
测试
@Test public void testGetStudents2(){ SqlSession session = MybatisUtils.getSession(); StudentMapper mapper = session.getMapper(StudentMapper.class); List<Student> students = mapper.getStudents2(); for (Student student : students){ System.out.println( "学生名:"+ student.getName() +"\t老师:"+student.getTeacher().getName()); } }
按照查询进行嵌套处理就像SQL中的子查询
按照结果进行嵌套处理就像SQL中的联表查询
一对多的处理
实体类编写
@Data public class Student { private int id; private String name; private int tid; }
@Data public class Teacher { private int id; private String name; //一个老师多个学生 private List<Student> students; }
按结果嵌套处理
TeacherMapper接口编写方法
//获取指定老师，及老师下的所有学生 public Teacher getTeacher(int id);
编写接口对应的Mapper配置文件
<mapper namespace="com.kuang.mapper.TeacherMapper"> <!-- 思路:1. 从学生表和老师表中查出学生id，学生姓名，老师姓名 2. 对查询出来的操作做结果集映射 1. 集合的话，使用collection！ JavaType和ofType都是用来指定对象类型的 JavaType是用来指定pojo中属性的类型 ofType指定的是映射到list集合属性中pojo的类型。 --> <select id="getTeacher" resultMap="TeacherStudent"> select s.id sid, s.name sname , t.name tname, t.id tid from student s,teacher t where s.tid = t.id and t.id=#{id} </select> <resultMap id="TeacherStudent" type="Teacher"> <result property="name" column="tname"/> <collection property="students" ofType="Student"> <result property="id" column="sid" /> <result property="name" column="sname" /> <result property="tid" column="tid" /> </collection> </resultMap> </mapper>
将Mapper文件注册到MyBatis-config文件中
<mappers> <mapper resource="mapper/TeacherMapper.xml"/> </mappers>
测试
@Test public void testGetTeacher(){ SqlSession session = MybatisUtils.getSession(); TeacherMapper mapper = session.getMapper(TeacherMapper.class); Teacher teacher = mapper.getTeacher(1); System.out.println(teacher.getName()); System.out.println(teacher.getStudents()); }
按查询嵌套处理
TeacherMapper接口编写方法
public Teacher getTeacher2(int id);
编写接口对应的Mapper配置文件
<select id="getTeacher2" resultMap="TeacherStudent2"> select * from teacher where id = #{id} </select> <resultMap id="TeacherStudent2" type="Teacher"> <!--column是一对多的外键 , 写的是一的主键的列名--> <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/> </resultMap> <select id="getStudentByTeacherId" resultType="Student"> select * from student where tid = #{id} </select>
将Mapper文件注册到MyBatis-confifig文件中
测试
@Test public void testGetTeacher2(){ SqlSession session = MybatisUtils.getSession(); TeacherMapper mapper = session.getMapper(TeacherMapper.class); Teacher teacher = mapper.getTeacher2(1); System.out.println(teacher.getName()); System.out.println(teacher.getStudents()); }
1. 关联-association
2. 集合-collection
3. 所以association是用于一对一和多对一，而collection是用于一对多的关系
4. JavaType和ofType都是用来指定对象类型的
JavaType是用来指定pojo中属性的类型
ofType指定的是映射到list集合属性中pojo的类型。
注意说明：
1. 保证SQL的可读性，尽量通俗易懂
2. 根据实际要求，尽量编写性能更高的SQL语句
3. 注意属性名和字段不一致的问题
4. 注意一对多和多对一 中：字段和属性对应的问题
5. 尽量使用Log4j，通过日志来查看自己的错误
动态SQL
动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句
新建一个数据库表：blog
字段：id，title，author，create_time，views
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
IDutil工具类
public class IDUtil { public static String genId(){ return UUID.randomUUID().toString().replaceAll("-",""); } }
实体类编写 【注意set方法作用】
import java.util.Date; public class Blog { private String id; private String title; private String author; private Date createTime; private int views; //set，get.... }
编写Mapper接口及xml文件
public interface BlogMapper { }
<?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.kuang.mapper.BlogMapper"> </mapper>
mybatis核心配置文件，下划线驼峰自动转换
<settings> <setting name="mapUnderscoreToCamelCase" value="true"/> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <!--注册Mapper.xml--> <mappers> <mapper resource="mapper/BlogMapper.xml"/> </mappers>
插入初始数据
编写接口
//新增一个博客 int addBlog(Blog blog);
sql配置文件
<insert id="addBlog" parameterType="blog"> insert into blog (id, title, author, create_time, views) values (#{id},#{title},#{author},#{createTime},#{views}); </insert>
初始化博客方法
@Test public void addInitBlog(){ SqlSession session = MybatisUtils.getSession(); BlogMapper mapper = session.getMapper(BlogMapper.class); Blog blog = new Blog(); blog.setId(IDUtil.genId()); blog.setTitle("Mybatis如此简单"); blog.setAuthor("狂神说"); blog.setCreateTime(new Date()); blog.setViews(9999); mapper.addBlog(blog); blog.setId(IDUtil.genId()); blog.setTitle("Java如此简单"); mapper.addBlog(blog); blog.setId(IDUtil.genId()); blog.setTitle("Spring如此简单"); mapper.addBlog(blog); blog.setId(IDUtil.genId()); blog.setTitle("微服务如此简单"); mapper.addBlog(blog); session.close();
if 语句
根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
编写接口类
//需求1 List<Blog> queryBlogIf(Map map);
编写SQL语句
<!--需求1： 根据作者名字和博客名字来查询博客！ 如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询 select * from blog where title = #{title} and author = #{author} --> <select id="queryBlogIf" parameterType="map" resultType="blog"> select * from blog where <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </select>
测试
@Test public void testQueryBlogIf(){ SqlSession session = MybatisUtils.getSession(); BlogMapper mapper = session.getMapper(BlogMapper.class); HashMap<String, String> map = new HashMap<String, String>(); map.put("title","Mybatis如此简单"); map.put("author","狂神说"); List<Blog> blogs = mapper.queryBlogIf(map); System.out.println(blogs); session.close(); }
Where
修改上面的SQL语句；
<select id="queryBlogIf" parameterType="map" resultType="blog"> select * from blog <where> <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </where> </select>
这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
Set
编写接口方法
int updateBlog(Map map);
sql配置文件
<!--注意set是用的逗号隔开--> <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>
测试
@Test public void testUpdateBlog(){ SqlSession session = MybatisUtils.getSession(); BlogMapper mapper = session.getMapper(BlogMapper.class); HashMap<String, String> map = new HashMap<String, String>(); map.put("title","动态SQL"); map.put("author","秦疆"); map.put("id","9d6a763f5e1347cebda43e2a32687a77"); mapper.updateBlog(map); session.close(); }
choose语句
编写接口方法
List<Blog> queryBlogChoose(Map map);
sql配置文件
<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>
测试类
@Test public void testQueryBlogChoose(){ SqlSession session = MybatisUtils.getSession(); BlogMapper mapper = session.getMapper(BlogMapper.class); HashMap<String, Object> map = new HashMap<String, Object>(); map.put("title","Java如此简单"); map.put("author","狂神说"); map.put("views",9999); List<Blog> blogs = mapper.queryBlogChoose(map); System.out.println(blogs); session.close(); }
提取SQL片段：
<sql id="if-title-author"> <if test="title != null"> title = #{title} </if> <if test="author != null"> and author = #{author} </if> </sql>
引用SQL片段：
<select id="queryBlogIf" parameterType="map" resultType="blog"> select * from blog <where> <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace --> <include refid="if-title-author"></include> <!-- 在这里还可以引用其他的 sql 片段 --> </where> </select>
最好基于 单表来定义 sql 片段，提高片段的可重用性
在 sql 片段中不要包括 where
Foreach
将数据库中前三个数据的id修改为1,2,3；
需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息
编写接口
List<Blog> queryBlogForeach(Map map);
编写SQL语句
<select id="queryBlogForeach" parameterType="map" resultType="blog"> select * from blog <where> <!-- collection:指定输入对象中的集合属性 item:每次遍历生成的对象 open:开始遍历时的拼接字符串 close:结束时拼接的字符串 separator:遍历对象之间需要拼接的字符串 select * from blog where 1=1 and (id=1 or id=2 or id=3) --><foreach collection="ids" item="id" open="and (" close=")" separator="or"> id=#{id} </foreach> </where> </select>
测试
@Test public void testQueryBlogForeach(){ SqlSession session = MybatisUtils.getSession(); BlogMapper mapper = session.getMapper(BlogMapper.class); HashMap map = new HashMap(); List<Integer> ids = new ArrayList<Integer>(); ids.add(1); ids.add(2); ids.add(3); map.put("ids",ids); List<Blog> blogs = mapper.queryBlogForeach(map); System.out.println(blogs); session.close(); }
缓存
1. 什么是缓存 [ Cache ]？
存在内存中的临时数据。
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库
数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
2. 为什么使用缓存？
减少和数据库的交互次数，减少系统开销，提高系统效率。
3. 什么样的数据能使用缓存？
经常查询并且不经常改变的数据。
Mybatis缓存
MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二
级缓存
一级缓存
一级缓存也叫本地缓存：
与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；
测试
在mybatis中加入日志，方便测试结果
编写接口方法
//根据id查询用户 User queryUserById(@Param("id") int id);
接口对应的Mapper文件
<select id="queryUserById" resultType="user"> select * from user where id = #{id} </select>
测试
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); User user2 = mapper.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session.close(); }
一级缓存失效的四种情况
一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；
一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请
求！
1. sqlSession不同
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); SqlSession session2 = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); UserMapper mapper2 = session2.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); User user2 = mapper2.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session.close(); session2.close(); }
每个sqlSession中的缓存相互独立
2. sqlSession相同，查询条件不同
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); UserMapper mapper2 = session.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); User user2 = mapper2.queryUserById(2); System.out.println(user2); System.out.println(user==user2); session.close(); }
当前缓存中，不存在这个数据
3. sqlSession相同，两次查询之间执行了增删改操作
增加方法
//修改用户 int updateUser(Map map);
编写SQL
<update id="updateUser" parameterType="map"> update user set name = #{name} where id = #{id} </update>
测试
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); HashMap map = new HashMap(); map.put("name","kuangshen"); map.put("id",4); mapper.updateUser(map); User user2 = mapper.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session.close(); }
因为增删改操作可能会对当前数据产生影响
4. sqlSession相同，手动清除一级缓存
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); session.clearCache();//手动清除缓存 User user2 = mapper.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session.close(); }
一级缓存就是一个map
二级缓存
二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
工作机制
一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一
级缓存中的数据被保存到二级缓存中；
新的会话查询信息，就可以从二级缓存中获取内容；
不同的mapper查出的数据会放在自己对应的缓存（map）中；
使用步骤
开启全局缓存 【mybatis-confifig.xml】
<setting name="cacheEnabled" value="true"/>
去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】
<cache/> 官方示例=====>查看官方文档 <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/> 这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者 产生冲突。
代码测试
所有的实体类先实现序列化接口
测试代码
@Test public void testQueryUserById(){ SqlSession session = MybatisUtils.getSession(); SqlSession session2 = MybatisUtils.getSession(); UserMapper mapper = session.getMapper(UserMapper.class); UserMapper mapper2 = session2.getMapper(UserMapper.class); User user = mapper.queryUserById(1); System.out.println(user); session.close(); User user2 = mapper2.queryUserById(1); System.out.println(user2); System.out.println(user==user2); session2.close(); }
只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
查出的数据都会被默认先放在一级缓存中
只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中
