- Transmission de paramètres anonymes par ordre
- Utilisation de l'annotation @Param
- Transmission de paramètres via Map
- Transmission de paramètres avec un objet Java
- Transmisssion directe de paramètres JSON
- Transmission de paramètres de type collection (List, Set, Array)
- Paramètres de type objet + collection
Dans le développement d'applications, les opérations CRUD impliquent toujours la transmission de paramètres. Cet article présente 7 méthodes pourr transmettre des paramètres dans MyBatis.
La transmission d'un seul paramètre est simple, nous nous concentrerons donc sur la transmission de plusieurs paramètres.
- Transmission de paramètres anonymes par ordre
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - transmission anonyme")
@GetMapping("trouverParParametres")
public ResultMsg trouverParParametres(Short genre, String age)
{
List resultat = personnelMapper.selectParGenreEtAge(genre, age);
return ResultMsg.getMsg(resultat);
}
Mapper
List<personnel> selectParGenreEtAge(Short genre, String age);
</personnel>
XML
<select id="selectParGenreEtAge" resultMap="BaseResultMap">
SELECT * FROM personnel WHERE genre = #{param1} AND age = #{param2}
</select>
Important : En utilisant les noms de paramètres, vous obtiendrez l'erreur suivante. MyBatis indique clairement que les paramètres anonymes ne peuvent utiliser que des formes comme arg1, arg0, param1, param2.
BindingException: Parameter 'genre' not found. Available parameters are [arg1, arg0, param1, param2]
L'inconvénient de cette méthode est son manque de flexibilité - l'ordre des paramètres doit être strictement respecté.
- Utilisation de l'annotation @Param
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - méthode par annotation")
@GetMapping("trouverParParametres2")
public ResultMsg trouverParParametres2(Short genre, String age)
{
List resultat = personnelMapper.selectParGenreEtAge2(genre, age);
return ResultMsg.getMsg(resultat);
}
Mapper
Utilisez l'annotation @Param pour indiquer explicitement à MyBatis le nom du paramètre, ce qui permet de faire référence au paramètre par son nom dans le XML.
List<personnel> selectParGenreEtAge2(@Param("genre") Short genre, @Param("age") String age);
</personnel>
XML
<select id="selectParGenreEtAge2" resultMap="BaseResultMap">
SELECT * FROM personnel WHERE genre = #{genre} AND age = #{age}
</select>
- Transmission de paramètres via Map
L'utilisation d'une Map pour transmettre plusieurs paramètres est une méthode recommandée dans le développement réel.
Contrôleur
@ApiOperation(value = "Requête multi-paramètres")
@GetMapping("trouverParMap")
public ResultMsg trouverParMap(Short genre, String age)
{
Map<String, Object> parametres = new HashMap<>();
parametres.put("genre", genre);
parametres.put("age", age);
List resultat = personnelMapper.selectParMap(parametres);
return ResultMsg.getMsg(resultat);
}
Mapper
List<Personnel> selectParMap(Map<String, Object> parametres);
XML
En utilisant une Map pour transmettre plusieurs paramètres, vous pouvez faire référence directement aux noms de paramètres.
<select id="selectParMap" resultMap="BaseResultMap" parameterType="map">
SELECT * FROM personnel WHERE genre = #{genre} AND age = #{age}
</select>
- Transmsision de paramètres avec un objet Java
Il est également possible d'utiliser un objet pour transmettre plusieurs paramètres. Spécifiez simplement parameterType comme le type correspondant de l'objet.
L'avantage de cette méthode est sa commodité. Le contrôleur reçoit le paramètre d'entité via @RequestBody et le transmet directement au mapper sans conversion de paramètres supplémentaire.
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - transmission par objet Java")
@PostMapping("trouverParObjet")
public ResultMsg trouverParObjet(@RequestBody Personnel personnel)
{
List resultat = personnelMapper.selectParObjet(personnel);
return ResultMsg.getMsg(resultat);
}
Mapper
List<Personnel> selectParObjet(Personnel personnel);
XML
La référence aux paramètres utilise directement les champs de l'objet.
<select id="selectParObjet" resultMap="BaseResultMap" parameterType="com.example.modele.Personnel">
SELECT * FROM personnel WHERE genre = #{genre} AND age = #{age}
</select>
- Transmission directe de paramètres JSON
C'est également une méthode de transmission recommandée. Après avoir reçu des données JSON au niveau du contrôleur, transmettez-les directement au niveau du mapper pour l'opération de requête, simple et pratique.
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - transmission par JSON")
@PostMapping("trouverParJSON")
public ResultMsg trouverParJSON(@RequestBody JSONObject parametres)
{
List resultat = personnelMapper.trouverParJSON(parametres);
return ResultMsg.getMsg(resultat);
}
Mapper
List<Personnel> trouverParJSON(JSONObject parametres);
XML
<select id="trouverParJSON" resultMap="BaseResultMap" parameterType="com.alibaba.fastjson.JSONObject">
SELECT * FROM personnel WHERE genre = #{genre} AND age = #{age}
</select>
- Transmission de paramètres de type collection (List, Set, Array)
Dans certaines requêtes complexes (comme l'opérateur IN en SQL), la transmission de paramètres traditionnelle ne suffit pas. Il est alors nécessaire d'utiliser la transmission de paramètres de type List, Set, Array.
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - transmission par List, Set, Array")
@PostMapping("trouverParListe")
public ResultMsg trouverParListe(@RequestBody List<String> liste)
{
List resultat = personnelMapper.trouverParListe(liste);
return ResultMsg.getMsg(resultat);
}
Mapper
List<Personnel> trouverParListe(List<String> liste);
XML
<select id="trouverParListe" resultMap="BaseResultMap">
SELECT * FROM personnel WHERE age IN
<foreach collection="list" open="(" separator="," close=")" item="age">
#{age}
</foreach>
</select>
L'élément foreach représente une opération de boucle. Les attributs principaux sont item, index, collection, open, separator, close.
- item : alias pour chaque élément pendant l'itération
- index : nom indiquant la position pendant l'itération
- open : caractère de début de l'instruction
- separator : séparateur entre chaque itération
- close : caractère de fin de l'instruction
L'attribut le plus crucial et facile à erreur dans foreach est collection. Sa valeur varie selon le contexte :
-
Si un seul paramètre de type List est transmis, collection="list"
-
Si un seul paramètre de type array est transmis, collection="array"
-
Si plusieurs paramètres sont transmis, ils doivent être encapsulés dans une Map ou un Object
-
Paramètres de type objet + collection
Ce type de paramètre est similaire au paramètre d'objet Java, mais plus complexe. Par exemple, la classe Département ci-dessous inclut non seulement des champs de base, mais aussi une liste d'Employés.
Objet
@Data
public class Departement {
private Long id;
private String nomDept;
private String description;
private Date creation;
private List<Employe> employes;
}
Contrôleur
@ApiOperation(value = "Requête multi-paramètres - objet + collection")
@PostMapping("trouverParDepartement")
public ResultMsg trouverParDepartement(@RequestBody Departement departement)
{
List resultat = personnelMapper.trouverParDepartement(departement);
return ResultMsg.getMsg(resultat);
}
Mapper
List<Personnel> trouverParDepartement(@Param("departement") Departement departement);
XML
<select id="trouverParDepartement" resultMap="BaseResultMap" parameterType="com.example.modele.Departement">
SELECT * FROM personnel WHERE dept_id = #{departement.id} AND age IN
<foreach collection="departement.employes" open="(" separator="," close=")" item="employe">
#{employe.age}
</foreach>
</select>
Ici, foreach correspond à la liste d'employés du Département.
Exemple de paramètre de requête : Rechercher les employés du département avec l'ID=1, et dont l'âge est 24 ou 25.
{
"creation": "2019-07-02T10:17:16.756Z",
"nomDept": "Informatique",
"description": "Développement logiciel",
"employes": [
{
"age": "24"
},
{
"age": "25"
}
],
"id": 1
}