Mybatis

简介：

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

中文文档： https://mybatis.org/mybatis-3/zh/index.html

下载地址： https://github.com/mybatis/mybatis-3/releases

maven仓库：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.4</version>
</dependency>

1.2持久层，持久化

数据持久化将程序

2.1环境搭建

新建一个普通的maven项目
删除src目录
导入maven依赖

<?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</artifactId>
    <version>1.0-SNAPSHOT</version>
<!--导入依赖-->
<dependencies>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <!--mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.4</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
<!--每一个Mapper。xml都需要在Mybatis核心配置文件中注册-->
</dependencies>
</project>

4.建一个maven项目

5.在resources文件下新建一个xml文件，可通过右侧连接

2.2配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <!--环境-->
    <environments default="development">
        <environment id="development">
        <!--事务管理默认JDBC-->
            <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&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>

</configuration>

2.3编写工具类utils

package com.utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
//sqlSessionFactory-->sqlSession
public class MybatisUtils {
    private static /*它用来增删改查*/SqlSessionFactory sqlSessionFactory;
    static {
        try {/*使用MybatisUtils第一步获取SQL sessionFactory对象*/
            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 getsSqlSession(){
    return sqlSessionFactory.openSession();
    }
}

2.3编写代码

实体类

package com.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;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
               '}'; }
    public int getId() {
        return id; }
    public void setId(int id) {
        this.id = id; }
    public String getName() {
        return name;  }
    public void setName(String name) {
        this.name = name;    }
    public String getPwd() {
        return pwd;    }
    public void setPwd(String pwd) {
        this.pwd = pwd;  }}

Dao接口

public interface Userdao {
    List<User> getUserList();}

接口实现类

<?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.dao.Userdao">
    <!--select查询语句 ,其中id对应Userdao中的方法的名字，
    resultType对应着返回的类型，resultMap对应着返回的集合，要写全路径-->
    <select id="getUserList" resultType="com.pojo.User">
    select * from mybaits.user;
  </select>
</mapper>

2.4测试

注意点：每一个Mapper.xml都需要在Mybatis核心配置文件中注册

<mapper resource="com/dao/UserMapper.xml"/></mappers>

在build中配置resource，来防止我们资源到处失败的问题

<build>    <resources>        <resource>            <directory>src/main/resources</directory>        <includes>            <include>**/*.propertise</include>            <include>**/*.xml</include>        </includes>                  </resource>        <resource>            <directory>src/main/java</directory>            <includes>                <include>**/*.prppertis</include>                <include>**/*.xml</include>            </includes>                    </resource>    </resources></build>

###mapper.xml 配置文件有中文可能报错。

### 否则可能报错

###useSSL=false否则也可能报错

进阶

CRUD

1.namespace

namespace中的包名要和mapper接口的报名一致

2.select

选择，查询语句
id：就是namespace方法名字
resultType：SQL语句执行的返回值
parmeterType：参数类型

1.编写接口

public interface UserMapper {    //查询所有用户    List<User> getUserList();    //跟据ID 查询一个用户    User getUserById(int id);    //insert一个用户   int addUser(User user);   //修改用户   int upsateUser(User user);   //删除一个用户    int deleteUser(int id);}

2.编写对应的mapper中的SQL语句

<mapper namespace="com.kuang.dao.UserMapper">    <!--select 查询语句-->    <select id="getUserList" resultType="com.kuang.pojo.User">        select * from mybatis.user;    </select>  
    <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">      select * FROM mybatis.user where id=#{id}/*#id是可变的参数*/    </select>

3.测试

public class UserDaoTest {    @Test/*查看所有*/    public void test() {        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper userDao = sqlSession.getMapper(UserMapper.class);        List<User> userList = userDao.getUserList();        for (User user : userList) {            System.out.println(user);        }        sqlSession.close();    }    @Test/*查看指定的*/public void getUserById(){        SqlSession sqlSession = MybatisUtils.getSqlSession();/*获取执行SQL的对象*/        UserMapper mapper = sqlSession.getMapper(UserMapper.class);/*获取UserMaper的对象*/        User userById = mapper.getUserById(1);        System.out.println(userById);        sqlSession.close();    }/*增删改需要提交事务*/    @Test    public void addUser(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        int haha = mapper.addUser(new User(4, "haha","d"));      if(haha!=0) {          System.out.println("成功改动了"+haha+"个点");      }        sqlSession.commit();        sqlSession.close();    }    @Test/*修改一个内容*/    public void upsateUser(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        int i = mapper.upsateUser(new User(4, "狗蛋", "123456"));        sqlSession.commit();        sqlSession.close();    }    @Test    public void deletdUser(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        int i = mapper.deleteUser(4);        if (i>0){            System.out.println("成功删除id为"+i+"的用户");        }        sqlSession.commit();        sqlSession.close();    }

3.insert

