java_spring07mybatis学习要点

<?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>  
    <typeAliases><!--别名-->  
        <typeAliases alias="user" type="com.mybatis.po.User"/>  
    </typeAliases>  
    <!-- 数据库环境 -->  
    <environments default="development">  
        <environment id="development">  
            <!-- 使用JDBC的事务管理 -->  
            <transactionManager type="JDBC" />  
            <dataSource type="POOLED">  
                <!-- MySQL数据库驱动 -->  
                <property name="driver" value="com.mysql.jdbc.Driver" />  
                <!-- 连接数据库的URL -->  
                <property name="url"  
                    value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />  
                <property name="username" value="root" />  
                <property name="password" value="1128" />  
            </dataSource>  
        </environment>  
    </environments>  
    <!-- 将mapper文件加入到配置文件中 -->  
    <mappers>  
        <mapper resource="com/mybatis/mapper/UserMapper.xml" />  
    </mappers>  
</configuration>

SqlSessionFactory factory = null;  
String resource = "mybatis-config.xml";  
InputStream is;  
try {  
    InputStream is = Resources.getResourceAsStream(resource);  
    factory = new SqlSessionFactoryBuilder().build(is);  
} catch (IOException e) {  
    e.printStackTrace();  
}

//定义 SqlSession  
SqlSession sqlSession = null;  
try {  
    // 打开 SqlSession 会话  
    sqlSession = SqlSessionFactory.openSession();  
    // some code...  
    sqlSession.commit();    // 提交事务  
} catch (IOException e) {  
    sqlSession.rollback();  // 回滚事务  
}finally{  
    // 在 finally 语句中确保资源被顺利关闭  
    if(sqlSession != null){  
        sqlSession.close();  
    }  
}

<mapper namespace="com.mybatis.mapper.RoleMapper">  
    <select id="getRole" parameterType="long" resultType="role">  
        SELECT id,role_name as roleName,note FROM role WHERE id =#{id}  
    </select>  
</mapper>

<!-- 配置SqlSessionFactoryBean -->  
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
    <!-- 引用数据源组件 -->  
    <property name="dataSource" ref="dataSource" />  
    <!-- 引用MyBatis配置文件中的配置 -->  
    <property name="configLocation" value="classpath:mybatis-config.xml" />  
</bean>

<!-- Mapper代理开发，使用Spring自动扫描MyBatis的接口并装配 （Sprinh将指定包中的所有被@Mapper注解标注的接口自动装配为MyBatis的映射接口） -->  
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
    <!-- mybatis-spring组件的扫描器，com.dao只需要接口（接口方法与SQL映射文件中的相同） -->  
    <property name="basePackage" value="com.dao" />  
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />  
</bean>

