mybatis详解(全)「建议收藏」

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

持久层技术解决方案有几种?

mybatis持久层框架

测试用例搭建

mybatis主配置文件

mybatis映射文件

mybatis动态SQL

mybatis分页

mybatis逆向工程

mybatis

持久层技术解决方案有几种?

1.JDBC技术–>Connection、PreparedStatement、ResultSet

2.Spring的JdbcTemplate–>Spring中对Jdbc的简单封装

3.Apache的DBUtils–>它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装

以上这些都不是框架(JDBC是规范、Spring的JdbcTemplate和Apache的DBUtils都只是工具类)

mybatis持久层框架

mybatis是一个用Java编写的持久层框架，它使用ORM实现了结果集的封装。

ORM是Object Relational Mapping 对象关系映射。简单来说，就是把数据库表和实体类及实体类的属性对应起来，让开发者操作实体类就实现操作数据库表。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等烦杂过程

测试用例搭建

搭建环境流程如下四点：

1. 创建maven工程并导入坐标

   <dependencies>
   	
   	       <dependency>
   	           <groupId>org.mybatis</groupId>
   	           <artifactId>mybatis</artifactId>
   	           <version>3.4.5</version>
   	       </dependency>
   	       <dependency>
   	           <groupId>mysql</groupId>
   	           <artifactId>mysql-connector-java</artifactId>
   	           <version>5.1.43</version>
   	       </dependency>
   	
   	       <dependency>
   	           <groupId>log4j</groupId>
   	           <artifactId>log4j</artifactId>
   	           <version>1.2.12</version>
   	       </dependency>
   	
   	       <dependency>
   	           <groupId>junit</groupId>
   	           <artifactId>junit</artifactId>
   	           <version>4.10</version>
   	       </dependency>
   	
   </dependencies>
   

2. 创建实体类和Mapper的接口

   public class User implements Serializable { 
        
   		
   	private int id ;
   	private String username;
   	......
   }
   

   public interface IUserMapper { 
        
   	/** * 查询所有操作 * @return */
   	List<User> findAll();
   }
   

3. 创建mybatis的主配置文件

   <configuration>
       <!--配置环境-->
       <environments default="mysql">
           <!--配置Mysql的环境-->
           <environment id="mysql">
               <!--配置事务的类型-->
               <transactionManager type="JDBC"></transactionManager>
               <!--配置数据源(连接池)-->
               <dataSource type="POOLED">
                   <!--配置连接数据库的四个基本信息-->
                   <property name="driver" value="com.mysql.jdbc.Driver" />
                   <property name="url" value="jdbc:mysql://localhost:3306/db1" />
                   <property name="username" value="root" />
                   <property name="password" value="root" />
               </dataSource>
           </environment>
       </environments>
   
       <mappers>
           <mapper resource="Mybatis/IuserMapper.xml" />
       </mappers>
   
   </configuration>
   

4. 创建映射配置文件

   <mapper namespace="com.Mapper.IUserMapper" >
       <select id="findAll" resultType="com.Pojo.User" >
           select * from usr
       </select>
   </mapper>
   

   测试方法

   ......
   
   InputStream in = Resources.getResourceAsStream("mybatis/MapperConfig.xml");
   //创建SqlSessionFactory工厂
   SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
   SqlSessionFactory factory = builder.build(in);
   //使用工厂生产SqlSession对象
   SqlSession session = factory.openSession();
   //使用SqlSession创建Mapper接口的代理对象
   UserMapper userMapper = session.getMapper(UserMapper.class);
   //使用代理对象执行方法
   List<mybatis_user> users = userMapper.findAll();
   for (mybatis_user muser : users){ 
        
       System.out.println(muser);
   }
   session.close();
   in.close();
   
   ......
   

mybatis主配置文件

mybatis的配置文件推荐为命名mybatis-config.xml，其内容包含了会深深影响mybatis行为的设置和属性信息。以下是全配置文件列表：
使用者掌握方面有properties、settings、typeAliases、enveronments、mappers

具体各个配置内容如下：

1. properties 标签

   开发者可通过properties属性来实现引用配置文件。这些属性都是可外部配置且可动态替换的

   [注]
   1.如果两个配置文件有同一个字段，优先使用外部配置文件的
   2.可以直接引入外部配置文件，properties子元素中可以增加一些属性配置

   

2. typeAliases 标签

   typeAliases类型别名是为java类型设置一个短的名字，存在的意义仅在于用来减少类完全限定名的冗余。java内置内建类型别名它们都不区分大小写，注意对基本类型名称重复采用的特殊命名风格。

   别名	映射的类型
   _byte	byte
   _long	long
   _int	int
   _integer	int
   _double	double
   _float	float
   _boolean	boolean
   string	String
   byte	Byte
   long	Long
   short	Short
   int	Integer
   Integer	Integer
   double	Double
   float	Float
   boolean	Boolean
   date	Date
   object	Object
   map	Map
   hashmap	HashMap
   list	List
   arraylist	ArrayList

   [注]
   方法二中，每一个在包中的Java bean,在没有注解的情况下，会使用bean的首字母小写的非限定类名来作为它的别名。若有注解，则别名为其注解值。(实体类上使用注解:@Alias(“user”))

3. setting 标签

   setting设置标签，这是Mybatis中极为重要的调整设置，它们会改变Mybatis的运行时行为

   

4. dataSource 标签

   我们在实际开发中都会使用连接池，因为它可以减少我们获取连接所消耗的时间，在mybatis中连接池提供了3种方式的配置

   
   [注]主配置文件的dataSource标签，type属性就是表达采用何种连接池方式

   1）POOLED 方式

   *采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现

   
   [注]观察出POOLED它是从池中获取一个连接来用

   2）UNPOOLED 方式

   *采用传统的获取连接的方式，虽然也实现javax.sql.DataSource接口，但是并没有使用连接池技术

   

   [注]UNPOOLED每次创建一个新的连接来用

   3）JNDI 方式

   *采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样的

   [注]如果不是web或者maven的war工程，是不能使用的

5. mappers 属性

   mappers映射器属性，MapperRegistry:注册绑定我们的Mapper文件。有三种方式如下：

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

   或

   <mappers>
   	<mapper class="com.ferao.mapper.UserMapper" />
   </mappers>
   

   [注]
   使用class文件绑定注册,接口和它的Mapper配置文件必须同名且接口且它的Mapper配置文件必须在同一个包下

   或

   <mappers>
   	<package name="com.ferao.mapper"></package>
   </mappers>
   

   [注]
   扫描包进行注入绑定方式,接口和它的Mapper配置文件必须同名且接口和它的Mapper配置文件必须在同一个包下

mybatis映射文件

映射配置文件里的参数信息如下：

1. parameterType（输入类型）

   可输入的类型有三种：简单类型、pojo对象、pojo包装对象

   1）简单类型

   2）pojo对象

   mybaits使用OGNL表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称

   [注]OGNL表达式：object Graphic Navigation Language (对象图导航语言)，它是通过对象的取值方法来获取数据。在写法上把gat给省略了。比如：我们获取用户的名称类中的写法：user.getUsername();
   OGNL表达式写法：user.username
   那么，mybatis中为什么能直接写username,而不用user呢？因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名

   3）pojo包装对象

   开发中通过pojo传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其他的查询条件（比如将用户购买商品消息也作为查询条件），这时可以使用包装对象传递输入pojo类参数中包含pojo。