 <!--对象中的属性可直接去除--><insert id="addUser" parameterType="com.kuang.pojo.User">    insert into mybatis.user (id,name,pwd) value(#{id},#{name},#{pwd})</insert>

4.update

<update id="upsateUser" parameterType="com.kuang.pojo.User">        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}    </update>

5.delete

<delete id="deleteUser" parameterType="int">        delete from mybatis.user where id=#{id}    </delete>

注意点：

增删改需要提交事务

读错要从后往前读

万能的Map野路子

假设，我们的实体类或数据库中的表，字段或参数过多，我们应当考虑使用Map

添加：

   //insert一个用户   切记不可方法重组
   int addUser2(Map<String,Object> map);

    <insert id="addUser2" parameterType="map">
insert into mybatis.user (id,pwd) value (#{userid},#{userpwd})
    </insert>

 @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map=new HashMap<>();
        map.put("userid",5);
        map.put("userpwd","lala");
        mapper.addUser2(map);
        sqlSession.commit();
        sqlSession.close();
    }

查找：

 User getUserById2(Map<String,Object> map);

  @Test
    public void getUserById2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String,Object> map=new HashMap<>();
        map.put("yourid",2);
        map.put("name","张三");
        User userById = mapper.getUserById2(map);
        System.out.println(userById);
        sqlSession.commit();
        sqlSession.close();
    }

<select id="getUserById2" parameterType="map" resultType="com.kuang.pojo.User">
     select * from mybatis.user where id=#{yourid} and name=#{name}
 </select>

map传递参数，直接在sql中取出key即可
对象传递参数，直接在sql中取出对象的属性即可
只有一个基本类型参数的情况下，可以直接在sql中取到

Java代码执行的时候，传递通配符

<select id="getUserListlike" resultType="com.kuang.pojo.User">    select * from mybatis.user where name like #{value}</select>

 List<User> userList = mapper.getUserListlike("%李%");

<select id="getUserListlike" resultType="com.kuang.pojo.User">    select * from mybatis.user where name like "%"#{value}"%"</select>

4.配置解析

1.核心配置文件

mybatis-config.xml
MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

2.环境配置（environments）

MyBatis可以配置成适应多种环境

不过要记住：尽管可以配置多种环境，但每个SqlSessionGactory实例只能选择一种环境

Mybatis默认的事务管理器就是JDBC，连接池：POOLED

3.属性（properties）

我们可以通过properties属性来实现引用配置文件

这些属性都是可外部配置且可动态替换的，既可以在典型的Java属性文件中配置，亦可通过properties元素的子元素来传递。【db.properties】

编写一个配置文件

driver=com.mysql.jdbc.Driver
user=jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8
username=root
password=root

在核心配置文件中引入

    <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}"/>

可以直接引用外部文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件的

4.类型别名

<!--可以给实体类起别名-->
    <typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

      <!--select 查询语句-->
    <select id="getUserList" resultType="User">
        select * from mybatis.user;
    </select>

减少限定名的冗余

可以指定一个包名，MyBatis会在包名下搜索需要的Java Bean比如：

扫描实体类的包，他的默认别名就为这个类的类名，首字母小写

    <typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

      <!--select 查询语句-->
    <select id="getUserList" resultType="user">
        select * from mybatis.user;
    </select>

