MyBatis （4）

1. El atributo parameterType en el archivo de mapeo Sql se pasa en el parámetro
[input / update / delete / select element input parameter] El
atributo parameterType se pasa en el parámetro
1. String + tipo básico [String — java.lang.String, int / boolean, java. lang.Integer]
2. Tipo POJO [tipo de objeto] com.wangxing.bean
. Estudiante 3. Tipo de colección [lista, hashMap]
cuando el método de la interfaz de acceso a datos tiene solo un parámetro [Cadena + tipo básico / POJO tipo], cuando hay Cuando se suelen utilizar varios parámetros [tipo de colección]
Por ejemplo:

package com.wangxing.mybatis.mapper;

import com.wangxing.mybatis.bean.Person;

import java.util.List;
import java.util.Map;

public interface PersonMapper {
    void insertPerson(Person person);
    void deletePerson(int perid);
    void deletePersonByName(String pername);
    void deletePersonByAge(int perage);
    List<Person> selectPerson(Map<String,Object> parameter);
}
Sql映射文件
<?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.wangxing.mybatis.mapper.PersonMapper">
    <!--测试parameterType属性为POJO类型-->
  <insert id="insertPerson" parameterType="com.wangxing.mybatis.bean.Person">
      insert into t_person values(null,#{pername},#{perage},#{peraddress});
  </insert>
    <!--测试parameterType属性为基本类型-->
  <delete id="deletePerson"  parameterType="int">
      delete from  t_person where per_id = #{perid};
  </delete>
    <!--测试parameterType属性为String类型-->
  <delete id="deletePersonByName" parameterType="java.lang.String">
       delete from  t_person where per_name = #{pername};
  </delete>
    <!--测试parameterType属性为基本类型的封装类类型-->
  <delete id="deletePersonByAge" parameterType="java.lang.Integer">
       delete from  t_person where per_age = #{perage};
  </delete>
    <resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
        <id column="per_id" property="perid"></id>
        <result column="per_name" property="pername"></result>
        <result column="per_age" property="perage"></result>
        <result column="per_address" property="peraddress"></result>
    </resultMap>
    <!--测试parameterType属性为集合类型-->
    <select id="selectPerson" parameterType="hashMap" resultMap="personMap">
        select * from t_person where per_id=#{id} or per_name=#{name} or per_age=#{age};
    </select>
</mapper>
测试类
package com.wangxing.mybatis.test;

import com.wangxing.mybatis.bean.Person;
import com.wangxing.mybatis.mapper.PersonMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.util.HashMap;
import java.util.List;

public class TestMain {
    /**
     * 得到SqlSession
     * @return
     */
    public static SqlSession  getSqlSession()throws  Exception{
        SqlSession sqlSession=null;
        SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatis-config.xml"));
        return sqlSessionFactory.openSession();
    }

    /**
     * 测试parameterType属性为POJO类型
     */
    public static  void testInsertPerson(){
        SqlSession  sqlSession=null;
        try{
            sqlSession=getSqlSession();
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            Person person=new Person();
            person.setPername("java");
            person.setPerage(20);
            person.setPeraddress("西安");
            personMapper.insertPerson(person);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            sqlSession.close();
        }
    }
    /**
     * 测试parameterType属性为集合类型
     */
    public static  void testSelectPerson(){
        SqlSession  sqlSession=null;
        try{
            sqlSession=getSqlSession();
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            HashMap<String,Object> parameter=new HashMap<String,Object>();
            parameter.put("id",3);
            parameter.put("name","wangwu");
            parameter.put("age",20);
            List<Person> personList=personMapper.selectPerson(parameter);
            sqlSession.commit();
            for(Person person:personList){
                System.out.println(person.getPerid()+"\t"+person.getPername());
            }
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            sqlSession.close();
        }
    }

    /**
     * 测试parameterType属性为String+基本类型
     */
    public static  void testDeletePerson(){
        SqlSession  sqlSession=null;
        try{
            sqlSession=getSqlSession();
            PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
            //personMapper.deletePerson(5);
            //personMapper.deletePersonByName("wangwu");
            personMapper.deletePersonByAge(23);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            sqlSession.close();
        }
    }
    public static void main(String[] args) {
        //testInsertPerson();
        //testSelectPerson();
        testDeletePerson();
    }
}

2. #{}y ${}uso
en el archivo de mapeo mybatis [archivo de mapeo de sql], los parámetros se pasan de dos formas. Uno es # {} y el otro es $ {}. Hay una gran diferencia entre los dos:
# {} implementa el preprocesamiento de sentencias sql, y ¿se usa en el sql que se ejecuta más tarde? Número en su lugar. No es necesario prestar atención al tipo de datos del parámetro al usarlo. Mybatis implementará automáticamente la conversión de tipos de datos y puede evitar la inyección de SQL.
$ {} implementa la operación de empalme de declaraciones SQL, sin conversión de tipo de datos, debe juzgar el tipo de datos usted mismo y no puede evitar la inyección de SQL.
Resumen: # {} marcador de posición para el paso de parámetros. $ {} se usa para la
prueba de empalme de sql :
Mybatis-config.xml establece la declaración de sql para que se genere en la consola

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
测试#{}的使用
package com.wangxing.mybatis.mapper;

import com.wangxing.mybatis.bean.Person;

import java.util.List;
import java.util.Map;

public interface PersonMapper {
     List<Person> selectPersonByName1(String pername);
}

Archivo de mapeo SQL

<?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.wangxing.mybatis.mapper.PersonMapper">
    <resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
        <id column="per_id" property="perid"></id>
        <result column="per_name" property="pername"></result>
        <result column="per_age" property="perage"></result>
        <result column="per_address" property="peraddress"></result>
    </resultMap>
    <select id="selectPersonByName1" parameterType="java.lang.String" resultMap="personMap">
        select * from t_person where per_name like  #{pername}
    </select>
 </mapper>

Código de prueba

public static  void selectPersonByName1(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        List<Person> personList=personMapper.selectPersonByName1("%j%");
        sqlSession.commit();
        for(Person person:personList){
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

resultado de la operación:

Se puede ver que # {} es el preprocesamiento de la ejecución de sentencias SQL. Al usar marcadores de posición para pasar parámetros para ejecutar sentencias SQL, la conversión del tipo de datos se realiza automáticamente y se puede prevenir la inyección SQL.
Pruebe el uso de $ {}

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import java.util.List;
import java.util.Map;
public interface PersonMapper {
      List<Person> selectPersonByName2(Map<String,Object> pername);
}

Archivo de mapeo SQL

<?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.wangxing.mybatis.mapper.PersonMapper">
    <resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
        <id column="per_id" property="perid"></id>
        <result column="per_name" property="pername"></result>
        <result column="per_age" property="perage"></result>
        <result column="per_address" property="peraddress"></result>
    </resultMap>
    <select id="selectPersonByName2" parameterType="hashMap" resultMap="personMap">
        select * from t_person where per_name like  ${name};
    </select>
</mapper>

Código de prueba

/**
 * 测试sql语句中通过${}方式接收参数值
 */
public static  void selectPersonByName2(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        HashMap<String,Object> pername=new HashMap<String,Object>();
        pername.put("name","'%j%'");
        List<Person> personList=personMapper.selectPersonByName2(pername);
        sqlSession.commit();
        for(Person person:personList){
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

resultado de la operación

Se puede ver que $ {} es la ejecución de empalme de declaraciones SQL, no implementa automáticamente la conversión de tipos de datos y no evita la inyección SQL.
3. ¿Por qué utilizar SQL dinámico?
Si tiene experiencia en el uso de JDBC u otros marcos similares, puede apreciar lo doloroso que es empalmar declaraciones SQL de acuerdo con diferentes condiciones. Al empalmar, asegúrese de no olvidar los espacios necesarios y también preste atención a omitir la coma al final de la lista de nombres de columna.
El uso de la función de SQL dinámico puede eliminar completamente este dolor.
P.ej:

String insertsql="insert into t_user values(null,'"+userbean.getUsername()+
			"',"+userbean.getUserage()+","+userbean.isUsersex()+
			",'"+userbean.getUseraddress()+"','"+userbean.getUserday()+"');";

5. ¿Cuáles son los SQL dinámicos más utilizados y cómo se utilizan?
si
elija (cuando, de lo contrario)
trim (donde, establezca)
foreach
prueba cada elemento para lograr la adición de lote / eliminación
de lote de adición de lote en declaraciones Sql

INSERT INTO `t_person` VALUES (6,'java',20,'西安'),(7,'javaee',21,'西安');

Eliminación de lotes en declaración SQL

delete from t_person where per_id in(6,7);

elemento foreach

 <foreach collection="list【表示需要被遍历的数据结合】" 
item="从collection对应的集合中得到的每一个数据对象【java对象】" 
separator="数据对象【java对象】的分隔符">
	    	每一个具体的数据对象
</foreach>

para cada elemento, realice
la interfaz de acceso de datos de adición por lotes

package com.wangxing.mybatis.mapper;

import com.wangxing.mybatis.bean.Person;

import java.util.List;
import java.util.Map;

public interface PersonMapper {
    void insertPersonForeach(List<Person> personList);
}
SQL映射文件
<insert id="insertPersonForeach" parameterType="java.util.List">
    insert into t_person values
    <foreach collection="list" item="person" separator=",">
        (null,#{person.pername},#{person.perage},#{person.peraddress})
    </foreach>
</insert>

Código de prueba

/**
 * 测试foreach元素，实现批量添加
 */
public static  void insertPersonForeach(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        personMapper.insertPersonForeach(getPersonList());
        sqlSession.commit();
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

Resultados de la prueba

para cada elemento, realice
la interfaz de acceso a datos de eliminación por lotes

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import java.util.List;
import java.util.Map;
public interface PersonMapper {
        void deletePersonForeach(List<Integer> perids);
}

Archivo de mapeo SQL

<delete id="deletePersonForeach" parameterType="java.util.List">
    delete from t_person where per_id in
    <foreach collection="list" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

Código de prueba

/**
 * 测试foreach元素，实现批量删除
 */
public static  void deletePersonForeach(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        List<Integer> perids=new ArrayList<Integer>();
        perids.add(8);
        perids.add(9);
        perids.add(10);
        perids.add(11);
        personMapper.deletePersonForeach(perids);
        sqlSession.commit();
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

resultado de la operación

Prueba si el elemento

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import java.util.List;
import java.util.Map;
public interface PersonMapper {
    List<Person> selectPersonByIf(Map<String,Object> pername);
}

<resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
    <id column="per_id" property="perid"></id>
    <result column="per_name" property="pername"></result>
    <result column="per_age" property="perage"></result>
    <result column="per_address" property="peraddress"></result>
</resultMap>
<select id="selectPersonByIf" parameterType="hashMap" resultMap="personMap">
    select * from t_person where 1=1
    <if test="name !=null and name !=''">
        and  per_name like #{name}
    </if>
</select>

/**
 * 测试if元素，判断是否有用户名，如果有就根据用户名模糊查询，如果没有就查询所有
 */
public static  void selectPersonByIf(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        HashMap<String,Object> pername=new HashMap<String,Object>();
        pername.put("name",null);
        List<Person> personList=personMapper.selectPersonByIf(pername);
        sqlSession.commit();
        for(Person person:personList){
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

En caso afirmativo, consulta aproximada basada en el nombre de usuario

Si no, marque todo

Prueba elegir (cuando, de lo contrario)
[Solo coincide con una condición a la vez]
Requisitos: Consultar información de usuario, si se ingresa el nombre de usuario, realizar una búsqueda aproximada basada en el nombre de usuario, regresar
Si se ingresa la edad, realizar una búsqueda coincidente según la edad, devuelva
si ingresó Dirección, realice una búsqueda aproximada de acuerdo con la dirección y regrese.
Si las condiciones de la consulta están vacías, consulte todas.
Algo similar a la declaración de Switch

package com.wangxing.mybatis.mapper;

import com.wangxing.mybatis.bean.Person;

import java.util.List;
import java.util.Map;

public interface PersonMapper {
     List<Person> selectPersonByChoose(Map<String,Object> pername);

}

<resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
    <id column="per_id" property="perid"></id>
    <result column="per_name" property="pername"></result>
    <result column="per_age" property="perage"></result>
    <result column="per_address" property="peraddress"></result>
</resultMap>
<select id="selectPersonByChoose" parameterType="hashMap" resultMap="personMap">
    select * from t_person where 1=1
    <choose>
        <when test="name !=null and name !=''">and  per_name like #{name}</when>
        <when test="age !=0 and age !=null">and  per_age=#{age}</when>
        <when test="address !=null and address !=''">and  per_address like #{address}</when>
        <otherwise></otherwise>
    </choose>
</select>

/**
 * 测试choose (when, otherwise)元素
 */
public static  void selectPersonByChoose(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        HashMap<String,Object> pername=new HashMap<String,Object>();
        pername.put("name",null);
        pername.put("age",24);
        pername.put("address","xian");
        List<Person> personList=personMapper.selectPersonByChoose(pername);
        sqlSession.commit();
        for(Person person:personList){
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

resultado de la operación

Prueba donde el elemento

package com.wangxing.mybatis.mapper;
import com.wangxing.mybatis.bean.Person;
import java.util.List;
import java.util.Map;
public interface PersonMapper {
       List<Person> selectPersonByWhere(Map<String,Object> pername);
}

<resultMap id="personMap" type="com.wangxing.mybatis.bean.Person">
    <id column="per_id" property="perid"></id>
    <result column="per_name" property="pername"></result>
    <result column="per_age" property="perage"></result>
    <result column="per_address" property="peraddress"></result>
</resultMap>
<select id="selectPersonByWhere" parameterType="hashMap" resultMap="personMap">
    select * from t_person
    <where>
        <if test="name !=null and name !=''">
            and  per_name like #{name}
        </if>
        <if test="age !=0 and age !=null">
            and  per_age=#{age}
        </if>
        <if test="address !=null and address !=''">
            and  per_address like #{address}
        </if>
    </where>
</select>

/**
 * 测试where元素
 */
public static  void selectPersonByWhere(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        HashMap<String,Object> pername=new HashMap<String,Object>();
        pername.put("name",null);
        pername.put("age",23);
        pername.put("address","xian");
        List<Person> personList=personMapper.selectPersonByWhere(pername);
        sqlSession.commit();
        for(Person person:personList){
            System.out.println(person.getPerid()+"\t"+person.getPername());
        }
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}

Elemento del conjunto de prueba

package com.wangxing.mybatis.mapper;

import com.wangxing.mybatis.bean.Person;

import java.util.List;
import java.util.Map;

public interface PersonMapper {
    void updatePerson(Map<String,Object> pername);
}

<update id="updatePerson" parameterType="hashMap">
    update  t_person
    <set>
        <if test="name !=null and name !=''">
            per_name = #{name},
        </if>
        <if test="age !=null and age !=0">
            per_age = #{age},
        </if>
        <if test="address !=null and address !=''">
            per_address = #{address},
        </if>
    </set>
    <where>per_id = #{id}</where>
</update>

/**
 * 测试set元素
 */
public static  void updatePerson(){
    SqlSession  sqlSession=null;
    try{
        sqlSession=getSqlSession();
        PersonMapper personMapper=sqlSession.getMapper(PersonMapper.class);
        HashMap<String,Object> pername=new HashMap<String,Object>();
        pername.put("id",12);
        pername.put("name",null);
        pername.put("age",33);
        pername.put("address","西安");
        personMapper.updatePerson(pername);
        sqlSession.commit();
    }catch (Exception e){
        e.printStackTrace();
        sqlSession.rollback();
    }finally {
        sqlSession.close();
    }
}