2. resultType（输出类型）

   可输出的类型有四种：返回一般数据类型(单条)、JavaBean 类型(单条)、List类型(多条)、Map类型

   1）一般数据类型(单条)

   比如要根据Id属性获得数据库中的某个字段值，示例：

   ①mapper(dao)接口

   String getStuNameById(Integer id);
   

   ②Mapper.xml 映射文件

   <select id="getStuNameById" resultType="string">
   	select username from t_student where id = #{id}
   </select>
   

   2）JavaBean 类型(单条)

   比如根据某个字段获得数据库中的信息，把查询的结果信息封装成某个javaBean类型的数据

   ①mapper(dao)接口

   Student getStuById(Integer id);
   

   ②Mapper.xml 映射文件

   <select id="getStuById" resultType="student">
   	select * from t_student where id = #{id}
   </select>	
   

   3）List类型(多条)

   有时候开发者查询的数据不止一条，比如，模糊查询，全表查询等，这时候返回的数据可能不止一条数据，对于多数据的处理可以存放在List集合中

   ①mapper(dao)接口

   List<Student> getAllStus();
   

   ②Mapper.xml 映射文件

   <!--注意这里的 resultType 返回值类型是集合内存储数据的类型，不是 'list'-->
   <select id="getAllStus" resultType="student">
   	select * from t_student
   </select>
   

   4）Map类型

   mybatis支持将查询的数据封装成Map。

   如果查询的结果是一条，开发者可以把查询的数据以(表字段名，对应的值)方式存入到map中

   ①mapper(dao)接口

   Map<String, Object> getStuAsMapById(Integer id);
   

   ②Mapper.xml 映射文件

   <!-- 注意这里的 resultType 返回值类型是 'map'-->
    <select id="getStuAsMapById" resultType="map">
   	select * from t_student where id = #{id}
   </select>
   

   如果查询的结果是多条数据，我们也可以把查询的数据以{表中某一字段名, JavaBean}方式来封装成Map

   ①mapper(dao)接口

   // 查询所有学生的信息，把数据库中的 'id' 字段作为 key,对应的 value 封装成 Student 对象
   // @MapKey 中的值表示用数据库中的哪个字段名作 key
   @MapKey("id")
   Map<Integer, Student> getAllStusAsMap();
   

   ②Mapper.xml 映射文件

   <!--注意 resultType 返回值类型，不再是 'map'，而是 Map 的 value 对应的 JavaBean 类型-->
   <select id="getAllStusAsMap" resultType="student">
   	select * from t_student
   </select>
   

   返回map集合时返回的类型是List<Map<String, Object>>

   ①mapper(dao)接口

   List<Map<String, Object>> getAllStuAsMapById(Integer id);
   

   ②Mapper.xml 映射文件

   <!--查询多条-->
   <select id="getAllStuAsMapById" parameterType="int" resultType="map">
   	select * from usr
   </select>	
   

