Uno, parámetros de transferencia de Mybatis
- Significa que los parámetros se pasan del código Java al archivo de mapeo. A continuación, se muestran varios métodos de uso común para pasar parámetros:
1. Un parámetro simple
- El método en la interfaz de Dao tiene solo un parámetro de tipo simple, usando el marcador de posición # {cualquier carácter}
- Los llamados tipos simples: tipos básicos de Java y String
Cada método a continuación presenta un ejemplo para facilitar la comprensión
(1) Defina un método para consultar la tabla de datos por valor de id en la interfaz
Student selectStudenById(Integer id);
(2) Archivo de mapeo
<select id="selectStudenById" resultType="com.hcz.entity.Student">
select * from student where id=#{studentId}
</select>
Nota:
1. El valor en # {studentId} aquí es un nombre de variable personalizado, que no tiene nada que ver con los nombres de los parámetros del método.
2. Después de usar # {} aquí, mybatis ejecuta sentencias SQL usando el objeto PrepareStatement en jdbc.
3. La conexión es creado por mybatis. PrepareStatement objeto
String sql = "select * from student where id=?";
PrepareStatement ps = conn.prepareStaetment(sql);
ps.setInt(1,1002);
4. Ejecute el paquete SQL como "com.hcz.dao.Student" este objeto
ResultSet rs = ps.executeQuery();
Student student = null;
while(rs.next){
//从数据库取表的一行数据，存到一个java对象属性中
student = new Student();
student.setId(rs.getId("id"));
student.setName(rs.getString("name"));
student.setEmail(rs.getString("email"));
student.setAge(rs.getInt("age"));
}
return student;//给了dao方法调用的返回值；Student student = dao. selectStudenById(1003);
(3) Definir el método de prueba
@Test
public void testSelectStudents(){
/**
* 使用mybatis的动态代理机制，使用SqlSession.getMapper(dao接口)
* getMapper能获取dao接口对应的实现类对象
*/
SqlSession sqlSession = MyBatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
//调用dao的方法，执行数据库的操作
Student student = dao.selectStudenById(1003);
System.out.println("学生="+student);
}
(4) Resultados de la implementación
2. Múltiples parámetros (usando los parámetros de nombre de @Param)
- Cuando hay varios parámetros en el método de la interfaz dao, agregue @ delante del parámetro del métodoParam ("Nombre de parámetro personalizado"), Y el archivo de mapeo usa #{"Nombre del parámetro personalizado"}
(1) Defina un método en la interfaz
List<Student> selectMulitParam(@Param("myname") String name,
@Param("myage") Integer age);
(2) Archivo de mapeo
<select id="selectMulitParam" resultType="com.hcz.entity.Student">
select * from student where name=#{myname} or age=#{myage}
</select>
Nota:
Aquí el valor en # {} es el nombre del parámetro personalizado por @Param
(3) Definir el método de prueba
@Test
public void testSelectMulitParam(){
SqlSession sqlSession = MyBatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
List<Student> studentList = dao.selectMulitParam("李四", 28);
for (Student student: studentList){
System.out.println("学生="+student);
}
}
(4) Resultados de la implementación
3. Múltiples parámetros (usando objetos Java como parámetros)
- Utilice el objeto Java para pasar parámetros, el valor del atributo del objeto Java es el valor del parámetro requerido por la declaración SQL
(1) Defina un método en la interfaz
List<Student> selectMultiStudent(Student student);
(2) Archivo de mapeo
<select id="selectMultiStudent" resultType="com.hcz.entity.Student">
select * from student where name=#{name}
or age=#{age}
</select>
(3) Definir el método de prueba
@Test
public void testSelectMulitStudent(){
SqlSession sqlSession = MyBatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Student student = new Student();
student.setName("李四");
student.setAge(36);
List<Student> studentList = dao.selectMultiStudent(student);
for (Student stu: studentList){
System.out.println("学生="+stu);
}
}
(4) Resultados de la implementación
4. Múltiples parámetros (pasar parámetros por posición)
- La posición del parámetro comienza desde 0, la versión anterior a mybatis-3.4 usa el método # {0}, # {1} y mybatis3.4 comienza con el método # {arg0}, # {arg1}
(1) Defina un método en la interfaz
List<Student> selectMultiPosition(String name,Integer age);
(2) Archivo de mapeo
<select id="selectMultiPosition" resultType="com.hcz.entity.Student">
select * from student where name=#{arg0}
or age=#{arg1}
</select>
(3) Definir el método de prueba
@Test
public void testSelectMulitPosition(){
SqlSession sqlSession = MyBatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
List<Student> studentList = dao.selectMultiPosition("李四",28);
for (Student stu: studentList){
System.out.println("学生="+stu);
}
}
(4) Resultados de la implementación
5. Múltiples parámetros (usar Map para pasar parámetros, legibilidad deficiente)
- La colección de mapas utiliza claves de cadena y valores de tipo de objeto para almacenar parámetros. Mapeo de uso de archivos #{llave} Parámetro de referencia
(1) Defina un método en la interfaz
List<Student> selectMultiByMap(Map<String,Object> map);
(2) Archivo de mapeo
<select id="selectMultiByMap" resultType="com.hcz.entity.Student">
select * from student where name=#{myname}
or age=#{myage}
</select>
(3) Definir el método de prueba
@Test
public void testSelectMultiMap(){
SqlSession sqlSession = MyBatisUtil.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);
Map<String,Object> data = new HashMap<>();
data.put("myname","李四");// #{myname}
data.put("myage",28); // #{myage}
List<Student> stuList = dao.selectMultiByMap(data);
stuList.forEach( stu -> System.out.println(stu));
}
(4) Resultados de la implementación
6. La diferencia entre # y $
（1） # ：Marcador de posición, Dile a mybatis que use el valor real del parámetro en su lugar. Y use el objeto PrepareStatement para ejecutar la instrucción SQL, # {…} en lugar de "?" En la instrucción SQL. Es más seguro y rápido, y suele ser el método preferido.
Ejemplo:
<select id="selectStudenById" resultType="com.hcz.entity.Student">
select * from student where id=#{studentId}
</select>
Lo que Mybatis ejecuta internamente es:
String sql = "select * from student where id=?";
PrepareStatement ps = conn.prepareStaetment(sql);
ps.setInt(1,1002);
El 1002 aquí reemplazará # {studentId}
（2) $:Reemplazo de cuerdas, Que es principalmente para reemplazar la ubicación con la cadena contenida, y usar Statement para conectar la sentencia sql con el contenido de $ {}. Se utiliza principalmente en operaciones como reemplazar nombres de tablas, nombres de columnas y ordenar diferentes columnas.
Ejemplo:
select * from student where id=${
studentId}
El resultado de $ ejecución es:
seleccionar id, nombre, correo electrónico, edad del estudiante donde id = 1001 es
equivalente a:
String sql = “seleccionar id, nombre, correo electrónico, edad del estudiante donde id =” + “1001”;
(3) Su diferencia
- #¿utilizar? Si está en la declaración sql, use PreparedStatement para ejecutar sql, que es eficiente
- # Capaz de evitar la inyección de sql, más seguro
- $ No usa marcadores de posición, es un método de concatenación de cadenas, usa el objeto Statement para ejecutar SQL, baja eficiencia
- $: Puede reemplazar el nombre de la tabla o el nombre de la columna. ejemplo:
- Definir un método en la interfaz.
List<Student> selectUse$Order(@Param("colname") String colname
,@Param("myname") String name);
- Archivo de mapeo
<select id="selectUse$Order" resultType="com.hcz.entity.Student">
select * from student where ${colname}=#{myname}
</select>
- La declaración SQL después de la ejecución es:
select * from student where name=?
- $ Tiene el riesgo de inyección SQL y carece de seguridad. ejemplo:
- Definir un método en la interfaz.
List<Student> selectUse$(@Param("colname") String colname);
- Archivo de mapeo
<select id="selectUse$" resultType="com.hcz.entity.Student">
select * from student where name =${colname}
</select>
- La declaración SQL después de la ejecución es:
select * from student where name ='李四';drop table student
2. Esquema de pensamiento
¡Por favor corríjame si hay alguna deficiencia!