Mybatis学习小结

Rs、

已于 2022-08-02 08:33:39 修改

阅读量705

点赞数

文章标签： mybatis 学习 java

于 2022-07-30 21:33:05 首次发布

本文链接：https://blog.csdn.net/m0_59833546/article/details/126077899

版权

1.什么是框架

Framework;
	一个框架包含多个可重用的组件；
	使用框架的最大好处就是可以提高开发效率；
框架本质就是一个软件的半成品；

举例说明？
1.包饺子吃？
	饺子皮就是一个框架；
2.披萨

2.初识Mybatis

1.mybatis是一个应用最广泛的持久层框架
2.它是一个半自动化的框架（Hiberante）,Mybatis主要写的就是SQL语句
3.它的前身是ibatis

3.开发步骤

1.导包(mybatis,mysql-connector)
2.定义实体类 （pojo）
3.定义核心配置文件 (相当于db.properites)  Configuration.xml
4.定义DAO接口，定义SQL映射（Mapper.xml）

4.开发详细步骤

导包

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>


        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

定义实体类(略)

public class Book {

    private Integer bookNo;
    private String name;
    private String author;
    private Integer price;
    
    //getter and setter方法略
}

定义核心配置文件（主要配置数据库连接的参及SQL映射文件的位置）

此配置文件可在IDEA中使用模版自定义

<?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/book"/>
                <property name="username" value="root"/>
                <property name="password" value="tiger"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/bao/BookMapper.xml"/>
    </mappers>
</configuration>

定义DAO接口

package com.bao.dao;

import com.bao.entity.Book;

import java.util.List;

public interface BookDao {
    public List<Book> selectAll();

    public void insert(Book book);
}

定义BookMapper映射文件，此映射文件与DAO接口对应；