3. resultMap（映射实体类）

   数据库字段名和实体类属性不相同时，无法映射到值，输出为Null。这是因为mybatis会根据这些从数据库中查询到的列名，将列名转化为小写(数据库不区分大小写)去对应实体类中查询相应列名的set方法设值，由于找不到setUserName()，所以会返回Null值。

   

   要明确与Java对象对应的列不是数据库中表的列名，而是查询后结果集的列名
   解决方案有两种：
   1）为列名指定别名，别名和Java实体类的属性名一致
   2）使用结果集映射ResultMap [推荐]

   resultMap的作用是建立sql查询结果字段与实体属性的映射关系信息，将查询的结果集转换为java对象，方便进一步操作，即结果集中的列与Java对象中的属性对应起来并值填充进去

   resultMap 属性全内容如下：

   <!--column不做限制，可以为任意表的字段，而property须为type 定义的pojo属性-->
   <resultMap id="" type="">
   	<!--设置主键时使用，使用此标签配置映射关系(可能不止一个) -->
   	<id column="" jdbcType="" property="" />
   	<result column="" jdbcType="" property=""/>
   	
   	<association property="" javaType="">
   	  <id column="" jdbcType="" property=""/>
   	  <result column="" jdbcType="" property=""/>
   	</association>
   	
   	<!-- 集合中的property须为oftype定义的pojo对象的属性-->
   	<collection property="pojo的集合属性" ofType="集合中的pojo对象">
   	  <id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" />
   	  <result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" />
   	</collection>
   </resultMap>	
   

   接下来对各标签属性进行简单介绍：

   1）resultMap 标签

   type属性：指开发者需要映射到的类对象

   id属性：表示reslutMap在select标签中使用时，id的名称

   2）id标签

   	方案一 -->为列名指定别名，别名和Java实体类的属性名一致 
   
   		 <select id="findAll"  resultType="user">
   		      select id,username as usernames from usr ;
   		 </select>	
   
   	方案二 --> 使用结果集映射ResultMap [推荐]
   
   		<resultMap id="UserMap" type="User">
   	        <!--id为主键-->
   	        <id column="id" property="id" />
   	        <!--column 是数据库表的名称，property是对应实体类的属性名-->
   	        <result column="username" property="usernames" />
   	    </resultMap>
   	
   		<!--查询所有-->
   	    <select id="findAll"  resultMap="UserMap">
   	      select id,username  from usr ;
   	    </select>
   
   	===========================标签描述====================================
   
   
   	--> 
   		
   		column   --> 表的主键字段,或者可以为查询语句中的别名字段
   		jdbcType --> 字段类型
   		property --> 映射pojo对象的主键属性
   	
   	result标签 --> 属性用于配置映射关系时使用
   
   		column   --> 表的一个字段（可以为任意表的一个字段）
   		jdbcType --> 字段类型
   		property --> 映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）
   
   	association标签 --> 
   
   		property --> pojo的一个对象属性
   		javaType --> pojo关联的pojo对象
   
   		id标签--> 
   		
   			column   --> 关联pojo对象对应表的主键字段
   			jdbcType --> 字段类型
   			property --> 关联pojo对象的主席属性	
   
   		result标签 -->
   		
   			column   --> 任意表的字段
   			jdbcType --> 字段类型
   			property --> 关联pojo对象的属性
   						
   		select   -->表示所需要的哪个类的查询语句
   		column   -->从resultMap中传过去用作查询参数
   		ofType   -->集合属性中的对象(可以不写)
   
   	collection标签 -->
   	
   		property --> 表示pojo类集合中的属性
   		select   -->表示所需要的哪个类的查询语句
   		column   -->从resultMap中传过去用作查询的参数
   		ofType   -->集合属性中的对象(可以不写)
   
   	===========================标签细节====================================
   
   	id & result
   
   		示例
   
   			<id property="id" column="post_id"/>
   			<result property="subject" column="post_subject"/>
   
   		含义
   		
   			这些是结果映射最基本的内容，id和result都将一个列的值映射到一个简单的数据类型
   
   			的属性或字段。这两者之间的唯一不同是，id表示的结果将是对象的标识属性，这些在
   
   			比较对象实例时用到，这样可以提高整体的性能，尤其是缓存和嵌套结果映射的时候
   	```
   
   
   
   

mybatis动态SQL

动态sql根据不同的条件生成不同的sql语句.所谓的动态sql，本质还是sql语句，只是开发者可以在sql层面，去执行一个逻辑代码，现在编写一个mapper接口用于测试：

List<User> queryUser(Map map);

if标签语句示例：

<select id="queryUser" parameterType="map" resultType="user">      
	  select * from usr where 1=1
	  <if test="id != null" >      
	      and id =#{id}  
	  </if>
	  <if test="username != null" >
	      and username = #{username}
	  </if>
</select>

where标签语句示例：

<!-- where 元素只会在至少有一个子元素的条件返回sql子句的情况下，才去插入"where" 子句-->
<select id="queryUser" parameterType="map" resultType="user">   
	  select * from usr  
		  <where>
			  <if test="id != null" >
			      id =#{id}
			  </if>
			  <if test="username != null" >
			      and username = #{username}
			  </if>
		  </where>
</select>

choose,when,otherwise标签语句示例：

<!-- 有时不想应用到所有的条件语句，而只想从中择其一项，针对这种情况，Mybatis提供了choose元素 它有点像java中的switch语句 -->
<select id="queryUser" parameterType="map" resultType="user">
	  select * from usr
	  <where>
	      <choose>
	          <when test="id != null" >
	              id =#{id}
	          </when>
	          <when test="username != null" >
	              and username = #{username}
	          </when>
	          <otherwise>
	              and id= 4
	          </otherwise>
	      </choose>
	  </where>
</select>

set 标签语句示例：

<!-- 这里set元素会动态前置set关键字，同时也会删除掉无关的逗号 因为用了条件语句之后很可能就会生成的sql后面留下这些逗号 -->
<update id="updateUsr" parameterType="map">   
		update usr
		    <set>
		        <if test="username !=null">
		            username =#{username}
		        </if>
		    </set>
		where id = #{id}
</update>

foreach 标签语句示例：

<!-- collection 表示迭代集合的名称，可以使用@Param注解指定，如下图所示 该参数为必选 item 表示本次迭代获取的元素，若collection为List、Set或者数组，则表示其中的元素； 若collection为map，则代表key-value的value，该参数为必选 open 表示该语句以什么开始，最常用的是左括弧’(’，注意:mybatis会将该字符拼接到整体的sql语句之前，并且只拼接一次，该参数为可选项 close 表示该语句以什么结束，最常用的是右括弧’)’，注意:mybatis会将该字符拼接到整体的sql语句之后，该参数为可选项 separator mybatis会在每次迭代后给sql语句append上separator属性指定的字符，该参数为可选项 index 在list、Set和数组中,index表示当前迭代的位置，在map中，index代指是元素的key，该参数是可选项。 -->

<!-- 第一步:迭代集合，获取对应的item，和外部的()，拼接形成('zhangsan') 第二步:在之前的基础上拼接上逗号分隔符（'zhangsan'）, 第三步:继续迭代并拼接逗号 （'zhangsan'）,（'lisi'）, 第四步:继续迭代并拼接逗号 （'zhangsan'）,（'lisi'）,（'wangwu'） -->
<foreach collection="list" item="item" separator=",">
	（#{item}）
</foreach>


<!-- 第一步:拼接open指定的开始字符 ( 第二步:迭代集合，拼接对应的item, ('zhangsan' 第三步:拼接separator指定的分隔符 ('zhangsan', 第四步:迭代集合，拼接对应的item, ('zhangsan','lisi' 第五步：拼接separator指定的分隔符('zhangsan','lisi', 第六步：拼接close指定的闭合字符 ('zhangsan','lisi','wangwu') -->
<foreach collection="list" item="item" open="(" separator="," close=")">
	#{item}
</foreach>

4. 拓展<sql>标签

   1. 基础内容

      -含义
      
      	定义常量及作用于引用
      
      -场景
      
      	当多种类型的查询语句的查询字段或者查询条件形同时，可以将其定义为常量，方便调用。
      	
      	为求<select>标签结构清晰，也可将sql语句分解
      

   2. 示例

      	<!-- 查询字段 -->
      	<sql id="Base_Column_List">
      	    ID,MAJOR,BIRTHDAY,AGE,NAME,HOBBY
      	</sql>
      	
      	<!-- 查询条件 -->
      	<sql id="Example_Where_Clause">
      	    where 1=1
      	    <trim suffixOverrides=",">
      	        <if test="id != null and id !=''">
      	            and id = #{ 
             id}
      	        </if>
      	        <if test="major != null and major != ''">
      	            and MAJOR = #{ 
             major}
      	        </if>
      	        <if test="birthday != null ">
      	            and BIRTHDAY = #{ 
             birthday}
      	        </if>
      	        <if test="age != null ">
      	            and AGE = #{ 
             age}
      	        </if>
      	        <if test="name != null and name != ''">
      	            and NAME = #{ 
             name}
      	        </if>
      	        <if test="hobby != null and hobby != ''">
      	            and HOBBY = #{ 
             hobby}
      	        </if>
      	        <if test="sorting != null">
      	            order by #{ 
             sorting}
      	        </if>
      	        <if test="sort!= null and sort != ''">
      	            order by ${ 
             sort} ${ 
             order}
      	        </if>
      	    </trim>
      	</sql>
      

      	<!-- 查询所有，不分页 -->
      	<select id="selectAll" resultMap="BaseResultMap">
      	    SELECT
      	    <include refid="Base_Column_List" />
      	    FROM student
      	    <include refid="Example_Where_Clause" />
      	</select>
      	
      	
      	<!-- 分页查询 -->
      	<select id="select" resultMap="BaseResultMap">
      	    select * from (
      	        select tt.*,rownum as rowno from
      	        (
      	            SELECT
      	            <include refid="Base_Column_List" />
      	            FROM student
      	            <include refid="Example_Where_Clause" />
      	            ) tt
      	            <where>
      	                <if test="pageNum != null and rows != null">
      	                    and rownum
      	                    <![CDATA[<=]]>#{ 
             page}*#{ 
             rows}
      	                </if>
      	            </where>
      	        ) table_alias
      	    where table_alias.rowno>#{ 
             pageNum}
      	</select>
      	
      	<!-- 根据条件删除 -->
      	<delete id="deleteByEntity" parameterType="java.util.Map">
      	    DELETE FROM student
      	    <include refid="Example_Where_Clause" />
      	</delete>
      

      -对应标签
      
      	include
      
      -含义
      
      	用于引用定义的常量
      

mybatis分页

mybatis分页可以减少数据的处理量，分页的方式有两种：limit分页、PageHelper分页插件

limit分页方式

首先知道以下SQL语法：

#select * from user limit startIndex,pageSize;
select * from user limit 3;   #[0,n] 

开始编写Mapper.java:

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

编写Mapper.xml:

<select id="getUserByLimit" parameterType="map" resultType="user">
	select * from usr limit #{startIndex},#{pageSize}
</select>

编写测试Test:

Map<String,Integer> map = new HashMap();
map.put("startIndex",0);
map.put("pageSize",3);

List<User> userList = mapper.getUserByLimit(map);

PageHelper分页插件

引入依赖

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>4.0.0</version>
</dependency>	

[注]由于使用了sql 解析工具，所以maven也引入了 jsqlparser.jar

mybatis-config.xml配置拦截器插件

<plugins>		
	<plugin interceptor="com.github.pagehelper.PageHelper">	    
		<property name="dialect" value="mysql"/>	        
	</plugin>    
</plugins>

[注]配置拦截器时要知道新版拦截器是 com.github.pagehelper.PageInterceptor，而com.github.pagehelper.PageHelper 现在是一个特殊的 dialect 实现类，是分页插件的默认实现类，提供了和以前相同的用法。

设置数据库类型时有 Oracle,Mysql,MariaDB,SQLite,Hsqldb,PostgreSQL 六种数据库。

dialect默认情况下会使用 PageHelper 方式进行分页

1. PageHelper分页插件

   测试方法
   

   [注]
   a.只有紧跟在PageHelper.startPage方法后的第一个Mybatis的查询（Select）方法会被分页
   b.对于带有for update的sql，会抛出运行时异常，对于这样的sql建议手动分页，毕 竟这样的sql需要重视
   c.分页插件不支持嵌套结果映射，由于嵌套结果方式会导致结果集被折叠，因此分页查询 的结果在折叠后总数会减少，所以无法保证分页结果数量正确。

mybatis逆向工程

MyBatis Generator(简称MBG)，如果实际开发中数据库的表特别多，那么我们需要手动去写每一张表的po类，xxxMapper.xml，xxxMapper.java文件，这显然需要花费巨大的精力，而且可能由于表字段太多，写错了而不知道也是可能的。
所以我们在实际开发中，一般使用逆向工程方式来自动生成所需的文件。

mybatis是目前很流行的持久层框架，其逆向工程更是大大缩减了我们的开发时间。所谓mybatis逆向工程，就是mybatis通过相应插件，根据我们设计好的数据表，针对单表自动生成pojo、mapper以及mapper.xml。

插件名称是mybatis-generator-core，获取可直接在https://mvnrepository.com/搜索 mybatis ,找到 MyBatis Generator Core

插件的使用流程如下：

1. 添加maven依赖

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

2. 新增generatorConfig.xml文件

   a.连接数据库的配置，包括数据名称，数据库用户名密码等配置

   b.指定要生成代码的包名，包括实体类po的包名，mapper的包名等

   c.指定数据库中哪些表需要生成文件

   <?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="mybatis.properties" />-->
       <context id="msqlTables" targetRuntime="MyBatis3">
           <!-- 生成的Java文件的编码 -->
           <property name="javaFileEncoding" value="UTF-8"/>
           <!-- 格式化java代码 -->
           <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
           <!-- 格式化XML代码 -->
           <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
   
           <plugin type="org.mybatis.generator.plugins.SerializablePlugin"></plugin>
   
           <!-- 一定要这枚配置命名规则，否则 EnumSupportPlugin会有问题 -->
           <plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin">
               <property name="searchString" value="Example$"/>
               <property name="replaceString" value="Criteria"/>
           </plugin>
   
           <commentGenerator>
               <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
               <property name="suppressAllComments" value="true"/>
               <property name="suppressDate" value="true"/>
           </commentGenerator>
   
           <jdbcConnection connectionURL="jdbc:mysql://localhost:3306/db1?useUnicode=true&amp;characterEncoding=UTF-8&amp;autoReconnect=true" driverClass="com.mysql.jdbc.Driver" password="root" userId="root" >
               <property name="nullCatalogMeansCurrent" value="true"/>
               <!--设置可以获取tables remarks信息-->
               <property name="useInformationSchema" value="true"/>
               <!--设置可以获取remarks信息-->
               <property name="remarks" value="true"/>
           </jdbcConnection>
   
           <!--java类型处理器 用于处理DB中的类型到Java中的类型，默认使用JavaTypeResolverDefaultImpl-->
           <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
               <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL和NUMERIC类型解析为java.math.BigDecimal -->
               <property name="forceBigDecimals" value="true" />
           </javaTypeResolver>
   
           <!-- targetPackage：生成的类要放的包，真实的包受enableSubPackages属性控制； targetProject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，MBG不会自动建目录 -->
           <javaModelGenerator targetPackage="com.unfair.db.model" targetProject="src/main/java">
               <!-- for MyBatis3/MyBatis3Simple 自动为每一个生成的类创建一个构造方法，构造方法包含了所有的field；而不是使用setter； -->
               <property name="constructorBased" value="false"/>
               <!-- enableSubPackages:是否让schema作为包的后缀 -->
               <property name="enableSubPackages" value="false"/>
               <!-- 从数据库返回的值被清理前后的空格 -->
               <property name="trimStrings" value="true" />
           </javaModelGenerator>
   
           <!-- targetProject:mapper映射文件生成的位置，重要！！ -->
           <sqlMapGenerator targetPackage="com.unfair.db.mapper" targetProject="src/main/java">
               <property name="enableSubPackages" value="false"/>
           </sqlMapGenerator>
   
           <!-- targetPackage：mapper接口生成的位置，重要！！ -->
           <javaClientGenerator type="XMLMAPPER" targetPackage="com.unfair.db.dao" targetProject="src/main/java">
               <!-- enableSubPackages:是否让schema作为包的后缀 -->
               <property name="enableSubPackages" value="false"/>
           </javaClientGenerator>
   
           <!-- 指定数据库表，要生成哪些表，就写哪些表，要和数据库中对应，不能写错！ -->
           <table tableName="usr" domainObjectName="User" enableCountByExample="true" enableUpdateByExample="true" enableDeleteByExample="true" enableSelectByExample="true" selectByExampleQueryId="true" >
               <!-- useActualColumnNames用于指定生成实体类时是否使用实际的列名作为实体类的属性名。取值true或false: true : MyBatis Generator会使用数据库中实际的字段名字作为生成的实体类的属性名。 false : 这是默认值。如果设置为false,则MyBatis Generator会将数据库中实际的字段名字转换为Camel Case风格作为生成的实体类的属性名。 如果明确的使用columnOverride元素指定了字段对应的实体的属性名,那么useActualColumnNames会被忽略。 -->
               <property name="useActualColumnNames" value="false"/>
           </table>
       </context>
   </generatorConfiguration>
   

   3. 自定义生成的文件名字

      含义
      
      	把 MyBatisGenerator  生成的 dao、model、mapper的文件 的后缀名进行更改
      	比如 ， dao文件 “BrandMapper.java”  改成  “BrandDao.java”
      
      配置内容
      
      	<!-- 此处是将Example改名为Criteria 当然 想改成什么都行~    -->      
      	<plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin">  
      			<property name="searchString" value="Example$" />
      			<!-- 替换后<property name="replaceString" value="Criteria" />-->
      			<property name="replaceString" value="Query" />
      	</plugin>  
      			
      	<!-- 此处是将UserMapper.xml改名为UserDao.xml 当然 想改成什么都行~ -->        
      	<plugin type="org.mybatis.generator.plugins.rename.RenameSqlMapperPlugin">  
      			 <property name="searchString" value="Mapper" />
      			 <property name="replaceString" value="Dao" />
      	</plugin>  
      			 
      	<!-- 此处是将UserMapper改名为UserDao 接口 当然 想改成什么都行~  -->        
      	<plugin type="org.mybatis.generator.plugins.rename.RenameJavaMapperPlugin">  
      			 <property name="searchString" value="Mapper$" />
      			 <property name="replaceString" value="Dao" />
      	</plugin>
      
      注意点
      
      	RenameExampleClassPlugin、RenameSqlMapperPlugin、RenameJavaMapperPlugin
      
      	这三个插件中 RenameExampleClassPlugin这个插件是  org.mybatis.generator 自带的 ，
      
      	其他两个（RenameSqlMapperPlugin、RenameJavaMapperPlugin） 
      
      	得根据 “RenameExampleClassPlugin” 这个例子自己写一下 ， 
      
      	放到“src\main\java” 目录下。				
      

   4. 执行generatorConfig.xml文件，生成代码

      方式
      
      　　【方式一】java代码
      
      　　【方式二】安装插件	
      
      注意点
      
      	使用逆向工程时，最好新建一个工程，如果你在原来的工程中使用，那也可以，
      
      	但是有一定的风险，因为mybatis是根据配置文件中配置的路径来生成的文件的，
      
      	如果你工程中有相同名字的文件，那么就会被新生成的文件所覆盖。所以实际开发中，
      
      	我们一般新建一个工程，将生成的文件复制到自己的所需的工程中。			
      

      1. 【方式一】java代码

         package com.etc.test;
         
         import org.mybatis.generator.api.MyBatisGenerator;
         import org.mybatis.generator.config.Configuration;
         import org.mybatis.generator.config.xml.ConfigurationParser;
         import org.mybatis.generator.internal.DefaultShellCallback;
         
         import java.io.File;
         import java.util.ArrayList;
         import java.util.List;
         
         public class GeneratorTest { 
                  
             public void testGenerator() throws Exception { 
                  
                 List<String> warnings = new ArrayList<>();
                 boolean overwrite = true;
                 //指定逆向工程配置文件
                 File configFile = new File(GeneratorTest.class.getResource("/generatorConfig.xml").getFile());
                 ConfigurationParser cp = new ConfigurationParser(warnings);
                 Configuration config = cp.parseConfiguration(configFile);
                 DefaultShellCallback callback = new DefaultShellCallback(overwrite);
                 MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,callback,warnings);
                 myBatisGenerator.generate(null);
             }
         
             public static void main(String[] args) throws Exception { 
                  
                 GeneratorTest generator = new GeneratorTest();
                 generator.testGenerator();
             }
         }	
         

         

      2. 【方式二】安装插件

         <build>
         	<plugins>
               <!-- 自动生成mybatis配置文件 -->
               <plugin>
                 <groupId>org.mybatis.generator</groupId>
                 <artifactId>mybatis-generator-maven-plugin</artifactId>
                 <version>1.3.2</version>
                 <dependencies>
                   <dependency>
                     <groupId>mysql</groupId>
                     <artifactId>mysql-connector-java</artifactId>
                     <version>${ 
                  mysql.version}</version>
                   </dependency>
                   <dependency>
                     <groupId>org.slf4j</groupId>
                     <artifactId>log4j-over-slf4j</artifactId>
                     <version>1.7.25</version>
                     <exclusions>
                       <exclusion>
                         <groupId>org.slf4j</groupId>
                         <artifactId>slf4j-api</artifactId>
                       </exclusion>
                     </exclusions>
                   </dependency>
                 </dependencies>
                 <configuration>
                   <configurationFile>${ 
                  basedir}/src/generate/generatorConfig.xml</configurationFile>
                   <verbose>true</verbose>
                   <overwrite>true</overwrite>
                 </configuration>
               </plugin>
         	</plugins>
         </build>
         

         	点击菜单run中Configurations(图)
         
         	点击加号，并选择maven(图)
         
         	在name和Commond line分别填上如上图所示，apply和ok(图)
         
         	点击如下运行(图)
         	
         	生成示例(图)	
         

         
         

3. XxxExample类的使用

   1. 含义

      mybatis的逆向工程中会生成实例及实例对应的example，
      
      这个类是专门用来对单表查询的类，即该类相当where后面的部分 
      
      对该单表的CURD操作是脱离sql性质的
      
      (已经通过逆向工程生成相应的sql)，直接在service层就可以完成相应操作。
      
       逆向工程生成的文件XxxExample.java中包含一个static 的内部类 Criteria ，
      
      在Criteria中有很多方法，主要是定义SQL 语句where后的查询条件。
      

      
      注意 : 图片中userCriteria未进行自定义名称前，名称是userExample

   2. 三个成员变量

      (打开一个Example类我们会看到该类的三个成员变量)
      
      orderByClause		字段用于指定ORDER BY条件,这个条件没有构造方法,直接通过传递字符串值指定。
      
      distinct			字段用于指定DISTINCT查询。
      	
      oredCriteria		字段用于自定义查询条件。	
      
      赋值=======
      
      new xxxExample().setOrderByClause(“字段名 ASC”);		添加升序排列条件，DESC为降序
      
      new xxxExample().setDistinct(false);				去除重复，boolean型，true为选择不重复的记录。			
      

   3. 内部类Criteria

      含义
      
      	在mybatis逆向工程生成的XxxExample中，包含一个static的内部类Criteria，，
      
      	Criteria中的方法是定义SQL 语句where后的查询条件。
      
      创建
      
      	Criteria criteria = new xxxExample().createCriteria();
      
      方法
      
      	criteria.andXxxIsNull				添加字段xxx为null的条件	
      
      	criteria.andXxxIsNotNull			添加字段xxx不为null的条件
      
      	criteria.andXxxEqualTo(value)		添加xxx字段等于value条件
      
      	criteria.andXxxNotEqualTo(value)	添加xxx字段不等于value条件
      
      	criteria.andXxxGreaterThan(value)	添加xxx字段大于value条件
      
      	criteria.andXxxGreaterThanOrEqualTo(value)
      										添加xxx字段大于等于value条件
      
      	criteria.andXxxLessThan(value)		添加xxx字段小于value条件
      
      	criteria.andXxxLessThanOrEqualTo(value)	
      										添加xxx字段小于等于value条件
      
      	criteria.andXxxIn(List<？>) 		添加xxx字段值在List<？>条件
      
      	criteria.andXxxNotIn(List<？>) 		添加xxx字段值不在List<？>条件
      
      	criteria.andXxxLike(“%”+value+”%”) 
      										添加xxx字段值为value的模糊查询条件
      
      	criteria.andXxxNotLike(“%”+value+”%”) 	
      										添加xxx字段值不为value的模糊查询条件
      
      	criteria.andXxxBetween(value1,value2) 	
      										添加xxx字段值在value1和value2之间条件
      
      	criteria.andXxxNotBetween(value1,value2) 	
      										添加xxx字段值不在value1和value2之间条件
      

   4. mapper接口方法

      int countByExample(UserExample example) 		按条件计数
      
      int deleteByPrimaryKey(Integer id)  			按主键删除
      
      int deleteByExample(UserExample example) 		按条件查询
      																										
      String/Integer insert(User record) 				插入数据（返回值为ID）
      
      User selectByPrimaryKey(Integer id)				按主键查询
      																										
      List selectByExample(UserExample example) 		按条件查询
      
      List selectByExampleWithBLOGs(UserExample example) 
      												按条件查询（包括BLOB字段）。只有当数据表中的字段类型有为二进制的才会产生。
      												
      int updateByPrimaryKey(User record)	 			按主键更新
      
      int updateByPrimaryKeySelective(User record)  	按主键更新值不为null的字段
      
      int updateByExample(User record, UserExample example)
      												按条件更新
      												
      int updateByExampleSelective(User record, UserExample example) 
      												按条件更新值不为null的字段
      

   5. 应用示例

      根据主键查询:
      
      		selectByPrimaryKey()
      
      示例
      
      		XxxMapper.selectByPrimaryKey(100);	
      
      		//相当于select * from user where id = 100
      

      根据where后条件查询
      
      	selectByExample()
      
      示例
      
      	UserCriteria criteria = new UserCriteria();
      
      	criteria.createCriteria().andUsernameEqualTo("wyw")..andUsernameIsNull();
      
      	criteria.setOrderByClause("username asc,email desc");
      
      	List<?>list = XxxMapper.selectByExample(criteria);
      
      	//相当于：select * from user where username = 'wyw' and username is null order by username asc,email desc
      

      createCriteria()，创建查询条件

      插入
      
      	insert()
      
      示例
      
      	User user = new User();
      	user.setId("dsfgsdfgdsfgds");
      	user.setUsername("admin");
      	user.setPassword("admin")
      	user.setEmail("wyw@163.com");
      	XxxMapper.insert(user);
      	//相当于：insert into user(ID,username,password,email) values ('dsfgsdfgdsfgds','admin','admin','wyw@126.com');
      
      

      更新数据
      
      	updateByPrimaryKey()
      
      示例1
      	
      	User user =new User();
      	user.setId("dsfgsdfgdsfgds");
      	user.setUsername("wyw");
      	user.setPassword("wyw");
      	user.setEmail("wyw@163.com");
      	XxxMapper.updateByPrimaryKey(user);
      	//相当于：update user set username='wyw', password='wyw', email='wyw@163.com' where id='dsfgsdfgdsfgds' 
      
      示例2
      
      	User user = new User();
      	user.setId("dsfgsdfgdsfgds");
      	user.setPassword("wyw");
      	XxxMapper.updateByPrimaryKey(user);
      	//相当于：update user set password='wyw' where id='dsfgsdfgdsfgds' 
      

      复杂更新
      
      	updateByPrimaryKeySelective()
      
      示例
      
      	UserCriteria criteria = new UserCriteria();
      	criteria .createCriteria().andUsernameEqualTo("admin")；
      	
      	User user = new User();
      	user.setPassword("wyw");
      	
      	XxxMapper.updateByPrimaryKeySelective(user,example);
      	//相当于：update user set password='wyw' where username='admin' 
      

4. 总结

   mybatis的逆向工程实现起来其实是非常简单的，但是在不同情况下，要特别注意文件路径的问题。
   
   其中，XxxExample.java只能实现简单条件增删改查，复杂的功能还需要自己编写sql代码来实现。
   
   注意，在配置文件中配置对应生成文件的所在目录时，最好使用绝对路径
   
   （若不是用maven聚合搭建的项目则不用修改）	
   

5. 完整配置

   	<?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>
   	    <!-- 可以用于加载配置项或者配置文件，在整个配置文件中就可以使用${ 
        propertyKey}的方式来引用配置项
   	        resource：配置资源加载地址，使用resource，MBG从classpath开始找，比如com/myproject/generatorConfig.properties
   	        url：配置资源加载地质，使用URL的方式，比如file:///C:/myfolder/generatorConfig.properties.
   	        注意，两个属性只能选址一个;
   	 
   	        另外，如果使用了mybatis-generator-maven-plugin，那么在pom.xml中定义的properties都可以直接在generatorConfig.xml中使用
   	    <properties resource="" url="" />
   	     -->
   	 
   	    <!-- 在MBG工作的时候，需要额外加载的依赖包
   	       location属性指明加载jar/zip包的全路径
   	   <classPathEntry location="/Program Files/IBM/SQLLIB/java/db2java.zip" />
   	     -->
   	 
   	    <!--
   	        context:生成一组对象的环境
   	        id:必选，上下文id，用于在生成错误时提示
   	        defaultModelType:指定生成对象的样式
   	            1，conditional：类似hierarchical；
   	            2，flat：所有内容（主键，blob）等全部生成在一个对象中；
   	            3，hierarchical：主键生成一个XXKey对象(key class)，Blob等单独生成一个对象，其他简单属性在一个对象中(record class)
   	        targetRuntime:
   	            1，MyBatis3：默认的值，生成基于MyBatis3.x以上版本的内容，包括XXXBySample；
   	            2，MyBatis3Simple：类似MyBatis3，只是不生成XXXBySample；
   	        introspectedColumnImpl：类全限定名，用于扩展MBG
   	    -->
   	    <context id="mysql" defaultModelType="hierarchical" targetRuntime="MyBatis3Simple" >
   	 
   	        <!-- 自动识别数据库关键字，默认false，如果设置为true，根据SqlReservedWords中定义的关键字列表；
   	            一般保留默认值，遇到数据库关键字（Java关键字），使用columnOverride覆盖
   	         -->
   	        <property name="autoDelimitKeywords" value="false"/>
   	        <!-- 生成的Java文件的编码 -->
   	        <property name="javaFileEncoding" value="UTF-8"/>
   	        <!-- 格式化java代码 -->
   	        <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
   	        <!-- 格式化XML代码 -->
   	        <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
   	 
   	        <!-- beginningDelimiter和endingDelimiter：指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； -->
   	        <property name="beginningDelimiter" value="`"/>
   	        <property name="endingDelimiter" value="`"/>
   	 
   	        <!-- 必须要有的，使用这个配置链接数据库
   	            @TODO:是否可以扩展
   	         -->
   	        <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql:///pss" userId="root" password="admin">
   	            <!-- 这里面可以设置property属性，每一个property属性都设置到配置的Driver上 -->
   	        </jdbcConnection>
   	 
   	        <!-- java类型处理器
   	            用于处理DB中的类型到Java中的类型，默认使用JavaTypeResolverDefaultImpl；
   	            注意一点，默认会先尝试使用Integer，Long，Short等来对应DECIMAL和 NUMERIC数据类型；
   	        -->
   	        <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
   	            <!--
   	                true：使用BigDecimal对应DECIMAL和 NUMERIC数据类型
   	                false：默认,
   	                    scale>0;length>18：使用BigDecimal;
   	                    scale=0;length[10,18]：使用Long；
   	                    scale=0;length[5,9]：使用Integer；
   	                    scale=0;length<5：使用Short；
   	             -->
   	            <property name="forceBigDecimals" value="false"/>
   	        </javaTypeResolver>
   	 
   	 
   	        <!-- java模型创建器，是必须要的元素
   	            负责：1，key类（见context的defaultModelType）；2，java类；3，查询类
   	            targetPackage：生成的类要放的包，真实的包受enableSubPackages属性控制；
   	            targetProject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，MBG不会自动建目录
   	         -->
   	        <javaModelGenerator targetPackage="com._520it.mybatis.domain" targetProject="src/main/java">
   	            <!--  for MyBatis3/MyBatis3Simple
   	                自动为每一个生成的类创建一个构造方法，构造方法包含了所有的field；而不是使用setter；
   	             -->
   	            <property name="constructorBased" value="false"/>
   	 
   	            <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
   	            <property name="enableSubPackages" value="true"/>
   	 
   	            <!-- for MyBatis3 / MyBatis3Simple
   	                是否创建一个不可变的类，如果为true，
   	                那么MBG会创建一个没有setter方法的类，取而代之的是类似constructorBased的类
   	             -->
   	            <property name="immutable" value="false"/>
   	 
   	            <!-- 设置一个根对象，
   	                如果设置了这个根对象，那么生成的keyClass或者recordClass会继承这个类；在Table的rootClass属性中可以覆盖该选项
   	                注意：如果在key class或者record class中有root class相同的属性，MBG就不会重新生成这些属性了，包括：
   	                    1，属性名相同，类型相同，有相同的getter/setter方法；
   	             -->
   	            <property name="rootClass" value="com._520it.mybatis.domain.BaseDomain"/>
   	 
   	            <!-- 设置是否在getter方法中，对String类型字段调用trim()方法 -->
   	            <property name="trimStrings" value="true"/>
   	        </javaModelGenerator>
   	 
   	 
   	        <!-- 生成SQL map的XML文件生成器，
   	            注意，在Mybatis3之后，我们可以使用mapper.xml文件+Mapper接口（或者不用mapper接口），
   	                或者只使用Mapper接口+Annotation，所以，如果 javaClientGenerator配置中配置了需要生成XML的话，这个元素就必须配置
   	            targetPackage/targetProject:同javaModelGenerator
   	         -->
   	        <sqlMapGenerator targetPackage="com._520it.mybatis.mapper" targetProject="src/main/resources">
   	            <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
   	            <property name="enableSubPackages" value="true"/>
   	        </sqlMapGenerator>
   	 
   	 
   	        <!-- 对于mybatis来说，即生成Mapper接口，注意，如果没有配置该元素，那么默认不会生成Mapper接口
   	            targetPackage/targetProject:同javaModelGenerator
   	            type：选择怎么生成mapper接口（在MyBatis3/MyBatis3Simple下）：
   	                1，ANNOTATEDMAPPER：会生成使用Mapper接口+Annotation的方式创建（SQL生成在annotation中），不会生成对应的XML；
   	                2，MIXEDMAPPER：使用混合配置，会生成Mapper接口，并适当添加合适的Annotation，但是XML会生成在XML中；
   	                3，XMLMAPPER：会生成Mapper接口，接口完全依赖XML；
   	            注意，如果context是MyBatis3Simple：只支持ANNOTATEDMAPPER和XMLMAPPER
   	        -->
   	        <javaClientGenerator targetPackage="com._520it.mybatis.mapper" type="ANNOTATEDMAPPER" targetProject="src/main/java">
   	            <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
   	            <property name="enableSubPackages" value="true"/>
   	 
   	            <!-- 可以为所有生成的接口添加一个父接口，但是MBG只负责生成，不负责检查
   	            <property name="rootInterface" value=""/>
   	             -->
   	        </javaClientGenerator>
   	 
   	        <!-- 选择一个table来生成相关文件，可以有一个或多个table，必须要有table元素
   	            选择的table会生成一下文件：
   	            1，SQL map文件
   	            2，生成一个主键类；
   	            3，除了BLOB和主键的其他字段的类；
   	            4，包含BLOB的类；
   	            5，一个用户生成动态查询的条件类（selectByExample, deleteByExample），可选；
   	            6，Mapper接口（可选）
   	 
   	            tableName（必要）：要生成对象的表名；
   	            注意：大小写敏感问题。正常情况下，MBG会自动的去识别数据库标识符的大小写敏感度，在一般情况下，MBG会
   	                根据设置的schema，catalog或tablename去查询数据表，按照下面的流程：
   	                1，如果schema，catalog或tablename中有空格，那么设置的是什么格式，就精确的使用指定的大小写格式去查询；
   	                2，否则，如果数据库的标识符使用大写的，那么MBG自动把表名变成大写再查找；
   	                3，否则，如果数据库的标识符使用小写的，那么MBG自动把表名变成小写再查找；
   	                4，否则，使用指定的大小写格式查询；
   	            另外的，如果在创建表的时候，使用的""把数据库对象规定大小写，就算数据库标识符是使用的大写，在这种情况下也会使用给定的大小写来创建表名；
   	            这个时候，请设置delimitIdentifiers="true"即可保留大小写格式；
   	 
   	            可选：
   	            1，schema：数据库的schema；
   	            2，catalog：数据库的catalog；
   	            3，alias：为数据表设置的别名，如果设置了alias，那么生成的所有的SELECT SQL语句中，列名会变成：alias_actualColumnName
   	            4，domainObjectName：生成的domain类的名字，如果不设置，直接使用表名作为domain类的名字；可以设置为somepck.domainName，那么会自动把domainName类再放到somepck包里面；
   	            5，enableInsert（默认true）：指定是否生成insert语句；
   	            6，enableSelectByPrimaryKey（默认true）：指定是否生成按照主键查询对象的语句（就是getById或get）；
   	            7，enableSelectByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询语句；
   	            8，enableUpdateByPrimaryKey（默认true）：指定是否生成按照主键修改对象的语句（即update)；
   	            9，enableDeleteByPrimaryKey（默认true）：指定是否生成按照主键删除对象的语句（即delete）；
   	            10，enableDeleteByExample（默认true）：MyBatis3Simple为false，指定是否生成动态删除语句；
   	            11，enableCountByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询总条数语句（用于分页的总条数查询）；
   	            12，enableUpdateByExample（默认true）：MyBatis3Simple为false，指定是否生成动态修改语句（只修改对象中不为空的属性）；
   	            13，modelType：参考context元素的defaultModelType，相当于覆盖；
   	            14，delimitIdentifiers：参考tableName的解释，注意，默认的delimitIdentifiers是双引号，如果类似MYSQL这样的数据库，使用的是`（反引号，那么还需要设置context的beginningDelimiter和endingDelimiter属性）
   	            15，delimitAllColumns：设置是否所有生成的SQL中的列名都使用标识符引起来。默认为false，delimitIdentifiers参考context的属性
   	 
   	            注意，table里面很多参数都是对javaModelGenerator，context等元素的默认属性的一个复写；
   	         -->
   	        <table tableName="userinfo" >
   	 
   	            <!-- 参考 javaModelGenerator 的 constructorBased属性-->
   	            <property name="constructorBased" value="false"/>
   	 
   	            <!-- 默认为false，如果设置为true，在生成的SQL中，table名字不会加上catalog或schema； -->
   	            <property name="ignoreQualifiersAtRuntime" value="false"/>
   	 
   	            <!-- 参考 javaModelGenerator 的 immutable 属性 -->
   	            <property name="immutable" value="false"/>
   	 
   	            <!-- 指定是否只生成domain类，如果设置为true，只生成domain类，如果还配置了sqlMapGenerator，那么在mapper XML文件中，只生成resultMap元素 -->
   	            <property name="modelOnly" value="false"/>
   	 
   	            <!-- 参考 javaModelGenerator 的 rootClass 属性
   	            <property name="rootClass" value=""/>
   	             -->
   	 
   	            <!-- 参考javaClientGenerator 的  rootInterface 属性
   	            <property name="rootInterface" value=""/>
   	            -->
   	 
   	            <!-- 如果设置了runtimeCatalog，那么在生成的SQL中，使用该指定的catalog，而不是table元素上的catalog
   	            <property name="runtimeCatalog" value=""/>
   	            -->
   	 
   	            <!-- 如果设置了runtimeSchema，那么在生成的SQL中，使用该指定的schema，而不是table元素上的schema
   	            <property name="runtimeSchema" value=""/>
   	            -->
   	 
   	            <!-- 如果设置了runtimeTableName，那么在生成的SQL中，使用该指定的tablename，而不是table元素上的tablename
   	            <property name="runtimeTableName" value=""/>
   	            -->
   	 
   	            <!-- 注意，该属性只针对MyBatis3Simple有用；
   	                如果选择的runtime是MyBatis3Simple，那么会生成一个SelectAll方法，如果指定了selectAllOrderByClause，那么会在该SQL中添加指定的这个order条件；
   	             -->
   	            <property name="selectAllOrderByClause" value="age desc,username asc"/>
   	 
   	            <!-- 如果设置为true，生成的model类会直接使用column本身的名字，而不会再使用驼峰命名方法，比如BORN_DATE，生成的属性名字就是BORN_DATE,而不会是bornDate -->
   	            <property name="useActualColumnNames" value="false"/>
   	 
   	 
   	            <!-- generatedKey用于生成生成主键的方法，
   	                如果设置了该元素，MBG会在生成的<insert>元素中生成一条正确的<selectKey>元素，该元素可选
   	                column:主键的列名；
   	                sqlStatement：要生成的selectKey语句，有以下可选项：
   	                    Cloudscape:相当于selectKey的SQL为： VALUES IDENTITY_VAL_LOCAL()
   	                    DB2       :相当于selectKey的SQL为： VALUES IDENTITY_VAL_LOCAL()
   	                    DB2_MF    :相当于selectKey的SQL为：SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1
   	                    Derby     :相当于selectKey的SQL为：VALUES IDENTITY_VAL_LOCAL()
   	                    HSQLDB    :相当于selectKey的SQL为：CALL IDENTITY()
   	                    Informix  :相当于selectKey的SQL为：select dbinfo('sqlca.sqlerrd1') from systables where tabid=1
   	                    MySql     :相当于selectKey的SQL为：SELECT LAST_INSERT_ID()
   	                    SqlServer :相当于selectKey的SQL为：SELECT SCOPE_IDENTITY()
   	                    SYBASE    :相当于selectKey的SQL为：SELECT @@IDENTITY
   	                    JDBC      :相当于在生成的insert元素上添加useGeneratedKeys="true"和keyProperty属性
   	            <generatedKey column="" sqlStatement=""/>
   	             -->
   	 
   	            <!--
   	                该元素会在根据表中列名计算对象属性名之前先重命名列名，非常适合用于表中的列都有公用的前缀字符串的时候，
   	                比如列名为：CUST_ID,CUST_NAME,CUST_EMAIL,CUST_ADDRESS等；
   	                那么就可以设置searchString为"^CUST_"，并使用空白替换，那么生成的Customer对象中的属性名称就不是
   	                custId,custName等，而是先被替换为ID,NAME,EMAIL,然后变成属性：id，name，email；
   	 
   	                注意，MBG是使用java.util.regex.Matcher.replaceAll来替换searchString和replaceString的，
   	                如果使用了columnOverride元素，该属性无效；
   	 
   	            <columnRenamingRule searchString="" replaceString=""/>
   	             -->
   	 
   	 
   	            <!-- 用来修改表中某个列的属性，MBG会使用修改后的列来生成domain的属性；
   	               column:要重新设置的列名；
   	               注意，一个table元素中可以有多个columnOverride元素哈~
   	             -->
   	            <columnOverride column="username">
   	                <!-- 使用property属性来指定列要生成的属性名称 -->
   	                <property name="property" value="userName"/>
   	 
   	                <!-- javaType用于指定生成的domain的属性类型，使用类型的全限定名
   	                <property name="javaType" value=""/>
   	                 -->
   	 
   	                <!-- jdbcType用于指定该列的JDBC类型
   	                <property name="jdbcType" value=""/>
   	                 -->
   	 
   	                <!-- typeHandler 用于指定该列使用到的TypeHandler，如果要指定，配置类型处理器的全限定名
   	                    注意，mybatis中，不会生成到mybatis-config.xml中的typeHandler
   	                    只会生成类似：where id = #{ 
        id,jdbcType=BIGINT,typeHandler=com._520it.mybatis.MyTypeHandler}的参数描述
   	                <property name="jdbcType" value=""/>
   	                -->
   	 
   	                <!-- 参考table元素的delimitAllColumns配置，默认为false
   	                <property name="delimitedColumnName" value=""/>
   	                 -->
   	            </columnOverride>
   	 
   	            <!-- ignoreColumn设置一个MGB忽略的列，如果设置了改列，那么在生成的domain中，生成的SQL中，都不会有该列出现
   	               column:指定要忽略的列的名字；
   	               delimitedColumnName：参考table元素的delimitAllColumns配置，默认为false
   	 
   	               注意，一个table元素中可以有多个ignoreColumn元素
   	            <ignoreColumn column="deptId" delimitedColumnName=""/>
   	            -->
   	        </table>
   	 
   	    </context>
   	 
   	</generatorConfiguration>
   

mybatis缓存

须知

	缓存
	
		1.存在内存中的临时数据
	
		2.将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)

		  查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题

	优点

		减少和数据库的交互次数，减少系统开销，提高系统效率

	使用前提

		经常查询并且不经常改变的数据

	mybatis缓存

		mybatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升

		查询效率。

		mybatis系统中默认定义了两级缓存：一级缓存和二级缓存。

		-默认情况下，只有一级缓存开启(sqlSession级别的缓存，也称为本地缓存)

		-二级缓存需要手动开启和配置，它是基于namespace级别的缓存。

		-为了提高扩展性，Mybatis定义了缓存接口Cache。操作者可以通过实现Cache接口来自定义二级缓存

	一级缓存

		含义

			一级缓存也叫本地缓存:

		内容

			与数据库同一次会话期间查询到的数据会放在本地缓存中

			以后如果需要获取相同的数据，直接从换缓存中拿，没必须再去查询数据库