public List<MyUser> selectAllUser(Map<String,Object> param);  
<!-- 查询陈姓男性用户信息 -->  
<select id="selectAllUser" resultType="com.mybatis.po.MyUser">  
    select * from user  
    where uname like concat('%',#{u_name},'%')  
    and usex = #{u_sex}  
</select>  
  
<select id="selectAllUser" resultType="com.po.MyUser" parameterType="com.pojo.SeletUserParam">  
    select * from user  
    where uname like concat('%',#{u_name},'%')  
    and usex=#{u_sex}  
</select>

<!--添加一个用户，成功后将主键值返回填给uid(po的属性)-->  
<insert id="addUser" parameterType="com.po.MyUser" keyProperty="uid" useGeneratedKeys="true">  
    insert into user (uname,usex) values(#{uname},#{usex})  
</insert>

<!-- 添加一个用户，#{uname}为 com.mybatis.po.MyUser 的属性值 -->  
<insert id="insertUser" parameterType="com.po.MyUser">  
    <!-- 先使用selectKey元素定义主键，然后再定义SQL语句 -->  
    <selectKey keyProperty="uid" resultType="Integer" order="BEFORE">  
    select if(max(uid) is null,1,max(uid)+1) as newUid from user)  
    </selectKey>  
    insert into user (uid,uname,usex) values(#{uid},#{uname},#{usex})  
</insert>

<sql id="comColumns">id,uname,usex</sql>  
<select id="selectUser" resultType="com.po.MyUser">  
    select <include refid="comColumns"> from user  
</select>

<!-- 查询所有用户信息存到Map中 -->  
<select id="selectAllUserMap" resultType="map">  
    select * from user  
</select>

<!--使用自定义结果集类型-->  
<resultMap type="com.pojo.MapUser" id="myResult">  
    <!-- property 是 com.pojo.MapUser 类中的属性-->  
    <!-- column是查询结果的列名，可以来自不同的表-->  
    <id property="m_uid" column="uid"/>  
    <result property="m_uname" column="uname"/>  
    <result property="m_usex" column="usex"/>  
</resultMap>

<!-- 使用自定义结果集类型查询所有用户 -->  
<select id="selectResultMap" resultMap="myResult">  
    select * from user  
</select>

<!-- 一对一根据id查询个人信息：级联查询的第一种方法（嵌套查询，执行两个SQL语句）-->  
<resultMap type="com.po.Person" id="cardAndPerson1">  
	<id property="id" column="id"/>  
	<result property="name" column="name"/>  
	<result property="age" column="age"/>  
	<!-- 一对一级联查询-->  
	<association property="card" column="idcard_id" javaType="com.po.Idcard"  
	select="com.dao.IdCardDao.selectCodeByld"/>  
</resultMap>

<!-- 一对多 根据uid查询用户及其关联的订单信息：级联查询的第一种方法（嵌套查询） -->  
<resultMap type="com.po.MyUser" id="userAndOrders1">  
    <id property="uid" column="uid" />  
    <result property="uname" column="uname" />  
    <result property="usex" column="usex" />  
    <!-- 一对多级联查询，ofType表示集合中的元素类型，将uid传递给selectOrdersByld -->  
    <collection property="ordersList" ofType="com.po.Orders"  
        column="uid" select="com.dao.OrdersDao.selectOrdersByld" />  
</resultMap>

<!--使用 if 元素根据条件动态查询用户信息-->  
<select id="selectUserByIf" resultType="com.po.MyUser" parameterType="com.po.MyUser">  
    select * from user where 1=1  
    <if test="uname!=null and uname!=''">  
        and uname like concat('%',#{uname},'%')  
    </if >  
    <if test="usex !=null and usex !=''">  
        and usex=#{usex}  
    </if >  
</select>

<!--使用choose、when、otherwise元素根据条件动态查询用户信息-->  
<select id="selectUserByChoose" resultType="com.po.MyUser" parameterType= "com.po.MyUser">  
    select * from user where 1=1  
    <choose>  
        <when test="uname!=null and uname!=''">  
            and uname like concat('%',#{uname},'%')  
        </when>  
        <when test="usex!=null and usex!=''">  
            and usex=#{usex}  
        </when>  
        <otherwise>  
            and uid > 10  
        </otherwise>  
    </choose>  
</select>

<!--使用where元素根据条件动态查询用户信息-->  
<select id="selectUserByWhere" resultType="com.po.MyUser" parameterType="com.po.MyUser">  
    select * from user  
    <where>  
        <if test="uname != null and uname ! = ''">  
            and uname like concat('%',#{uname},'%')  
        </if>  
        <if test="usex != null and usex != '' ">  
            and usex=#{usex}  
        </if >  
    </where>  
</select>

<!--使用set元素动态修改一个用户-->  
<update id="updateUserBySet" parameterType="com.po.MyUser">       
    update user  
    <set>  
        <if test="uname!=null">uname=#{uname}</if>  
        <if test="usex!=null">usex=#{usex}</if>  
    </set>  
    where uid=#{uid}  
</update>

item 表示集合中每一个元素进行迭代时的别名。  
index 指定一个名字，用于表示在迭代过程中每次迭代到的位置。  
open 表示该语句以什么开始。  
separator 表示在每次进行迭代之间以什么符号作为分隔符。  
close 表示以什么结束。

如果传入的是单参数且参数类型是一个 List，collection 属性值为 list。  
如果传入的是单参数且参数类型是一个 array 数组，collection 的属性值为 array。  
如果传入的参数是多个，需要把它们封装成一个 Map，当然单参数也可以封装成 Map。Map 的 key 是参数名，collection 属性值是传入的 List 或 array 对象在自己封装的 Map 中的 key。

<!--使用foreach元素查询用户信息-->  
<select id="selectUserByForeach" resultType="com.po.MyUser" parameterType=  
"List">  
    select * from user where uid in  
    <foreach item="item" index="index" collection="list"  
    open="(" separator="," close=")">  
        # {item}  
    </foreach>  
</select>

select * from table where name like '%${name}%'

<bind name="bindeName" value="'%'+name+'%'"/>  
SELECT * FROM table where name like #{bindeName}

<if test=” userName != null and userName ! = ””>  
　　and username like concat （ '1',#{userName},'2' ）  
</if>

<if test="" userName != null and userName !="">
　　<bind name= "userNameLike" value = "'1'＋ userName ＋ '2'"/>
　　and username like #{userNameLike}
</if>

【添加数据：（增）】
    int insert(T entity);              // 插入一条记录
注：
    T         表示任意实体类型
    entity    表示实体对象

【删除数据：（删）】
    int deleteById(Serializable id);    // 根据主键 ID 删除
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象
注：
    id        表示 主键 ID
    columnMap 表示表字段的 map 对象
    wrapper   表示实体对象封装操作类，可以为 null。
    idList    表示 主键 ID 集合（列表、数组），不能为 null 或 empty

【修改数据：（改）】
    int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象
注：
    update 中的 entity 为 set 条件，可以为 null。
    updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

【查询数据：（查）】
    T selectById(Serializable id); // 根据 主键 ID 查询数据
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数


    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合）
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合）
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
    <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页
    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页
注：
    queryWrapper 表示实体对象封装操作类（可以为 null）
    page 表示分页查询条件

【添加数据：（增）】
    default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
    boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据
注：
    entityList 表示实体对象集合 
    batchSize 表示一次批量插入的数据量，默认为 1000

【添加或修改数据：（增或改）】
   boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
   default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
   boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 

【删除数据：（删）】
    default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
    default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
    default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
    default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
    
【修改数据：（改）】
    default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
    default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
    boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据

【查找数据：（查）】
    default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
    default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
    default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
    default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。
    Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。
    default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。
    default List<T> list(); // 返回所有数据。
    default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
    default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
注：
    get 用于返回一条记录。
    list 用于返回多条记录。
    count 用于返回记录总数。
    page 用于分页查询。

【链式调用：】
    default QueryChainWrapper<T> query(); // 普通链式查询
    default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改
    default UpdateChainWrapper<T> update(); // 普通链式修改
    default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改
注：
    query 表示查询
    update 表示修改
    Lambda 表示内部支持 Lambda 写法。
形如：
    query().eq("column", value).one();
    lambdaQuery().eq(Entity::getId, value).list();
    update().eq("column", value).remove();
    lambdaUpdate().eq(Entity::getId, value).update(entity);

汇总为
【添加数据：（增）】
    int insert(T entity);              // 插入一条记录
    boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据

【删除数据：（删）】
    int deleteById(Serializable id);    // 根据主键 ID 删除
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除

【修改数据：（改）】
    int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
    boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象

【添加或修改数据：（增或改）】
   boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
   boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 
   default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作

【查询数据：（查）】
    T selectById(Serializable id); // 根据 主键 ID 查询数据
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
   Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数

增，删，改，查，增或改：单个Id，批次id，条件id，个数查询（仅查询）