实体类较少用第一种

实体类多用第二种

第二种扫描包注解为别名

5.映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件

方式一：

<!--每一个 Mapper.xml 都需要在 Mybatis 核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/kuang/dao/UserMapper.xml"/>
    </mappers>

方式二：

<!--每一个 Mapper.xml 都需要在 Mybatis 核心配置文件中注册！-->
    <mappers>
        <mapper class="com/kuang/dao/UserMapper"/>
    </mappers>

使用class的注意点：

接口和他的Mapper配置文件必须同名
接口和它的Mapper配置文件必须在同一个包下

方式三：

使用扫描包进行诸如绑定：注意点同上

生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d8aj9RJN-1603633209615)(D:\学习\笔记\img\捕的获.PNG)]

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题

SqlSessionFactoryBuilder：

一旦创建了SqlSessionFactory，就不再需要他了
局部变量

SqlSessionFactory

就是可以想象为数据库连接池
SqlSessionFactory一旦创建就一直存在，没有任何理由丢弃或重新创建
因此SqlSessionFactory最佳作用域是应用作用域

SqlSession

连接到连接池的请求
放在方法里
用完关闭，否则资源被占用

6.解决属性名和字段名不一致的问题

6.1结果集映射

id name pwd     //数据库中的
id name password    //我们想让它变成的
  
<resultMap id="UserMap" type="User">
    <!--column数据库中的字段 ，property 实体类中的属性-->
  <!--  <result column="id" property="id"/>-->
   <!-- <result column="name" property="name"/>-->
    <result column="pwd" property="password"/>
</resultMap>
    
    <select id="getUserById" parameterType="int" resultMap="UserMap">
      select * FROM mybatis.user where id=#{id}/*#id是可变的参数*/
    </select>

7.日志

7.1日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手

SLF4J
Apache Commons Logging
Log4j 2
Log4j【掌握】
JDK logging
STDOUT_LOGGING【掌握】

在Mybatis中具体使用哪一个日志实现，在设定中设定

STDOUT_LOGGING标准日志输出

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

读一下下：

Opening JDBC Connection           //打开一个Jdbc连接
Created connection 641853239.   //创建一个connection连接对象
Setting autocommit to false/*设置了一个自动提交*/ on JDBC Connection [com.mysql.jdbc.JDBC4Connection@2641e737]
==>  Preparing: select * FROM mybatis.user where id=?/*预编译*/
==> Parameters: 1(Integer)/*参数过来*/
<==    Columns: id, name, pwd  /*查询的列*/
<==        Row: 1, 狂神, 123456/*查询的参数*/
<==      Total: 1               /*总共有几条参数*/
User{id=1, name='狂神', password='123456'}/*结果*/
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@2641e737]
Closing JDBC Connection  /*关闭Connection*/ [com.mysql.jdbc.JDBC4Connection@2641e737]
Returned connection 641853239 to pool./*返回连接池*/

7.2Log4j

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog 守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1.先导包

<dependencies>    <!-- https://mvnrepository.com/artifact/log4j/log4j -->    <dependency>       
    <groupId>log4j</groupId>        <artifactId>log4j</artifactId>        <version>1.2.17</version> 
    </dependency></dependencies>

jog4j.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/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.sqaredStatement=DEBUG

详解：

