The main use of foreach is in the build in condition , which can iterate a collection in an SQL statement. The properties of the Foreach element are mainly item,index,collection,open,separator,close.
Item represents the alias at which each element in the collection iterates.
index specifies a name that represents the position of each iteration during the iteration,
Open indicates what the statement starts with,
Separator indicates what symbol is used as a delimiter between each iteration.
Close indicates what ends with,
The most critical and error-prone thing when using foreach is the collection property, which must be specified, but in different cases the value of the property is not the same ,
There are 3 main cases:
1. If a single parameter is passed in and the parameter type is a list, thecollection property value is List
2. If a single parameter is passed in and the parameter type is an array, thevalue of the collection property is array
3. If the parameters passed in are multiple , we need to encapsulate them into a map , of course, the single parameter can also be encapsulated into a map, in fact, if you pass in the parameters, In breast it will be encapsulated into a map, themap key is the parameter name , so this time the collection property value is the incoming list or array object in its own encapsulated map key
Here's a look at the sample code for each of the three scenarios:
1. Type of single parameter list:
<select id= "Dynamicforeachtest" resulttype= "Blog" >
SELECT * from T_blog where ID in
<foreach collection= "list" index= "index" item= "Item" open= "(" separator= "," close= ")" >
#{item}
</foreach>
</select>
The value of the above collection is List, the corresponding mapper is the public list<blog> dynamicforeachtest (list<integer> IDs);
Test code:
@Test
public void Dynamicforeachtest () {
sqlsession session = Util.getsqlsessionfactory (). Opensession ();
Blogmapper blogmapper = Session.getmapper (Blogmapper.class); Annotation patterns are used here
list<integer> ids = new arraylist<integer> ();
Ids.add (1);
Ids.add (3);
Ids.add (6);
list<blog> blogs = blogmapper.dynamicforeachtest (IDS);
for (Blog blog:blogs)
SYSTEM.OUT.PRINTLN (blog);
Session.close ();
}
2. Type of single-parameter array arrays:
<select id= "Dynamicforeach2test" resulttype= "Blog" >
SELECT * from T_blog where ID in
<foreach collection= "array" index= "index" item= "Item" open= "(" separator= "," close= ")" >
#{item}
</foreach>
</select>
The above collection is an array, corresponding to the Mapper code: public list<blog> dynamicforeach2test (int[] IDs);
The corresponding test code:
@Test public void Dynamicforeach2test () {
sqlsession session = Util.getsqlsessionfactory (). Opensession ();
Blogmapper blogmapper = Session.getmapper (Blogmapper.class);
int[] ids = new int[] {1,3,6,9};
list<blog> blogs = blogmapper.dynamicforeach2test (IDS);
for (Blog blog:blogs)
SYSTEM.OUT.PRINTLN (blog);
Session.close ();
}
3. Encapsulate the parameters as a map type
<select id= "Dynamicforeach3test" resulttype= "Blog" >
SELECT * from T_blog where title like "%" ${title} "%" and ID in
<foreach collection= "IDs" index= "index" item= "Item" open= "(" separator= "," close= ")" >
#{item}
</foreach>
</select> the value of the above collection is IDs, which is the key of the incoming parameter map, corresponding to the Mapper code:
Public list<blog> dynamicforeach3test (map<string, object> params);
Corresponding Test code:
@Test
public void Dynamicforeach3test () {
sqlsession session = Util.getsqlsessionfactory (). Opensession ();
Blogmapper blogmapper = Session.getmapper (Blogmapper.class);
final List<integer> ids = new arraylist<integer> ();
Ids.add (1); Ids.add (2);
Ids.add (3); Ids.add (6);
Ids.add (7); Ids.add (9);
map<string, object> params = new hashmap<string, object> ();
Params. put("IDs", IDs); Params.put ("title", "China");
list<blog> blogs = blogmapper.dynamicforeach3test (params);
for (Blog blog:blogs)
SYSTEM.OUT.PRINTLN (blog);
Session.close ();
}
MyBatis's foreach statement