143_Java_SpringMybatis_Mybatis参数处理 & CRUD

Mybatis使用insert|update|delete|select完成CRUD

public class MybatisUtils {

    private  static SqlSessionFactory sqlSessionFactory ;

    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream is  = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
//       * sqlSessionFactory.openSession();===》手动提交
//     * sqlSessionFactory.openSession(true);===》自动提交

    public static SqlSession getSqlSession (){
        return  sqlSessionFactory.openSession();
    }
}

1 普通CRUD

EmployeeMapper

public interface EmployeeMapper {   
 // 1 增
    public Long addEmp(Employee employee);
    // 2 删除
    public void deleteEmpById(Integer id);
    // 3 改
    public boolean updateEmp(Employee employee);
    // 4 查
    public Employee getEmpById(Integer id);

    // 5 多个参数的查询   @Param("属性名") 明确指定, 方便多个参数法封装成一个map
    public Employee getEmpByIdAndLastName(@Param("id")Integer id, @Param("lastName")String lastName);

}

EmployeeMapper.xml

   <mapper namespace="com.alex.dao.EmployeeMapper">
 

<!--    // 增 public Long addEmp(Employee employee);-->
<!--    // 删除 public void deleteEmpById(Integer id);-->
<!--    // 改 public boolean updateEmp(Employee employee);-->

    <!-- public void addEmp(Employee employee); -->
    <!-- parameterType：参数类型，可以省略，
    获取自增主键的值：
        mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
        useGeneratedKeys="true"；使用自增主键获取主键值策略
        keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性
    -->
    <insert id="addEmp"  parameterType="com.alex.bean.Employee" databaseId="mysql" useGeneratedKeys="true" keyProperty="id">
        insert into tbl_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
    </insert>

    <update id="updateEmp">
		update tbl_employee  set last_name=#{lastName},email=#{email},gender=#{gender} where id=#{id}
	</update>

    <delete id="deleteEmpById" >
        delete from tbl_employee where id = #{id}
    </delete>
    
    
<!--  4    单个参数的查询-->

    <select id="getEmpById" resultType="com.alex.bean.Employee" databaseId="mysql">
		select *  from tbl_employee where id = #{idddddd}
	</select>
    
<!--   5  多个参数的查询 @Param-->
<!--    public Employee getEmpByIdAndLastName(@Param("id")Integer id, @Param("lastName")String lastName);-->
    <select id="getEmpByIdAndLastName" resultType="com.alex.bean.Employee" databaseId="mysql" >
        select  * from   tbl_employee where  id=#{id} and last_name =#{lastName}
    </select>
</mapper>

Test

@Test
    public void test_add(){
        //1、获取到的SqlSession不会自动提交数据
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        Employee alex = new Employee("alex", "alex@163.com", "1");
        Long resout = mapper.addEmp(alex);
        System.out.println(alex.getId()); //有返回值 4
        session.commit();
        session.close();
    }

    @Test
    public void test_update(){
        //1、获取到的SqlSession不会自动提交数据
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        Employee tom = new Employee(1,"tom", "tom@163.com", "1");
        mapper.updateEmp(tom);
        session.commit();
        session.close();
    }

    @Test
    public void test_delete(){
        //1、获取到的SqlSession不会自动提交数据
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
       mapper.deleteEmpById(1);
        session.commit();
        session.close();
    }

    // 单个参数查询
    @Test
    public void getEmpById() {
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        Employee employee = mapper.getEmpById(4);
        System.out.println(employee);
        session.close();
    }
    // 多个参数查询 @param
    @Test
    public void getEmpByIdAndLastName() {
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        Employee alex = mapper.getEmpByIdAndLastName(4, "alex");
        session.commit();
        System.out.println(alex);
        session.close();
    }

1 单个参数：mybatis不会做特殊处理，
	#{参数名/任意名}：取出参数值。
	select *  from tbl_employee where id = #{idddddd}
	
	
2 多个参数：mybatis会做特殊处理, 多个参数会被封装成map， #{}就是从map中获取指定的key的值；
	     封装map的规则：key：param1...paramN,或者参数的索引也可以 ,value：传入的参数值
		 如不指定参数 会报异常 org.apache.ibatis.binding.BindingException:
        Parameter 'id' not found.  Available parameters are [1, 0, param1, param2]		 

 解决办法 使用命名参数：明确指定封装参数时map的key；@Param("id")
	多个参数会被封装成一个map， key：使用@Param注解指定的值， value：参数值； #{指定的key}取出对应的参数值