log4j.rootLogger=INFO,consoleAppender,logfile,MAIL
log4j.addivity.org.apache=true
#ConsoleAppender，控制台输出
#FileAppender，文件日志输出
#SMTPAppender，发邮件输出日志
#SocketAppender，Socket 日志
#NTEventLogAppender，Window NT 日志
#SyslogAppender，
#JMSAppender，
#AsyncAppender，
#NullAppender
#文件输出：RollingFileAppender
#log4j.rootLogger = INFO,logfile
log4j.appender.logfile = org.apache.log4j.RollingFileAppender
log4j.appender.logfile.Threshold = INFO
# 输出以上的 INFO 信息
log4j.appender.logfile.File = INFO_log.html
#保存 log 文件路径
Log4j 从入门到详解
10
log4j.appender.logfile.Append = true
# 默认为 true，添加到末尾，false 在每次启动时进行覆盖
log4j.appender.logfile.MaxFileSize = 1MB
# 一个 log 文件的大小，超过这个大小就又会生成 1 个日志 # KB ，MB，GB
log4j.appender.logfile.MaxBackupIndex = 3
# 最多保存 3 个文件备份
log4j.appender.logfile.layout = org.apache.log4j.HTMLLayout
# 输出文件的格式
log4j.appender.logfile.layout.LocationInfo = true
#是否显示类名和行数
log4j.appender.logfile.layout.Title
=title:\u63d0\u9192\u60a8\uff1a\u7cfb\u7edf\u53d1\u751f\u4e86\u4e25\u91cd\u9519\u8b
ef
error 成功关闭链接
###############################################################################
#每天文件的输出：DailyRollingFileAppender
#log4j.rootLogger = INFO,errorlogfile
log4j.appender.errorlogfile = org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorlogfile.Threshold = ERROR
log4j.appender.errorlogfile.File = ../logs/ERROR_log
log4j.appender.errorlogfile.Append = true
#默认为 true，添加到末尾，false 在每次启动时进行覆盖
log4j.appender.errorlogfile.ImmediateFlush = true
#直接输出，不进行缓存
# ' . ' yyyy - MM: 每个月更新一个 log 日志
# ' . ' yyyy - ww: 每个星期更新一个 log 日志
# ' . ' yyyy - MM - dd: 每天更新一个 log 日志
# ' . ' yyyy - MM - dd - a: 每天的午夜和正午更新一个 log 日志
# ' . ' yyyy - MM - dd - HH: 每小时更新一个 log 日志
# ' . ' yyyy - MM - dd - HH - mm: 每分钟更新一个 log 日志
Log4j 从入门到详解
11
log4j.appender.errorlogfile.DatePattern = ' . ' yyyy - MM - dd ' .log '
#文件名称的格式
log4j.appender.errorlogfile.layout = org.apache.log4j.PatternLayout
log4j.appender.errorlogfile.layout.ConversionPattern =%d %p [ %c] - %m %n %d
#控制台输出：
#log4j.rootLogger = INFO,consoleAppender
log4j.appender.consoleAppender = org.apache.log4j.ConsoleAppender
log4j.appender.consoleAppender.Threshold = ERROR
log4j.appender.consoleAppender.layout = org.apache.log4j.PatternLayout
log4j.appender.consoleAppender.layout.ConversionPattern =%d %-5p %m %n
log4j.appender.consoleAppender.ImmediateFlush = true
# 直接输出，不进行缓存
log4j.appender.consoleAppender.Target = System.err
# 默认是 System.out 方式输出
#发送邮件：SMTPAppender
#log4j.rootLogger = INFO,MAIL
log4j.appender.MAIL = org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold = INFO
log4j.appender.MAIL.BufferSize = 10
log4j.appender.MAIL.From = yourmail@gmail.com
log4j.appender.MAIL.SMTPHost = smtp.gmail.com
log4j.appender.MAIL.Subject = Log4J Message
log4j.appender.MAIL.To = yourmail@gmail.com
log4j.appender.MAIL.layout = org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern =%d - %c -%-4r [%t] %-5p %c %x - %m %n
#数据库：JDBCAppender
log4j.appender.DATABASE = org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL = jdbc:oracle:thin:@ 210.51 . 173.94 : 1521 :YDB
log4j.appender.DATABASE.driver = oracle.jdbc.driver.OracleDriver
log4j.appender.DATABASE.user = ydbuser
log4j.appender.DATABASE.password = ydbuser
log4j.appender.DATABASE.sql = INSERT INTO A1 (TITLE3) VALUES ( ' %d - %c %-5p %c %x - %m%n
' )
log4j.appender.DATABASE.layout = org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern =% d - % c -%- 4r [ % t] %- 5p % c %
x - % m % n
#数据库的链接会有问题，可以重写 org.apache.log4j.jdbc.JDBCAppender 的 getConnection() 使用数
据库链接池去得链接，可以避免 insert 一条就链接一次数据库

简单使用

1.在使用log4j的类中，导入包import org.apache.log4j.Logger;

static Logger logger = Logger.getLogger(UserDaoTest.class);

 @Test
    public void testlog4j(){
                logger.info("info：进入了testLong4j");
                logger.debug("debug:进入了testlog4j");
                logger.error("error:进入了testlog4j");
    }

8.分页

select * from user limit 0,-1;

接口：

List<User> getUserByLimt(Map<String,Integer> map);

xml:

<select id="getUserByLimt" parameterType="map" resultType="user">
       select * from mybatis.user  limit #{startIndex},#{pageSize};
   </select>

测试：

@Test
  public void getUserBylimt(){
      SqlSession sqlSession = MybatisUtils.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> userByLimt = mapper.getUserByLimt(map);
      for (User user : userByLimt) {
          System.out.println(user);
      }
      sqlSession.close();
  }

9.注解

注解在接口上实现：

public interface UserMapper {
@Select("select * from user")
List<User> getUser();
  }

配置文件：

    <mappers>
        <mapper class="com.kuang.dao.UserMapper"/>
    </mappers>

测试

public class UserMapperTest {
@Test
    public void test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> user = mapper.getUser();
    for (User user1 : user) {
        System.out.println(user1);
    }
     sqlSession.close();
}

本质：反射机制实现

底层：动态代理

lombok

10.多对一

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');

做法： select s.id,s.name,t.name from student s,teacher t where s.tid=t.id;

用mybatis实现，类似子查询，法一：

<mapper namespace="com.kuang.dao.StudentMapper">
    <!--思路：1.查询所有学生的信息.2.根据查询出来的学生的tid，寻找对应的老师-->
    <select id="getStudent" resultMap="StudentTeacher">
select * from student
</select>
  《其中id表示他的标识，type表示那种类作为其映射的类》
    <resultMap id="StudentTeacher" type="Student">
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独处理对像：association 集合：collection-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="com.kuang.pojo.Teacher">
        select * from teacher where id=#{id}
    </select>

</mapper>

法二：

    <select id="getStudent2" 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="com.kuang.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="com.kuang.pojo.Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

注意：

一对多

实体类

public class Student {
    private int id;
    private String name;
private int tid;

public class Teacher {
    private int id;
    private String name;
private List<Student> students;

<mapper namespace="com.kuang.dao.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from  teacher t,student s
    where s.id=t.id and t.id=#{tid}
    </select>
    <resultMap id="TeacherStudent" type="com.kuang.pojo.Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--复杂的属性，我们需要单独处理  对象：association 集合：collection
  javaType=“”指定属性的类型
  集合中的泛型信息，我们使用ofType获取-->
        <collection property="students" ofType="com.kuang.pojo.Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

小结：

1.关联-association【多对一】

2.集合-collection【一对多】

JavaType & ofType

JavaType 用来指定实体类中属性的类型

ofType用来指定映射到List或者集合中pojo类型，反型中的约束类型

11.动态SQL

就是通过不同的条件生成不同的SQL 语句

搭建环境

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

创建一个基础工程

导包

编写配置文件

import java.util.Date;

public class Blog{
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

编写实体类

编写实体类对应的Mapper接口和Mapper.XML文件

//随便可以给一个条件
<select id="  " parameterType="map" resultMap="bolg">
    select * from mybatis.bolg  
   <where> <if test="title!=null" >
        and title=#{title}
    </if>
    <if test="author!=null">
        and author =#{author}
    </if></where>
</select>

二级缓存：

步骤

1.开启全局缓存

<cache
  eviction="FIFO"          创建FIFO缓存
  flushInterval="60000"     每隔60秒刷新
  size="512"                最多可以存储结果对象512个引用
  readOnly="true"/>

上一篇compose和pips函数

下一篇防抖与手写高阶函数

本文作者：我是小杨

本文链接：https://www.cnblogs.com/Liguangyang/p/16492760.html

posted @ 2022-07-19 08:48 我是小杨阅读(24) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页