Mybatis映射文件（1）

我不是女神ヾ 2022-05-24 02:22 293阅读 0赞

mybatis映射文件——增删改查

  1. public interface EmployeeMapper {
  2.     Employee selectById(Integer id);
  3.     void addEmp(Employee employee);
  4.     void updateEmp(Employee employee);
  5.     void deleteEmpById(Integer id);
  6. }
  8. <mapper namespace="dao.EmployeeMapper">
  9.     <select id="selectById" resultType="employee">
  10.         SELECT * FROM t_employee WHERE id = #{id}
  11.     </select>
  13.     <!--parameterType可以省略-->
  14.     <insert id="addEmp" parameterType="bean.Employee">
  15.         INSERT INTO t_employee VALUES (NULL ,#{lastName},#{gender},#{email})
  16.     </insert>
  18.     <update id="updateEmp">
  19.         UPDATE t_employee SET last_name = #{lastName},gender=#{gender},email = #{email} WHERE id=#{id}
  20.     </update>
  22.     <delete id="deleteEmpById">
  23.         DELETE FROM t_employee WHERE id=#{id}
  24.     </delete>
  25. </mapper>
  27. /**
  28.  *1、 mybatis 允许增删改查直接定义一下返回值类型
  29.  *         Long、Integer、Boolean
  30.  *2、我们需要手动提交数据
  31.  *      sqlSessionFactory.openSession()===》手动提交
  32.  *          sqlSessionFactory.openSession(true)===》自动提交
  33.  * @throws IOException
  34.  */
  35. @Test
  36. public void testSelect() throws IOException {
  37.     SqlSession sqlSession = getSqlSession();
  38.     try {
  39.         //3、获取Employee的代理对象——通过sqlSession为接口创建一个代理对象
  40.         EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
  41.         //增删改查
  42.         mapper.addEmp(new Employee(null, "haha", "1", "haha@qq.com"));
  44.         mapper.deleteEmpById(3);
  46.         mapper.updateEmp(new Employee(1, "tona", "1", "toma@qq.com"));
  48.         Employee e = mapper.selectById(2);
  50.         System.out.println(e);
  51.     } finally {
  52.         //4、关闭SqlSession对象
  53.         sqlSession.close();
  54.     }
  55. }

获取自增主键值的策略

自增的数据库：MySQL 

  1. <!--
  2. parameterType可以省略
  3. mybatis支持自增主键、自增主键的获取，mabatis也是利用statement.getGenereatedKeys()
  4. useGeneratedKeys="true"使用主键自增获取主键值策略
  5. keyProperty:指定对应的主键属性，也就是mybatis获取到主键后，将这个值封装给JavaBean的那个属性
  6. -->
  7. <insert id="addEmp" parameterType="bean.Employee" useGeneratedKeys="true" keyProperty="id">
  8.     INSERT INTO t_employee(last_name, gender, email) VALUES (#{lastName},#{gender},#{email})
  9. </insert>

非自增的数据库：如Oracle 

  1. <!--oracle数据库不支持自增-->
  2. <!--使用Oracle-->
  3. <insert id="addEmp" parameterType="bean.Employee" databaseId="oracle">
  4.     /*
  5.     查询主键的sql语句
  6.     keyProperty:查出主键封装给javaBean的那个属性
  7.     order="BEFORE":当前sql在插入sql之前运行
  8.            AFTER:当前sql在插入sql之后运行
  9.     resultType:查询出的数据的返回值类型
  10.     */
  11.     <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
  12.         SELECT EMPLOYEES_SEQ.nextval FROM dual
  13.     </selectKey>
  14.     INSERT INTO t_employee(EMPLOYEE_ID,last_name, gender, email) VALUES (#{id},#{lastName},#{gender},#{email})
  15. </insert>
mybatis参数处理

单个参数：mybatis不会做任何处理

  1.            \#\{参数名\}：取出参数的值

多个参数：mybatis会做特殊处理

  1.             多个参数会被封装成一个map
  3.             key：param1，。。。。,paramN或者参数的索引也可以
  5.             value：传入的参数值  
  8.             \#\{ \}就是从map中获取指定的key值  
  11. Employee selectByIdAndLastName(Integer id,String lastNae);
  13. <select id="selectByIdAndLastName" resultType="employee">
  14.     SELECT * FROM t_employee WHERE id = #{id} AND last_name=#{lastName}
  15. </select>

出现异常： org.apache.ibatis.binding.BindingException: Parameter ‘id’ not found. Available parameters are [arg1, arg0, param1, param2]

改成：

  1. <select id="selectByIdAndLastName" resultType="employee">
  2.     SELECT * FROM t_employee WHERE id = #{param1} AND last_name=#{param2}
  3. </select>

程序运行OK。

推荐：

命名参数：明确指定封装参数时的map的key：

  1. @Param("id")

多个参数会被封装成一个map

  1.     key：使用@Param注解指定的值
  3.     value：参数值

#{ }取出对应的参数值 

  1. Employee selectByIdAndLastName(@Param("id") Integer id,@Param("lastName") String lastName);
  3. <select id="selectByIdAndLastName" resultType="employee">
  4.     SELECT * FROM t_employee WHERE id = #{id} AND last_name=#{lastName}
  5. </select>

POJO：

如果多个参数正好时我们业务逻辑的数据模型，我们可以直接传入pojo 

  1.     \#\{属性名\}：取出传入的pojo的属性值

Map：

如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map

  1.     \#\{key\}：取出map对应的值

TO：

如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象

Page{

int index；

int size;

}

============小结==============

  1. Employee getEmp(@Param("id") Integer id,String lastName);
  2. 取值：id==》#{id/param1}  lastName==》#{param2}
  4. Employee getEmp(@Param("id") Integer id,@Param("e") Employee emp);
  5. 取值：id==》#{param1}  lastName==》#{param2.lastName/e.lastName}
  7. ###特别注意：如果是Collection（List，Set）类型或者是数组，也会特殊处理。也是把传入的list或数组封装在map中
  8. key：Collection（collection），如果是List还可以使用key（list）,数组（array）
  9. Employee getEmpById(List<Integer> ids);
  10. 取值：取出第一个值id==》#{ids[0]}

==============源码——mybatis对参数的处理==============

  1. public class ParamNameResolver {
  2.     private static final String GENERIC_NAME_PREFIX = "param";
  3.     /**
  4.      * 存放参数个数
  5.      */
  6.     private final SortedMap<Integer, String> names;
  8.     private boolean hasParamAnnotation;
  9.     //解析参数封装成map
  10.     public ParamNameResolver(Configuration config, Method method) {
  11.         final Class<?>[] paramTypes = method.getParameterTypes();
  12.         final Annotation[][] paramAnnotations = method.getParameterAnnotations();
  13.         final SortedMap<Integer, String> map = new TreeMap<Integer, String>();
  14.         int paramCount = paramAnnotations.length;
  15.         // get names from @Param annotations
  16.         //索引参数
  17.         for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
  18.             if (isSpecialParameter(paramTypes[paramIndex])) {
  19.                 // skip special parameters
  20.                 continue;
  21.             }
  22.             String name = null;
  23.             //如果当前参数的注解为@Param注解
  24.             for (Annotation annotation : paramAnnotations[paramIndex]) {
  25.                 if (annotation instanceof Param) {
  26.                     hasParamAnnotation = true;
  27.                     name = ((Param) annotation).value();//获取参数的值
  28.                     break;
  29.                 }
  30.             }
  31.             if (name == null) {
  32.                 // @Param was not specified.
  33.                 if (config.isUseActualParamName()) {
  34.                     name = getActualParamName(method, paramIndex);
  35.                 }
  36.                 if (name == null) {
  37.                     // use the parameter index as the name ("0", "1", ...)
  38.                     // gcode issue #71
  39.                     name = String.valueOf(map.size());//如果么有标注解就是map
  40.                 }
  41.             }
  42.             map.put(paramIndex, name);//放入
  43.         }
  44.         names = Collections.unmodifiableSortedMap(map);
  45.     }
  47.     private String getActualParamName(Method method, int paramIndex) {
  48.         if (Jdk.parameterExists) {
  49.             return ParamNameUtil.getParamNames(method).get(paramIndex);
  50.         }
  51.         return null;
  52.     }
  54.     private static boolean isSpecialParameter(Class<?> clazz) {
  55.         return RowBounds.class.isAssignableFrom(clazz) || ResultHandler.class.isAssignableFrom(clazz);
  56.     }
  58.     /**
  59.      * Returns parameter names referenced by SQL providers.
  60.      */
  61.     public String[] getNames() {
  62.         return names.values().toArray(new String[0]);
  63.     }
  65.     /**
  66.      *  names (param1, param2,...).
  67.      * </p>
  68.      */
  69.     public Object getNamedParams(Object[] args) {
  70.         final int paramCount = names.size();//获取参数个数
  71.         if (args == null || paramCount == 0) {
  72.             return null;//参数为null直接返回
  73.             //如果只有一个元素，并且没有param注解，直接返回args[0],单个元素直接返回
  74.         } else if (!hasParamAnnotation && paramCount == 1) {
  75.             return args[names.firstKey()];
  76.         } else {
  77.             final Map<String, Object> param = new ParamMap<Object>();
  78.             int i = 0;
  79.             //给上面新建的param这个map保存数据——遍历names集合
  80.             for (Map.Entry<Integer, String> entry : names.entrySet()) {
  81.                 //names集合的value值作为key，names集合的key又作为取值的参考
  82.                 //如：names集合{0=id，1=lastName}===》{id=args[0]:1,lastName=args[1]:toma}
  83.                 param.put(entry.getValue(), args[entry.getKey()]);
  84.                 // add generic param names (param1, param2, ...)
  85.                 //额外的将每个参数保存到map中，使用新的key：param1，param2。。。。paramN
  86.                 final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
  87.                 // ensure not to overwrite parameter named with @Param
  88.                 if (!names.containsValue(genericParamName)) {
  89.                     param.put(genericParamName, args[entry.getKey()]);
  90.                 }
  91.                 i++;
  92.             }
  93.             return param;
  94.         }
  95.     }
  96. }

ParamNameResolver解析参数封装map的：

1、names获取参数（0=id，1=lastName）

2、获取每个表了@param注解的参数的值：id、lastName，赋值给name

3、每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）

  1.     name的值：标注了param注解：注解的值
  3.     没有标注：1、全局配置isUseActualParamName（JDK1.8才行）：name=参数名
  5.                      2、name=map.size()——相当于当前元素的索引

===============关于参数的获取================

#{ }：可以获取map中的值或者pojo对象中的值

${ }：可以获取map中的值或者pojo对象中的值

  1.     区别：
  3. <select id="selectByIdAndLastName" resultType="employee">
  4.     SELECT * FROM t_employee WHERE id = #{id} AND last_name=#{lastName}
  5. </select>

执行的sql语句为： Preparing: SELECT * FROM t_employee WHERE id = ? AND last_name=? 

  1. <select id="selectByIdAndLastName" resultType="employee">
  2.     SELECT * FROM t_employee WHERE id = ${id} AND last_name=#{lastName}
  3. </select>

执行的sql语句为：Preparing: SELECT * FROM t_employee WHERE id = 1 AND last_name=?

#{ }：是以预编译的形式将参数设置到sql语句中，PrepareStatement。防止sql注入

${ }：将取出的值直接拼装在sql中。会有安全问题

大多数情况下，我们取参数的值都应该使用#{ }

但是在原生jdbc不支持占位符的地方就可以使用${ }进行取值

比如：分表：按照年份分表拆分

  1. select \* from $\{year\}\_salary where xxxx
  3. select \* from employ order by $\{ name \} $\{ desc/asc\}——排序

#{ }：更丰富的用法：

  1.     规定一些规则：
  3.     javaType、jdbcType、mode（存储过程）、numericScale（小数位数）、
  5.     resultMap（结果集）、 typeHandler（类型处理器）、jdbcTypeName、express

jdbcType：通常需要在某些特定的条件下被设置：在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理，比如oracle（报错）——JdbcType OTHER：无效类型，因为mybatis对所有的null都映射的是原生jdbc的 Other类型

由于全局配置中：jdbcTypeForNull=OTHER，Oracle不支持：——两种解决：

1、#{ 参数，jdbcType=OTHER} 2、在全局配置文件中设置：jdbcTypeForNull=NULL 

  1. <setting name="jdbcTypeForNull" value="NULL"></setting>

发表评论

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

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

相关阅读

    相关 Mybatis-映射文件

    Mybatis-映射文件(二) Mybatis的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器XML文件就显得相对简单。如果拿他跟具有相同功能的JD

    ╰半夏微凉°╰半夏微凉°/ 0 赞/ 393 阅读