Mybatis学习笔记

叁歲伎倆 2022-05-27 00:39 314阅读 0赞

学习了Mybatis。相对于hibernate来说这个框架更加灵活，开发效率更快，适用于那些改动比较频繁的项目。

首先加入mybatis的配置文件myBatisConfig.xml 这个配置文件的名字随意 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <settings>
  7. <!--         懒加载开启 -->
  8.         <setting name="lazyLoadingEnabled" value="true"/>
  9. <!--         为真，直接查询关联数据，为假按需查询 -->
  10.         <setting name="aggressiveLazyLoading" value="false"/>
  11. <!--         开启二级缓存 -->
  12.         <setting name="cacheEnabled" value="true"/>
  13.     </settings>
  14. <!--     配置数据库连接信息 -->
  15.     <properties resource="db.properties"/>
  17.     <!--     别名定义 ，一定要放在environments标签前面-->
  18.     <typeAliases>
  19. <!--         单个类别名定义 -->
  20. <!--         <typeAlias type="com.samrtian.entity.User" alias="User"/> -->
  21. <!--         批量，扫描整个包别名定义，名字就是类名 -->
  22.         <package name="com.samrtian.entity"/>
  23.     </typeAliases>
  25. <!--     连接信息 -->
  26.     <environments default="development">
  27.         <environment id="development">
  28.             <transactionManager type="JDBC"/>
  29.             <dataSource type="POOLED">
  30.               <property name="driver" value="${jdbc.driver}"/>
  31.               <property name="url" value="${jdbc.connect}"/>
  32.               <property name="username" value="${jdbc.username}"/>
  33.               <property name="password" value="${jdbc.password}"/>
  34.             </dataSource>
  35.         </environment>
  36.     </environments>
  38.     <mappers>
  39. <!--     映射文件 -->
  40.         <mapper resource="sqlMap/User.xml"/>
  41. <!--     代理方法映射文件 -->
  42. <!--         <mapper resource="com/samrtian/mapper/UserMapper.xml"/> -->
  43. <!--     通过代理接口映射文件XML和类名必须一致且在同一个目录内 -->
  44. <!--         <mapper class="com.samrtian.mapper.UserMapper"/> -->
  45. <!--     通过包名批量加载代理接口映射文件 -->
  46.         <package name="com.samrtian.mapper"/>
  47.     </mappers>
  50. </configuration>

下边是db.properties的数据库配置文件

  1. jdbc.driver=com.mysql.cj.jdbc.Driver
  2. jdbc.connect=jdbc:mysql://localhost:3306/bls?serverTimezone=GMT
  3. jdbc.username=root
  4. jdbc.password=ytfmnm