<?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.huayu.dao.BookDao">

    <select id="selectAll" resultType="com.bao.entity.Book">
        select * from tb_book
    </select>


    <insert id="insert" parameterType="com.bao.entity.Book">
        insert into tb_book values(null,#{name},#{author},#{price})
    </insert>

</mapper>

使用Mybatis的API来进行操作

public class TestBook {

	//session工厂
    SqlSessionFactory sqlSessionFactory=null;

    @Before
    public void init(){
        //1.定义核心配置文件
        String resource = "Configuration.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //2.创建Session工厂
       sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }
    
    
    @Test
    public void testSelect(){
        //3.获得session(会话)，程序与Mybatis
        SqlSession session=sqlSessionFactory.openSession();
        //4.获得dao对象
        BookDao dao=session.getMapper(BookDao.class);
        List<Book> list=dao.selectAll();

        for(Book b:list){
            System.out.println(b);
        }
        session.close();
    }


    @Test
    public void insertTest(){
        SqlSession session=sqlSessionFactory.openSession();
        BookDao dao=session.getMapper(BookDao.class);

        Book b=new Book();
        b.setAuthor("刘润");
        b.setName("逻辑思维");
        b.setPrice(56);
        dao.insert(b);
        session.commit();
        session.close();
    }
}

5.Mybatis的工作原理

6.映射器的方式

创建映射器有两种方式；
1.DAO接口+xml;
2.DAO接口+annotation

Dao+Annotation

定义Dao接口和Annoation

@Select("select * from tb_book")
public List<Book> selectAll();

@Insert("insert into tb_book values(null,#{name},#{author},#{price})")
public void insert(Book book);

在核心配置文件中加载映射

<mappers>
     <package name="com.bao.dao"/>
</mappers>

7.核心配置文件

在Mybatis中，通过核心配置文件，可以配置Mybatis中最常用的配置，哪数据源，别名，参数设置，加载映射文件等，主要的元素有，

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

1.settings

      <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.18.0</version>
        </dependency>

    <settings>
        <!--标准的日志实现-->
        <setting name="logImpl" value="LOG4J2"/>
    </settings>

<!--log4j2.xml-->

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="DEBUG">
    <appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </appenders>
    <loggers>
        <logger name="log4j.logger.noModule" level="fatal" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.org.mybatis.jpetstore" level="trace" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.com.opensymphony.xwork2" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.com.ibatis" level="trace" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.com.ibatis.common.jdbc.SimpleDataSource" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.com.ibatis.common.jdbc.ScriptRunner" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.org.mybatis" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.java.sql" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.java.sql.Connection" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.java.sql.Statement" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.java.sql.PreparedStatement" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <logger name="log4j.logger.java.sql.ResultSet" level="debug" additivity="false">
            <appender-ref ref="Console"/>
        </logger>
        <root level="trace">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

2设置别名

    <typeAliases>
<!--        <typeAlias type="com.huayu.entity.Book" alias="book"/>-->    
        <package name="com.huayu.entity"/>
    </typeAliases>

3.数据源

<environments default="produce">

        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="jdbc:mysql://localhost:3306/book"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>


        <environment id="produce">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="jdbc:mysql://localhost:3308/books"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

4映射器

    <mappers>
<!--        <package name="com.huayu.dao"/>-->
        <mapper resource="com/bao/BookMapper.xml"/>
    </mappers>

注意：如果使用的是mapper方式，需要在resources中创建两个文件夹，com/bao,不能直接创建com.bao

8.XML映射文件（SQL映射）

主要标记

insert – 映射插入语句。
update – 映射更新语句。
delete – 映射删除语句。
select – 映射查询语句。

sql – 可被其它语句引用的可重用语句块。
cache – 该命名空间的缓存配置。
cache-ref – 引用其它命名空间的缓存配置。
resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。

1示例

定义一个方法，用来获得某个作者的图书的数量，最高的价格，及总价格；
map->三个key;

    <select id="selectInfoByAuthor" resultType="map">
        select count(*) count,max(price) max,sum(price) sum from tb_book where
        author=#{author}
    </select>
    
      //通过一个方法返回图书

    public Map<String,Long> selectInfoByAuthor(String author);

#如果一个方法有两个参数应该好何处理呢？

select * from tb_book where name=? and price>?

1.使用pojo;
2.使用map
3.传递多个参数；使用@Param注解为参数命名

public List<Book> selectByCondition(@Param("name") String name, @Param("price") Integer price);

   <select id="selectByCondition" resultType="book">
        select * from tb_book where
        author=#{name} and price>#{price}
    </select>

2标记的属性小结

id:标记的唯一标识，不能重复，映射的是DAO中的方法名
parameterType:参数类型，可以省略
resultType:返回值的类型  vo,map,基本类型均可
resultMap:自定义的结构映射；
statementType:执行SQL语句的底层Statement类型，有三种：Statement,PreparedStatment,CallableStatment

OGNL表达式；

3.关于insert中生成主键的处理

<!--利用数据库的自增长功能   useGeneratedKeys代表是否使用数据库生成的主键，keyProperty:表示将生成的主键赋给哪个属性-->
    <insert id="insert" parameterType="order" useGeneratedKeys="true" keyProperty="orderId">
        insert into biz_order values(null,#{orderCode},#{orderDate},#{orderFlag})
    </insert>

#如果数据库不支持自增长怎么办？

    <insert id="insert" parameterType="order">
        <selectKey keyProperty="orderId" order="BEFORE" resultType="int">
            select max(orderId)+10 from biz_order
        </selectKey>
        insert into biz_order values(#{orderId},#{orderCode},#{orderDate},#{orderFlag})
    </insert>

4.update与delete

    <update id="update" parameterType="order">
        update biz_order set orderFlag=#{orderFlag} where orderId=#{orderId}
    </update>


    <delete id="delete" parameterType="int">
        delete from biz_order where orderId=#{orderId}
    </delete>

5.sql

sql标记可以定义一段可重复使用的SQL片段，然后通过include标记进行引用

    <sql id="column">
        orderid,ordercode,orderDate,orderflag
    </sql>

    <select id="selectAll" resultType="order">
    select <include refid="column"></include>  from biz_order
</select>

6字符串的拼接

#{}:语法是使用点位符进行参数的替换
${}:就是完成字符串的拼接

通过${}可以解决按字段排序的问题；
同样${}会产生SQL注入的问题；


 <select id="selectOrder" resultType="order">
        select * from biz_order order by ${name}
  </select>

9高级映射 ResultMap

为什么要用ResultMap
1.当字段与Pojo的属性不一致时，可以使用ResultMap自定义映射规则
2.当需要完成复杂映射时，例如（1对1，1对多）时，必须使用ResultMap;

<resultMap id="映射的唯一标识" type="java的Pojo类">

	constructor,id,result子标记都是设置字段与属性的映射规则
	association:一对一
	collections:一对多

示例

1.定义两个表，sys_emp,sys_dept;一个部门对应多个员工
2.定义两个实体类；
		Emp
			id
			name
			sex
			Dept dept
			hiredate
			
			association
		Dept
			deptno
			dname
			List<Emp> emps;
			collection

1.多对一的映射

    <!--自定义映射规则-->
    <resultMap id="empResultMap" type="com.bao.entity.Emp" >
        <id property="id" column="id"></id>
        <result property="sex" column="sex"></result>
        <result property="name" column="name"></result>
        <result property="hiredate" column="hiredate"></result>
        
        <association property="dept" javaType="com.bao.entity.Dept"  >
            <id column="deptno" property="deptno"></id>
            <result column="dname" property="dname"/>
        </association>
    </resultMap>

    <select id="select" resultMap="empResultMap" >
       select id,name,sex,hiredate,sys_dept.deptno deptno,dname  from sys_emp,sys_dept
       where sys_emp.deptno=sys_dept.deptno
    </select>

2.自动映射

注意：如果字段与属性名完全相同，则可以使用自动映射

    <!--自定义映射规则-->
    <resultMap id="empResultMap" type="com.bao.entity.Emp"  autoMapping="true">
        <association property="dept" javaType="com.bao.entity.Dept"  autoMapping="true">
        </association>
    </resultMap>

3.查询语句映射

多对一关联时，如果想查到关联的数据，可能通过两种方法
1.表连接（查询一次）
2.先查员工,再根据员工ID查询所对应的部门（n+1）

    <!--自定义映射规则-->
    <resultMap id="empResultMap" type="com.bao.entity.Emp"  autoMapping="true">

        <association property="dept" javaType="com.bao.entity.Dept" column="deptno" select="getDeptByNo">
        </association>
    </resultMap>


    <select id="getDeptByNo" resultType="dept">
        select * from sys_dept where deptno=#{deptno}
    </select>

4.一对多的映射

<!--通过Collections标记；（元素）
	注意：id是判断是否重复的标准；
-->
    <resultMap id="myDeptMapper" type="com.bao.entity.Dept" >
        <id column="deptno" property="deptno"/>
        <result column="dname" property="dname"/>

        <collection property="emps" ofType="com.bao.entity.Emp" resultMap="myEmp">

        </collection>
    </resultMap>
    ·········································································································
       <select id="select" resultMap="myDeptMapper">
        select id,name,sex,hiredate,d.deptno deptno,dname
        from sys_dept d left join sys_emp e on d.deptno=e.deptno
        order by deptno
    </select>

   <!--n+1的方式-->
   <resultMap id="myDeptMapper" type="com.bao.entity.Dept" >
        <id column="deptno" property="deptno"/>
        <result column="dname" property="dname"/>

        <collection property="emps" ofType="com.bao.entity.Emp" column="deptno" select="selectEmpsByDeptno">

        </collection>
    </resultMap>

    <resultMap id="myEmp" type="com.bao.entity.Emp" autoMapping="true">

    </resultMap>


    <select id="selectEmpsByDeptno" resultType="emp">
        select * from sys_emp where deptno=#{deptno}
    </select>

5.在Mapper中引用另一个Mapper中的resultMap或方法

1.通过全路径+方法名（或resultMap的id）例如
	select="com.bao.dao.DeptMapper.getDeptByNo">
2.有个前提要求
	接口名与Sql映射文件的文件名及路径完全相同。

6.鉴别器

	商品
		id;
		名称
		品牌
		价格
		类型:1,2,3
		
	鞋：
		号码
	丝巾：
		颜色
		材质
	帽子：
		颜色
		尺寸

10. 动态SQL语句

动态SQL是Mybatis是强大的功能之一。它通过一些标记来实现动态SQL，常用的标记有 if choose where foreach set等；

if标记

语法 
<if test="">
	语句
</if>
如果条件成立，就生成语句，否则无此内容；
  <if test="deptNo != null">
         and deptno=#{deptNo}
  </if>

where标记

where:如果where标记中没有内容，则去除where，否成生成where,并且去除where中第一个and或or;

      <where>
            <if test="name !=null">
                or name=#{name}
             </if>
            <if test="sex != null">
                and sex=#{sex}
            </if>
            <if test="deptNo != null">
                and deptno=#{deptNo}
            </if>
        </where>

choose 多分支


[收入] 【= >】[1000]

<choose>
	<when test="operation =='eq'">
			sal = #{sal}
	</when>
	<otherwise>
		sal > #{sal}
	</otherwise>

</choose>

            <if test="deptNo != null">
                <choose>
                    <when test="operation =='eq'">
                        and deptno=#{deptNo}
                    </when>
                    <otherwise>
                        and deptno>#{deptNo}
                    </otherwise>
                </choose>
            </if>

Trim :自定义增加或去除的前缀及后缀

<trim prefix="where" prefixOverrides="and|or">
            <if test="name !=null">
                or name=#{name}
             </if>
            <if test="sex != null">
                and sex=#{sex}
            </if>
            <if test="deptNo != null">
                <choose>
                    <when test="operation =='eq'">
                        and deptno=#{deptNo} 
                    </when>
                    <otherwise>
                        and deptno>#{deptNo} 
                    </otherwise>
                </choose>
            </if>

        </trim>

set

    <update id="update">
        update sys_emp
        <set>
            <if test="name!=null">
                name=#{name},
            </if>
            <if test="sex!=null">
                sex=#{sex},
            </if>
            <if test="deptNo!=null">
                deptno=#{deptNo}
            </if>
        </set>
        where id=#{id}
    </update>

foreach

遍历

    <select id="selectIn" resultType="emp">     
        select * from sys_emp
        <where>

            <foreach collection="array" item="id" open="id in (" close=")" separator=",">
                #{id}
            </foreach>
        </where>
    </select>

关于参数的传递

mybatis内部使用的是Ognl表达式，这个表达式与EL的很相似；
	对象图导航语言；Object　Graph　Navigation Language

本质是将数据存到map结构中，然后再通过OGNL表达式来获取；
(@Param("name") String userName)  ===>  map.put("name",userName)
(int[] ids)                       ===>  map.put("array",ids)
(@Param("param") int[] ids)       ====>  map.put("param",ids)

#{name}   #{array}

Bind

bind 元素允许你在 OGNL 表达式以外创建一个变量，并将其绑定到当前的上下文。比如：

<select id="selectBlogsLike" resultType="Blog">
  <bind name="pattern" value="'%' + _parameter.getTitle() + '%'" />
  SELECT * FROM BLOG
  WHERE title LIKE #{pattern}
</select>

11.延迟加载

延迟加载也叫按需加载；在很多的技术点中都有延迟加载；
	单例；
	servlet：

mybatis的延迟加载指的是：先查询主信息，从信息在需要时才加载；

mybatis的延迟加载在哪里可以使用：association,collection

	Dept->List<Emp> emps
		get.getEmps();
		
		getDname();

可以通过两种方式配置是否加载加载 
1.在Configuration.xml中
	<setting name="lazyLoadingEnabled" value="true"/>
2.在SQL映射文件中，使用fetchType="lazy"来设置
	<association property="dept" javaType="com.huayu.entity.Dept" fetchType="eager" column="deptno" select="com.huayu.dao.DeptMapper.getDeptByNo">

如果同时通过两种方式设置，那么SQL映射的fetchTpye的优先级更高；

12.缓存

Mybatis的缓存分为两种，一级缓存和二级缓存；
一级缓存：Session级别的，默认是打开的；
二级缓存：SessionFactory级别，可以设置；

为什么要使用缓存；
	减少对数据的访问次数（查询）；从而提高性能；

一级缓存

一级缓存是Session级别的，不需要配置；
当执行insert,update,delete时，将会清空缓存；

 EmpDao dao=session.getMapper(EmpDao.class);
 System.out.println(dao.selectEmpById(1));
 System.out.println(dao.selectEmpById(1));

二级缓存

二级缓存是SqlSessionFactory级别的，只有一个，被所有的session共享，可以手动配置

操作步骤

打开二级缓存的开关

 <setting name="cacheEnabled" value="true"/>

在Mapper文件中加入cache标记

<cache></cache>

 <cache
            eviction="LRU"
            flushInterval="60000"
            size="512"
            readOnly="false"/>

size:最多缓存多少条查询
flushIntervale:多久刷新一次；
evication:驱逐策略，FIFO,LRU
readOnly（只读:属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。
	
selectId(1);   张三 ，18；   Emp(1,张三，19)

实现序列化接口

示例

    @Test
    public void testCache() throws InterruptedException {
        EmpDao dao=session.getMapper(EmpDao.class);
        System.out.println(dao.selectEmpById(1));
        session.commit();
        System.out.println(dao.selectEmpById(2));
        session.commit();
        System.out.println(dao.selectEmpById(1));
        session.commit();
        System.out.println(dao.selectEmpById(3));
//        Emp e=new Emp();
//        e.setId(2);
//        e.setName("张三丰");
//        dao.update(e);
          session.close();


        //创建第二个session
        SqlSession session1=sqlSessionFactory.openSession();
        EmpDao dao1=session1.getMapper(EmpDao.class);
//        for(int i=0;i<100;i++){
            dao1.selectEmpById(1);
        }

        System.out.println("==============================");
        System.out.println(dao1.selectEmpById(1));
        System.out.println(dao1.selectEmpById(2));
        System.out.println(dao1.selectEmpById(3));
    }

13.逆向工程

逆向工程的作用；生成mybatis代码？

能生成什么？
	1.实体类
	2.Mapper接口
	3.Mapper映射文件

逆向工程的步骤
1.导包 mybatis-generator-core
2.增加 mybatis-generator插件
3.定义数据源（根据表生成代码）
4.创建generatorConfig配置文件，此配置文件定义了生成代码的规则
5.运行maven mybatisgenerator插件

1.导包及增加插件（pom.xml）

    <dependencies>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.4.1</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>zsxt</finalName>
        <!--执行逆向工程代码的插件-->
        <plugins>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.4.1</version>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.定义数据源,generator.properties

jdbc.driverLocation=D:....(自己文件位置).../mysql-connector-java-5.1.49.jar
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.connectionURL=jdbc:mysql://localhost:3306/cmp?useSSL=false
jdbc.userId=root
jdbc.password=tiger

3.定义generatorConfig配置文件

<?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>
    <!--导入属性配置-->
    <properties resource="generator.properties"></properties>

    <!--指定特定数据库的jdbc驱动jar包的位置-->
    <classPathEntry location="${jdbc.driverLocation}"/>

    <context id="default" targetRuntime="MyBatis3">

        <!-- optional，旨在创建class时，对注释进行控制 -->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!--jdbc的数据库连接 -->
        <jdbcConnection
                driverClass="${jdbc.driverClass}"
                connectionURL="${jdbc.connectionURL}"
                userId="${jdbc.userId}"
                password="${jdbc.password}">
            <!--MySQL 不支持 schema 或者 catalog 所以需要添加这个-->
            <!-- 不然会出现生成器把其他数据库的同名表生成下来的问题 -->
            <!-- 现象就是某个类中出现了数据库表里面没有的字段 -->
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>


        <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>


        <!-- Model模型生成器,用来生成含有主键key的类，记录类 以及查询Example类
            targetPackage     指定生成的model生成所在的包名
            targetProject     指定在该项目下所在的路径
        -->
        <javaModelGenerator targetPackage="com.huayu.entity"
                            targetProject="src/main/java">

            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对model添加 构造函数 -->
            <property name="constructorBased" value="true"/>
            <!-- 是否对类CHAR类型的列的数据进行trim操作 -->
            <property name="trimStrings" value="true"/>
            <!-- 建立的Model对象是否 不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>

        </javaModelGenerator>

        <!--Mapper映射文件生成所在的目录 为每一个数据库的表生成对应的SqlMap文件 -->
        <sqlMapGenerator targetPackage="com.huayu.mapper"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!-- 客户端代码，生成易于使用的针对Model对象和XML配置文件 的代码
                type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象
                type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象
                type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口
        -->
        <javaClientGenerator targetPackage="com.huayu.mapper"
                             targetProject="src/main/java" type="XMLMAPPER">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!--要执行逆向工程所用到的表-->
        <table tableName="sys_dept" domainObjectName="Dept">
        <property name="useActualColumnNames" value="false"/>
    </table>
        <table tableName="sys_emp" domainObjectName="Emp">
            <property name="useActualColumnNames" value="false"/>
        </table>

        <!--        <table tableName="category" />-->
    </context>
</generatorConfiguration>

4.执行插件

5.测试

import com.huayu.entity.Emp;
import com.huayu.entity.EmpExample;
import com.huayu.mapper.DeptMapper;
import com.huayu.mapper.EmpMapper;
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 org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestGenerator {


    SqlSessionFactory sqlSessionFactory=null;
    SqlSession session=null;

    @Before
    public void init() throws IOException {
        String resource = "Configuration.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        session=sqlSessionFactory.openSession();
    }

    @Test
    public void test(){
        DeptMapper mapper=session.getMapper(DeptMapper.class);

        System.out.println(mapper.selectByPrimaryKey(2));

        EmpMapper mapper1=session.getMapper(EmpMapper.class);

        EmpExample example=new EmpExample();

        example.createCriteria().andSexEqualTo("男").andNameLike("%白%");

        List<Emp> list=mapper1.selectByExample(example);

        list.stream().forEach(System.out::println);
    }
}


~~~java

ession.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestGenerator {


    SqlSessionFactory sqlSessionFactory=null;
    SqlSession session=null;

    @Before
    public void init() throws IOException {
        String resource = "Configuration.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        session=sqlSessionFactory.openSession();
    }

    @Test
    public void test(){
        DeptMapper mapper=session.getMapper(DeptMapper.class);

        System.out.println(mapper.selectByPrimaryKey(2));

        EmpMapper mapper1=session.getMapper(EmpMapper.class);

        EmpExample example=new EmpExample();

        example.createCriteria().andSexEqualTo("男").andNameLike("%白%");

        List<Emp> list=mapper1.selectByExample(example);

        list.stream().forEach(System.out::println);
    }
}

Rs、

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Mybatis学习小结

MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。......
复制链接

扫一扫