SSM-MyBatis

最新推荐文章于 2024-05-15 16:59:55 发布

心中爱恋宝宝的猪猪

最新推荐文章于 2024-05-15 16:59:55 发布

阅读量408

点赞数

文章标签： mybatis

本文链接：https://blog.csdn.net/shtxk/article/details/118500350

版权

mybatis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单体框架-SSM在项目中所代替的部分（mybatis-->dao层）

框架的概念：jar+配置文件

发展历程
MyBatis原名是iBatis，是Apache的开源项目。2010.6月跟随开发团队投入Google code旗下。在IBatis3.x正式更名为MyBatis。它提供了持久层架包包括SQL Maps和DATA Access Object（DAO）;

安装（我没用，直接maven）
网址：https://github.com/mybatis/mybatis-3

Mybatis特性
   MyBatis支持定制化SQL、存储过程以及高级映射
   MyBatis避免了几乎所有的JDBC代码和手动设置参数以及结果集解析操作
   MyBatis可以使用简单的XML或注解实现配置和原始映射；将接口和Java的POJO（Plain Ordinary Java Object，普通的Java对象）映射成数据库中的记录
   Mybatis是一个半自动的ORM（Object Relation Mapping）框架

与其他持久层的技术对比
   jdbc（唯一连接方式）但是耦合度高，开发效率低，不利于开发（所以要进行保证）
   Hibernate和JPA：操作简单，但是复杂查询不足
   MyBatis:轻量级。sql与java代码分开，效率略逊色于Hibernate

创建MyBatis（Maven（pom创建）版本，因为它一般不会单用，所以我直接写出它最终单用版本）
1.创建一个普通Maven（方法看我上一次传的）
2.创建好后，在pom.xml中导入以下代码（这些是maven导入的jar）

<dependencies>
    <!-- Mybatis核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>

    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.17</version>
    </dependency>

    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

   3.在resource文件夹中创建一个新文件（mybatis-config.xml）
   4.在新创的文件mybatis-config.xml中加入mybatis的API中的getting started（新手入门）中关于mybatis-config.xml的内容（加以修改数据源--->jdbc是连接数据库唯一的方式）

<?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/curd?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

5.在resources文件夹下创建文件夹mapper，在创建XxxMapper.xml（Xxx--->数据库表名）
6.在XxxMapper.xml文件下填写如下getting started的内容（修改一些数据，下面具体说）---->我创建的数据库叫curd，表叫user（具体的看源码）

<?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="org.mybatis.example.BlogMapper"> 
 <select id="selectUser" resultType="User"> 
 select * from user where id = #{id} 
 </select> 
</mapper>

7.创建接口和实体类
8.创建测试类
链接：https://pan.baidu.com/s/1Fq0qdRkjY4l69luLwR-xPA
提取码：0303

MyBatis核心配置文件
核心文件configuration有严格的顺序要求：(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)

<?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>

    <!--引入properties文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

          <!--
        typeAliases：设置类型别名
    -->
    <typeAliases>
        <!--
            typeAlias：设置某个具体的类型的别名
            属性：
            type：需要设置别名的类型的全类名
            alias：设置此类型的别名，若不设置此属性，该类型拥有默认的别名，即类名且不区分大小写
            若设置此属性，此时该类型的别名只能使用alias所设置的值
        -->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User"></typeAlias>-->
        <!--<typeAlias type="com.atguigu.mybatis.bean.User" alias="abc"></typeAlias>-->
        <!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="com.atguigu.mybatis.bean"/>
    </typeAliases>

<!--    分页插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
    <!--
        environments：设置多个连接数据库的环境
        属性：
        default：设置默认使用的环境的id
    -->
    <environments default="mysql_test">
        <!--
            environment：设置具体的连接数据库的环境信息
            属性：
            id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
        -->
        <environment id="mysql_test">
            <!--
                transactionManager：设置事务管理方式
                属性：
                type：设置事务管理方式，type="JDBC|MANAGED"
                type="JDBC"：设置当前环境的事务管理都必须手动处理
                type="MANAGED"：设置事务被管理，例如spring中的AOP
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource：设置数据源
                属性：
                type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
                type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
                type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
                type="JNDI"：调用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <!--设置驱动类的全类名-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的连接地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
        <environment id="mysql_development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