然后是加入映射文件我们下边用的事mapper的代理方法，这样方便快捷

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper  
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  6. <!-- 这里的namespace是对应的代理类名 -->
  7. <mapper namespace="com.samrtian.mapper.UserMapper">
  8. <!--     让这个mapper启用二级缓存, 并且把相关的实体类实现序列化     -->
  9. <!--     <cache type="使用哪些二级缓存类"/> -->
  11.     <select id="findByUserID" parameterType="java.lang.Integer" resultType="com.samrtian.entity.User">
  12.         select * from t_user where id = #{id}
  13.     </select>
  15.     <select id="findByUserName" parameterType="java.lang.String" resultType="com.samrtian.entity.User">
  16.         select * from t_user where name = #{value} 
  17.     </select>
  19.     <select id="findLikeUserName" parameterType="java.lang.String" resultType="com.samrtian.entity.User">
  20.         select * from t_user where name like '%${value}%' 
  21.     </select>
  23.     <delete id="deleteUser" parameterType="java.lang.Integer">
  24.         delete from t_user where id = #{id}
  25.     </delete>
  27.     <update id="updateUser" parameterType="User">
  28.         update t_user set name = #{name}, password = #{password} where id = #{id}
  29.     </update>
  31.     <insert id="insertUser" parameterType="com.samrtian.entity.User">
  32. <!--     插入数据后ID自动填充到User里边，因为是先提交插入到数据库里边才生成的ID所以用AFTER -->
  33.         <selectKey keyProperty="id" resultType="java.lang.Integer" order="AFTER">
  34.             select LAST_INSERT_ID()
  35.         </selectKey>
  36.         INSERT into t_user(name, password) VALUES(#{name}, #{password});
  37.     </insert>
  39. <!--     定义一个SQL片段 -->
  40.     <sql id="sql_user_where">
  41.         <if test="user!=null">
  42.             <if test="user.name!=null">
  43.                 and name = #{user.name}
  44.             </if>
  45.              <if test="user.password">
  46.                  and password = #{user.password}
  47.              </if>
  48.         </if>
  49.     </sql>
  50. <!--     多参数的话自定义一个包装类VO，把条件当属性添加进去 , user是CustomVo里边的一个属性-->
  51. <!--     只有当属性成员user和里边的属性值不为空的话才会拼接条件 -->
  52.     <select id="findByUserInfo" parameterType="com.samrtian.po.CustomVo" resultType="User">
  53.         select * from t_user
  54.         <where>
  55. <!--             如果这段查询条件经常用到的话可以定义一个SQL片段，这样的话可以复用 -->
  56. <!--             <if test="user!=null"> -->
  57. <!--                 <if test="user.name!=null"> -->
  58. <!--                     and name = #{user.name} -->
  59. <!--                 </if> -->
  60. <!--                  <if test="user.password"> -->
  61. <!--                      and password = #{user.password} -->
  62. <!--                  </if> -->
  63. <!--             </if> -->
  64.             <include refid="sql_user_where"/>
  65.         </where>  
  66.     </select>
  68. <!--     当查出来的结果集列名与POJO的属性名不一致时可以做一个映射这样就可以查询出来结果集了 -->
  69.     <resultMap type="User" id="UserMap">
  70.         <id column="id_" property="id"/>
  71.         <result column="n_" property="name"/>
  72.         <result column="p_" property="password"/>
  73.     </resultMap>
  74.     <select id="findByidResultMap" parameterType="int" resultMap="UserMap">
  75.         select id id_, name n_, password p_ from t_user where id = #{id}
  76.     </select>
  78. <!--     以列表为参数 -->
  79.     <select id="findByIds" parameterType="list" resultType="User">
  80.         select * from t_user
  81.         <where>
  82.             <if test="list!=null">
  83.                 <foreach collection="list" item="user_id" open="and id in (" close=")" separator=",">
  84.                     #{user_id}
  85.                 </foreach>
  86.             </if>
  87.         </where>
  88.     </select>
  90. <!--     association标签是用来标识一对一的关系映射也可以实现懒加载 -->
  91.     <resultMap type="com.samrtian.po.CustomVo" id="Cv">
  92.             <result column="GroupName" property="groupName"/>    
  93.         <association property="user" javaType="User">
  94.             <id column="id" property="id"/>
  95.             <result column="name" property="name"/>
  96.             <result column="password" property="password"/>
  97.             <result column="groupid" property="groupID"/>
  98.         </association>
  99.     </resultMap>
  100.     <select id="findByidAss" parameterType="int" resultMap="Cv">
  101.         SELECT u.*, g.GroupName FROM t_user u, t_groupwork g 
  102.             WHERE u.groupid = g.GroupID AND u.id = #{id}
  103.     </select>
  105. <!--     collection标签是用来标识一对多关系映射 select是延迟加载-->
  106. <!--     <resultMap type="" id="" extends=""> -->
  107. <!--         <collection property="属性名" ofType="多的那个类型" select="上边的select ID"> -->
  108. <!--             <id/> -->
  109. <!--             <result/> -->
  110. <!--         </collection> -->
  111. <!--     </resultMap> -->
  112. <!--     <select id=""> -->
  113. <!--     </select> -->
  115. <!--     collection标签也可以用来标识多对多关系映射 -->
  116. <!--     <resultMap type="" id="" extends=""> -->
  117. <!--         <collection property="属性名" ofType="多的那个类型"> -->
  118. <!--             <id/> -->
  119. <!--             <result/> -->
  120. <!--             <collection property=""> -->
  121. <!--             </collection> -->
  122. <!--         </collection> -->
  123. <!--     </resultMap> -->
  124. <!--     <select id=""> -->
  125. <!--     </select> -->
  129. </mapper>

下边是映射文件对应的代理接口类

  1. package com.samrtian.mapper;
  3. import java.util.List;
  5. import com.samrtian.entity.User;
  6. import com.samrtian.po.CustomVo;
  8. public interface UserMapper {
  9.     public User findByUserID(int id);
  10.     public User findByUserName(String name);
  11.     public List<User> findLikeUserName(String name);
  12.     public void insertUser(User user);
  13.     public void deleteUser(int id);
  14.     public void updateUser(User user);
  15.     public User findByUserInfo(CustomVo vo);
  16.     public User findByidResultMap(int id);
  17.     public List<User> findByIds(List<Integer> list);
  18.     public CustomVo findByidAss(int id);
  19. }

代理接口类的方法与xml映射文件的id要一致包括参数和返回类型.

下边来测试使用方法

  1. package test_ssh;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.util.ArrayList;
  7. import java.util.List;
  9. import org.apache.ibatis.io.Resources;
  10. import org.apache.ibatis.session.SqlSession;
  11. import org.apache.ibatis.session.SqlSessionFactory;
  12. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  13. import org.junit.Test;
  15. import com.samrtian.entity.User;
  16. import com.samrtian.mapper.UserMapper;
  17. import com.samrtian.po.CustomVo;
  20. public class test {
  22.     @Test
  23.     public void select() throws IOException {
  24.         String resource = "myBatisConfig.xml";
  25.         InputStream inputStream = Resources.getResourceAsStream(resource);
  26.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  27.         SqlSession session = sqlSessionFactory.openSession();
  28.         User user = session.selectOne("nsUser.findByUserID", 1);
  29.         System.out.println(user.getName() + "   " + user.getPassword());
  30.         session.close();
  31.     }
  33.     @Test
  34.     public void like() throws IOException {
  35.         String resource = "myBatisConfig.xml";
  36.         InputStream inputStream = Resources.getResourceAsStream(resource);
  37.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  38.         SqlSession session = sqlSessionFactory.openSession();
  39.         List<User> list = session.selectList("nsUser.findLikeUserName", "xu");
  40.         System.out.println(list);
  41.         session.close();
  42.     }
  44.     @Test
  45.     public void insert() throws IOException {
  46.         String resource = "myBatisConfig.xml";
  47.         InputStream inputStream = Resources.getResourceAsStream(resource);
  48.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  49.         SqlSession session = sqlSessionFactory.openSession();
  50.         User user = new User();
  51.         user.setName("xiaohu");
  52.         user.setPassword("fsdfds");
  53.         session.insert("nsUser.insertUser", user);
  54.         session.commit();
  55.         System.out.println(user);
  56.         session.close();
  57.     }
  59.     @Test
  60.     public void delete() throws IOException {
  61.         String resource = "myBatisConfig.xml";
  62.         InputStream inputStream = Resources.getResourceAsStream(resource);
  63.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  64.         SqlSession session = sqlSessionFactory.openSession();
  65.         session.delete("nsUser.deleteUser", 334);
  66.         session.commit();
  67.         session.close();
  68.     }
  70.     @Test
  71.     public void update() throws IOException {
  72.         String resource = "myBatisConfig.xml";
  73.         InputStream inputStream = Resources.getResourceAsStream(resource);
  74.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  75.         SqlSession session = sqlSessionFactory.openSession();
  76.         User user = new User();
  77.         user.setId(888);
  78.         user.setName("kongjinxiang");
  79.         user.setPassword("55555");
  80.         session.update("nsUser.updateUser", user);
  81.         session.commit();
  82.         session.close();
  83.     }
  85.     @Test
  86.     public void testMapper() throws IOException {
  87.         String resource = "myBatisConfig.xml";
  88.         InputStream inputStream = Resources.getResourceAsStream(resource);
  89.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  90.         SqlSession session = sqlSessionFactory.openSession();
  91.         UserMapper userMapper = session.getMapper(UserMapper.class);
  92.         User user = userMapper.findByUserID(888);
  93.         session.close();
  95.         System.out.println(user);
  96.     }
  98.     @Test
  99.     public void testMultiParam() throws IOException {
  100.         String resource = "myBatisConfig.xml";
  101.         InputStream inputStream = Resources.getResourceAsStream(resource);
  102.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  103.         SqlSession session = sqlSessionFactory.openSession();
  104.         UserMapper userMapper = session.getMapper(UserMapper.class);
  106.         CustomVo vo = new CustomVo();
  107.         User user = new User();
  108.         user.setName("xiaohu");
  109.         user.setPassword("fsdfds");
  110.         vo.setUser(user);
  111.         userMapper.findByUserInfo(vo);
  112.         session.close();
  114.         System.out.println(user);
  115.     }
  117.     @Test
  118.     public void testResultMap() throws IOException {
  119.         String resource = "myBatisConfig.xml";
  120.         InputStream inputStream = Resources.getResourceAsStream(resource);
  121.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  122.         SqlSession session = sqlSessionFactory.openSession();
  123.         UserMapper userMapper = session.getMapper(UserMapper.class);
  125.         User user = userMapper.findByidResultMap(1);
  126.         session.close();
  128.         System.out.println(user);
  129.     }
  131.     @Test
  132.     public void testUsersForID() throws IOException {
  133.         String resource = "myBatisConfig.xml";
  134.         InputStream inputStream = Resources.getResourceAsStream(resource);
  135.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  136.         SqlSession session = sqlSessionFactory.openSession();
  137.         UserMapper userMapper = session.getMapper(UserMapper.class);
  139.         List<Integer> list = new ArrayList<Integer>();
  140.         list.add(1);
  141.         list.add(3);
  142.         list.add(5);
  143.         List<User> users = userMapper.findByIds(list);
  144.         session.close();
  146.         System.out.println(users);
  147.     }
  149.     @Test
  150.     public void testAssociation() throws IOException {
  151.         String resource = "myBatisConfig.xml";
  152.         InputStream inputStream = Resources.getResourceAsStream(resource);
  153.         SqlSessionFactory  sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  154.         SqlSession session = sqlSessionFactory.openSession();
  155.         UserMapper userMapper = session.getMapper(UserMapper.class);
  157.         CustomVo user = userMapper.findByidAss(1);
  158.         session.close();
  160.         System.out.println(user.getUser().toString() + "    " + user.getGroupName());
  161.     }
  162. }

测试成功。都没问题

发表评论

表情：
评论列表 （有 0 条评论，314人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Mybatis学习笔记

    一、引言 1.框架的三层架构     表现层：是用于展示数据（SpringMVC）     业务层：是处理业务需求     持久层：是和数据库交互（MyBati

    骑猪看日落骑猪看日落/ 0 赞/ 198 阅读

    相关 Mybatis学习笔记

    学习了Mybatis。相对于hibernate来说这个框架更加灵活，开发效率更快，适用于那些改动比较频繁的项目。 首先加入mybatis的配置文件myBatisConfig.

    叁歲伎倆叁歲伎倆/ 0 赞/ 315 阅读