6 多个参数的查询 Map    
7 返回集合
8 返回一条记录的map；key就是列名，值就是对应的值
9 多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean

3 POJO：
如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo；
	#{属性名}：取出传入的pojo的属性值	

4 Map：
如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map
	#{key}：取出map中对应的值


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

6 #{} 大多情况下，我们去参数的值都应该去使用#{}；
select * from tbl_employee where id=${id} and last_name=#{lastName}

#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
${}:取出的值直接拼装在sql语句中；会有安全问题；
		
${} 原生jdbc不支持占位符的地方我们就可以使用${}进行取值 , 比如分表、排序。。。；按照年份分表拆分
			select * from ${year}_salary where xxx;
			select * from tbl_employee order by ${f_name} ${order}
#{}:更丰富的用法： 规定参数的一些规则：
	javaType、 jdbcType、 mode（存储过程）、 numericScale、
	resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）；

	jdbcType通常需要在某种特定的条件下被设置：
		在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）；
		JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理;
		由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法
		1、#{email,jdbcType=OTHER};
		2、jdbcTypeForNull=NULL
			<setting name="jdbcTypeForNull" value="NULL"/>

public interface EmployeeMapper {
    // 6 多个参数的查询 Map
    public Employee getEmpByMap(Map<String, Object> map);

    // 7 返回集合
    public List<Employee> getEmpsByLastNameLike(String lastName);


    //8 返回一条记录的map；key就是列名，值就是对应的值
    public Map<String, Object> getEmpByIdReturnMap(Integer id);


    //9 多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
    //@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
    @MapKey("lastName")
    public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);
    
}

<?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.alex.dao.EmployeeMapper">
 
    <!--6  多个参数的查询 map-->
   <!-- public Employee getEmpByMap(Map<String, Object> map);-->
<!--    测试 ${ tableName}  原生JDBC 或者 不能预编译的 可以使用-->

    <select id="getEmpByMap" resultType="com.alex.bean.Employee" databaseId="mysql">
        <!--    select *  from tbl_employee where id = #{id} and last_name =#{lastName}-->
		select *  from  ${tableName} where id = #{id} and last_name =#{lastName}
	</select>


    <!-- public List<Employee> getEmpsByLastNameLike(String lastName); -->
    <!--7 resultType：如果返回的是一个集合，要写集合中元素的类型 Employee -->
    <select id="getEmpsByLastNameLike" resultType="com.alex.bean.Employee" databaseId="mysql">
            select *  from tbl_employee where last_name like  #{lastName}
    </select>


<!--  8  返回值封装成一个map-->
    <!--public Map<String, Object> getEmpByIdReturnMap(Integer id);  -->
    <select id="getEmpByIdReturnMap" resultType="map" databaseId="mysql">
 		select *  from tbl_employee where id= #{id}
 	</select>

    <!--9 resultType：如果返回的是一个集合，要写集合中元素的类型  -->
    <!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
    <select id="getEmpByLastNameLikeReturnMap" resultType="com.alex.bean.Employee">
 		select * from tbl_employee where last_name like #{lastName}
 	</select>
    
</mapper>

 // 多个参数查询 map
    @Test
    public void getEmpByMap() {
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

        HashMap<String, Object> map = new HashMap<>();
        map.put("id" ,4 );
        map.put("lastName" ,"alex" );
        map.put("tableName" ,"tbl_employee");
        Employee employee = mapper.getEmpByMap(map);
        session.commit();
        System.out.println(employee);
        session.close();
    }


    // 返回 List  like
    @Test
    public void getEmpsByLastNameLike() {
        SqlSession session = MybatisUtils.getSqlSession();
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        List<Employee> list_emp = mapper.getEmpsByLastNameLike("%e%");
        session.commit();

        for (Employee employee : list_emp) {
//            System.out.println(employee);
        }
        session.close();

others
public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1}   lastName==>#{param2}

public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1}    lastName===>#{param2.lastName/e.lastName}

##特别注意：如果是Collection（List、Set）类型或者是数组，也会特殊处理。也是把传入的list或者数组封装在map中。
			key：Collection（collection）,如果是List还可以使用这个key(list),数组(array)
public Employee getEmpById(List<Integer> ids); 取值：取出第一个id的值: #{list[0]}