MyBatis获取参数的两种方式
   获得方式为：${} 和 #{}
   方法的本质：${}---->字符串的拼接；#{}---->占位符的复制
   优缺点：${}凭借字符串或日期的时候，需要手动加单引号（等一下可以看事例）；#{}则会自动添加
   当参数数量不同的时候，实例分析：
       1.当只有一个字面量（八大基本类型+对应的包装类+string）参数的时候
       两种都可以用，里面的参数可以为任意字符串，但是${}里面不能为纯数字或以数字开头的字符串，因为它本身具有运算效果

<!--    User getByName(String username);-->
    <select id="getByName" resultType="com.baby.bean.User">
        select * from user where username='${s1}'
--             select * from user where username=#{12}
    </select>

2.当有多个字面量参数的时候
多个参数的时候，它会自动存在一个map集合中，key只有arg和param两种。注意：arg是从0开始，param是从一开始，他们不能超过参数的数目

<!--    User getBys(String username,String role,String pass);-->
    <select id="getBys" resultType="com.baby.bean.User">
--          select * from user where username='${arg0}' and role='${arg1}' and pass='${arg2}'
   select * from user where username=#{param1} and role=#{param2} and pass=#{param3}
    </select>

3.当有多个字面量参数的时候，可以自定义一个map集合存储
我们需要手动创建一个map集合，然后复制，key的值为我们自定义的值

<!--    User getByss(Map<String,String> map);-->
    <select id="getByss" resultType="com.baby.bean.User">
--           select * from user where username=#{name} and role=#{role} and pass=#{pass}
    select * from user where username='${name}' and role='${role}' and pass='${pass}'
    </select>

4.当参数是一个对象的时候
我们可以直接写对应JavaBean的成员变量名

    <insert id="getByUser">
--         INSERT INTO USER  VALUES( NULL,'${username}','${role}','${pass}')
     INSERT INTO USER  VALUES( NULL,#{username},#{role},#{pass})
    </insert>

5.当参数添加注解的时候
我们可以在接口中为参数添加注解，注解里面的字面量可以为key值；param1，param2也可以作为key值

<!--
@paran里面只有一个值的时候
@param(value="")===@param("")
 User checkUser(@Param(value = "username") String username,@Param("password") String pass);
-->
<select id="checkUser" resultType="user">
    <!--select * from user where username='${username}' and pass='${password}'-->
    select * from user where username=#{param1} and pass=#{param2}
</select>

6.当参数为对象加注解的时候
这时候只可以使用语法：--->注解的值.bean的成员名

<!--  int getInstallById(@Param("user") User user);-->
<insert id="getInstallById">
    <!--INSERT INTO USER  VALUES( NULL,'${user.username}','${user.role}','${user.pass}')-->
    INSERT INTO USER  VALUES( NULL,#{user.username},#{user.role},#{user.pass})
</insert>

MyBatis的查询情况（5）
   resultType和resultMap两种返回结果集
   resultType--->1.真实的类（全类名） 2.类的别名（自定义的别名和默认别名（八大基本类型及对应的包装类））
   resultMap--->自定义映射；值为自己定义一个resultMap的id（主要可以解决数据库字段名和实体类的属性名不一致的问题）
   1.查询返回一个实体类

<!-- User selectById(@Param("id") int id);-->
<select id="selectById" resultType="User">
    select * from user where id=#{id}
</select>

2.查询返回一个list集合
如果返回值为list集合返回结果映射为<>泛型里面的值

<!--   List<User> selectAll(); -->
<select id="selectAll" resultType="user">
     select * from user
</select>

3.查询返回一个数据
这是根据字段名并不是字段值查询的，所以是string类型而不是int类型

<!--   int selectCount(@Param("id") String name);-->
<select id="selectCount" resultType="int">
    SELECT COUNT(#{id}) FROM USER
</select>

查询返回一条数据返回为map集合（唯一的好处可以不需要创建bean，可以当临时变量的存储）

<!--Map<String,Object> selectAllToMap(@Param("id") int id);  -->
<select id="selectAllToMap" resultType="map">
    select * from user where id=#{id}
</select>
结果：{role=辅助, id=3, username=瑶}

   查询多条数据返回为一个map集合（不常用）
   在接口上添加一个注解，字段作为key，value是每天map集合

</select>
<!--
 @MapKey("id")---把"字段"作为key
Map<String,Object> selectAllToMap();
本质：map（map）
  -->
<select id="selectAllToMap" resultType="map">
     select * from user
</select>
结果：
{2={role=射手, pass=123,
 id=2, username=后羿}, 3={role=辅助, id=3, username=瑶}, 
6={role=ly, pass=123, id=6, username=ly},
 7={role=c, id=7, username=c}, 
8={role=ss, id=8, username=ss},
 12={role=sl, pass=123, id=12, username=ls}}

特殊的sql（模糊查询和批量删除及返回主键）
1.模糊查询
注意：单引号中如果用#{}获取参数，这时候#{}并不是作为占位符？存在，而是作为字符？号存在，会报错；只能使用concat连接字符串方法

<!--    List<User> getSelectMH(@Param("mh") String mh);-->
<select id="getSelectMH" resultType="user">
    <!--SELECT * FROM USER WHERE username LIKE '%${mh}%'-->
    SELECT * FROM USER WHERE username LIKE concat('%',#{mh},'%')
</select>

2.批量删除
批量删除只能用${}；当参数为字符串的时候

<!--  int getDelById(String ids);   -->
<delete id="getDelById">
    DELETE  FROM USER WHERE id in (${ids})
</delete>

3.返回主键
useGeneratedKeys 取值范围true、false 默认值是：false。含义：设置是否使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域型属性中；keyProperty则是指定主键值赋值给哪个字段名

<!--  int getInstallById(@Param("user") User user);-->
<insert id="getInstallById" useGeneratedKeys="true" keyProperty="id">
    <!--INSERT INTO USER  VALUES( NULL,'${user.username}','${user.role}','${user.pass}')-->
    INSERT INTO USER  VALUES( NULL,#{user.username},#{user.role},#{user.pass})
</insert>

自定义映射
   问题：实体类和数据库字段名不一致的时候，不能直接映射赋值？
   解决方案：
       1.在sql语句中取别名

<!--    User selectUser(int id);-->
    <select id="selectUser" resultType="com.baby.bean.User">
     select id,user_name userName,role,pass from user where id = #{id}
     </select>

2.在mybatis-config配置文件中开启下划线转驼峰（实体类（驼峰）和表的字段名符（_）合对应规则）--->看上面的核心配置文件
3.自定义映射（resultMap）（可以自己设置值对应，eg：把实体类username的值对应字段名pass，这样username就可以接收pass的值）--->可以只设定与字段名不一致的属性

 <!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    子标签：
    id：设置主键的映射关系
    result：设置普通字段的映射关系
    association：设置多对一的映射关系
    collection：设置一对多的映射关系
    属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名
-->
    <resultMap id="id" type="user">
        <id property="id" column="id"></id>
        <result property="userName" column="user_name"></result>
        <result property="role" column="role"></result>
        <result property="pass" column="pass"></result>
    </resultMap>
<!--    User getByName(String username);-->
    <select id="getByName" resultMap="id">
     <!-- select * from user where username=#{16563} -->
        select * from user where user_name='${s1}'
</select>

映射关系（只有查询才有映射关系）（当我们写mapper.xml了必须写命名空间---><mapper namespace="com.baby.mybatis.mapper.EmpMapper">）

①实体类中映射关系的表示会写在多的一方

②对一用对象表示，对多用集合表示
   多对一映射关系（对象）
       1.级联方式（不太推荐--->可以只写出第二张表的resultMap映射）

 <!--type对应的是返回值类型-->
    <resultMap id="deptid" type="com.baby.bean.Emp">
        <id property="eId" column="e_id"></id>
        <result property="eName" column="e_name"></result>
        <result property="eAge" column="e_age"></result>
        <result property="dept.dId" column="d_id"></result>
        <result property="dept.dName" column="d_name"></result>
    </resultMap>
<!--    Emp getSelectEmpAndDeptById(@Param("id") int id);-->
    <select id="getSelectEmpAndDeptById" resultMap="deptid">
        SELECT dept.*,emp.* FROM emp INNER JOIN dept ON emp.`d_id`=dept.`d_id` WHERE emp.`e_id`=#{id}
    </select>

2.设置多对一的映射关系

<!--    Emp getSelectAll();-->
    <resultMap id="allid" type="com.baby.bean.Emp">
        <association property="dept">
            <id property="dId" column="d_id"></id>
            <result property="dName" column="d_name"></result>
        </association>
    </resultMap>
    <select id="getSelectAll" resultMap="allid">
        select  * from emp left join dept on emp.`d_id`=dept.`d_id`
    </select>

3.分步查询(延时加载，按需加载)
1.如果想要延迟加载；那么就必须在配置文件中配置mybatis-config--->看核心配置文件

  <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>

2.分步查询（如果查getById（）那么就不会执行整个方法；但是查询getAll（）会执行所有）

<!--
    Emp getById(@Param("id") int id);
    Emp getAll(@Param("id") int id);
-->
   <select id="getById" resultType="com.baby.bean.Dept">
       select * from dept where d_id=#{id}
   </select>
    <resultMap id="did" type="com.baby.bean.Emp">
        <association property="dept" select="com.baby.mapper.WorKMapper.getById" column="d_id">
        </association>
    </resultMap>
    <select id="getAll" resultMap="did">
        select * from emp where e_id=#{id}
    </select>

   一对多关系（集合）
       1.映射关系
           这里必须写完整，不然映射不到

<!--        List<Dept> getDeptToEmpById(@Param("id") int id);-->
    <resultMap id="deptById" type="Dept">
        <id property="dId" column="d_id"></id>
        <result property="dName" column="d_name"></result>
        <collection property="emp" ofType="Emp">
            <id property="eId" column="e_id"></id>
            <result property="eName" column="e_name"></result>
            <result property="eAge" column="e_age"></result>
        </collection>
    </resultMap>
    <select id="getDeptToEmpById" resultMap="deptById">
        SELECT * FROM dept INNER JOIN emp ON emp.`d_id`=dept.`d_id` WHERE dept.`d_id`=#{id}
    </select>

2.分步查询（获取单个元素可以只执行一条sql语句）
这里dept 的id映射必须写不然不能获取

<!--    List<Emp> getDeptDId(@Param("did") int id);-->
        <select id="getDeptDId" resultType="emp">
            select * from emp where d_id=#{did}
        </select> 
 <!--
    分步查询
    Dept getById(@Param("id") int id);
    -->
<resultMap id="did" type="dept">
    <id property="dId" column="d_id"></id>
    <collection property="emp" select="com.baby.mybatis.mapper.EmpMapper.getDeptDId" column="d_id">
    </collection>
</resultMap>
<select id="getById" resultMap="did">
    select  * from dept where d_id=#{id}
</select>

动态（dynamic）SQL语句
1.if（<if test="userName != '' and userName!=null">）和where（问题：解决多余and和where）
1.if标签和1=1/2=2恒成立联用--->and是关联字不可少

<!--
 List<User> getDynamicUser(User user);
 1=1 恒成立=>可以解决没有条件使失去了语句成功运行
   -->
<select id="getDynamicUser" resultType="user">
    select * from user where 1=1
    <if test="userName != '' and userName!=null">
        and user_name like '%${userName}%'
    </if>
    <if test="role != '' and role!=null">
        and role=#{role}
    </if>
    <if test="pass != '' and pass!=null">
        and pass=#{pass}
    </if>
</select>

2.if和where标签的组合使用（可以省略第一个and；但是我个人不推荐省略）-->where标签可以省略前面的and，但是不能省略表达式后面的and

<!-- List<User> getDynamicUser(User user);-->
<select id="getDynamicUser" resultType="user">
    select * from user
    <where>
        <if test="userName != '' and userName!=null">
            and user_name like '%${userName}%'
        </if>
        <if test="role != '' and role!=null">
            and role=#{role}
        </if>
        <if test="pass != '' and pass!=null">
            and pass=#{pass}
        </if>
    </where>
</select>

2.trim
3.trim的可以添加一个或删除一个前缀（后缀）

<!-- List<User> getDynamicUser(User user);-->
<select id="getDynamicUser" resultType="user">
    select * from user
    <!--
    prefix="" :添加一个前缀
    prefixOverrides=""  ：删除一个前缀
    suffix=""  ：添加一个后缀
    suffixOverrides="" ：删除一个后缀
    -->
    <trim prefix="where" suffixOverrides="and">
        <if test="userName != '' and userName!=null">
             user_name like '%${userName}%' and
        </if>
        <if test="role != '' and role!=null">
             role=#{role} and
        </if>
        <if test="pass != '' and pass!=null">
             pass=#{pass}
        </if>
    </trim>
</select>

3.choose，when和otherwise---->相当于if....if else....else....
这是单条件，所有不需要加and，而且如果满足任何一个条件，后面的就不会执行；otherwise标签如果前面没有执行的，那么它必定会执行

    <!--    List<User> getById(User user);   -->
<select id="getById" resultType="user">
    select * from user
    <where>
        <choose>
            <when test="userName != '' and userName!=null">
                user_name like '%${userName}%'
            </when>
            <when test="role != '' and role!=null">
                role=#{role}
            </when>
            <otherwise>
                pass=#{pass}
            </otherwise>
        </choose>
    </where>
</select>

注意：1.insert添加语句必须所有元素一起添加，少一个都不行；2.choose，when，otherwise可以赋值；3.性别必须加单引号（要符合sql规范）

 <!--int installUser(User user); -->
<insert id="installUser">
    INSERT INTO USER  VALUES(
    null,
    <if test="userName != '' and userName!=null">
        #{userName},
    </if>
    <if test="role != '' and role!=null">
        #{role},
    </if>
    <if test="pass != '' and pass!=null">
        #{pass},
    </if>
    <if test="gender != '' and gender !=null">
        <choose>
            <when test="gender==0">'女'</when>
            <when test="gender==1">'男'</when>
            <otherwise>null</otherwise>
        </choose>
    </if>
    )
</insert>

4.foreach
如果参数是list集合：foreach属性：①collection（可以填arg0或collection或list三选一）设置循环的数组或集合类型 ②item：表示数组或集合中的一天数据 ③循环体之间的分隔符号

<!--int  insertUsers(List<User> list);-->
<insert id="insertUsers">
    insert into user values
    <foreach collection="list" item="user" separator=",">
        (null,#{user.userName},#{user.role},#{user.pass},#{user.gender})
    </foreach>
</insert>

如果参数是数组①collection（array，arg0）④open：foreach标签的开始符号；⑤close：foreach的结束符号

<!--    int delUserS(@Param("ids") String its);-->
    <delete id="delUserS">
        delete from user where id in
        <foreach collection="array" item="id" open="("  separator="," close=")">
            '${id}'
        </foreach>
    </delete>

open和colse不常用

<delete id="delUserS">
    delete from user where
    <foreach collection="arg0" item="id" separator="or">
        id=#{id}
    </foreach>
</delete>

5.sql
sql片段，截取公共的片段，通过include来引用（注意写规范，比如‘_’ 和驼峰的别名那些）

<sql id="userAll">
    id,user_name userName,role,pass,gender
</sql>

select <include refid="userAll"></include> from user

MyBatis的缓存--->只针对查询语句有效果
   本质：map集合
   一级缓存
       概述：一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问
       存储：以json数据存储
       作用域：一个session会话中
       默认开启
       失效的情况（4种）：
           1) 不同的SqlSession对应不同的一级缓存
           2) 同一个SqlSession但是查询条件不同
           3) 同一个SqlSession两次查询期间执行了任何一次增删改操作
           4) 同一个SqlSession两次查询期间手动清空了缓存
   二级缓存
       概念：二级缓存是namespace级别的，即映射文件级别的，不管使用的是哪个SqlSession，只要执行的是该映射文件中的查询语句，结果就会被缓存；此后若再次执行映射文件中相同的查询语句，结果就会从缓存中取
       开启条件：
           a>在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
           b>在映射文件中设置标签\<cache />
           c>二级缓存必须在SqlSession关闭或提交之后有效
           d>查询的数据所转换的实体类类型必须实现序列化的接口
       二级缓存失效情况：
           两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效
           标签种设置flushCache和useCache为false；增删改种只有flushCache，而且默认为false
       <cache />标签的属性

第三方缓存（不常用）
。。。。。。

MyBatis--逆向工程
1.引入jar插件

<!-- 控制Maven在构建过程中相关配置 -->
<build>

    <!-- 构建过程中用到的插件 -->
    <plugins>

        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>

            <!-- 插件的依赖 -->
            <dependencies>

                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>

                <!-- 数据库连接池 -->
                <dependency>
                    <groupId>com.mchange</groupId>
                    <artifactId>c3p0</artifactId>
                    <version>0.9.2</version>
                </dependency>

                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.17</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

2.写逆向生成的配置文件--generatorConfig.xml（主要生成（要修改的地址）三个，1.实体类；2.接口；3.接收的映射）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
            targetRuntime: 执行生成的逆向工程的版本
                    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
                    MyBatis3: 生成带条件的CRUD（奢华尊享版）
     -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://127.0.0.1:3306/crud?serverTimezone=UTC"
                        userId="root"
                        password="password">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.atguigu.mybatis.entity" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="mapper"  targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.atguigu.mybatis.mapper"  targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="login_user" domainObjectName="LoginUser"/>
    </context>
</generatorConfiguration>

3.生成命令

mybatis--分页插件PageHelper
1.导入jar包

<!--        分页插件-->
        <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.jsqlparser/jsqlparser -->
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.5</version>
        </dependency>

2.在核心配置文件配置（注意顺序）--->看核心配置文件

<!--    分页插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

3.使用并认识分页插件的属性（2个）

①Page<LoginUser> login = PageHelper.startPage(1, 3);
参数：当前页，每一页的记录数
System.out.println(login);
结果属性：Page{count=true, pageNum=1, pageSize=3,
 startRow=0, endRow=3, total=0, 
pages=0, reasonable=null, pageSizeZero=null}

要了解的：pageNum-->当前页  ；  pageSize-->每一页的记录数   ；  
 startROW-->从第几行数据开始   ；  endRow-->第几行结束
total-->总记录数    ；   pages-->页码数


②PageInfo<LoginUser> users =new PageInfo<>(loginUsers,1);
参数：查询的list结果集 ； 逻辑导航分页数
System.out.println(users);
结果属性：PageInfo{pageNum=1, pageSize=3, size=3, startRow=1,
 endRow=3, total=14, pages=5, 
list=Page{count=true, pageNum=1, pageSize=3, startRow=0,
 endRow=3, total=14, pages=5, reasonable=false, pageSizeZero=false}, 
prePage=0, nextPage=2, isFirstPage=true, 
isLastPage=false, hasPreviousPage=false,
 hasNextPage=true, navigatePages=1,
 navigateFirstPage1, navigateLastPage1, navigatepageNums=[1]}

要了解的：size-->每一页的真实数  ；prePage-->上一页的页码数  ；nextPage-->下一页的页码数  ；
isFirstPage-->是否是第一页  ； isLastPage-->是否是最后一页 ；
hasPreviousPage---> 是否有上一页 ；hasNextPage--->是否有下一页;
navigatePages--->导航分页数（下面的哪个）；navigateFirstPage-->导航分页从第几行开始 ；
navigateLastPage--> 导航分页到第几行结束；navigatepageNums-->显示当前的导航数（集合显示）

心中爱恋宝宝的猪猪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SSM-MyBatis

单体框架-SSM在项目中所代替的部分（mybatis-->dao层）框架的概念：jar+配置文件发展历程 MyBatis原名是iBatis，是Apache的开源项目。2010.6月跟随开发团队投入Google code旗下。在IBatis3.x正式更名为MyBatis。它提供了持久层架包包括SQL Maps和DATA Access Object（DAO）;安装（我没用，直接maven）网址：https://github.com/mybatis...
复制链接

扫一扫