1. Overview
When select mapping in MyBatis, the return type can be used with resultType or resultMap. resultType directly represents the return type, while resultMap is a reference to the external ResultMap, but resultType and resultMap cannot exist at the same time.
When MyBatis is querying mapping, in fact, each attribute query is placed in a corresponding map, where the key is the attribute name and the value is its corresponding value.
① When the provided return type attribute is resultType, MyBatis will take out the key value pairs in the map and assign them to the corresponding attributes of the object specified by resultType. So in fact, the return type of each query map of MyBatis is ResultMap. However, when the provided return type attribute is resultType, MyBatis automatically assigns the corresponding value to the attributes of the object specified by resultType.
② When the provided return type is resultMap, because the Map cannot represent the domain model well, it needs to further convert it into the corresponding object itself, which is often very useful in complex queries.
2. ResultsType
Blog.javapublic class Blog {private int id;private String title;private String content;private String owner;private List<Comment> comments;}The corresponding database table stores id, title, Content, and Owner attributes.
<typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/><select id="selectBlog" parameterType="int" resultType="Blog">select * from t_blog where id = #{id}</select>MyBatis will automatically create a ResultMap object, and then encapsulate the key value pair based on the found attribute name. Then, you will see that the return type is a Blog object, and then take out the key value pair corresponding to the Blog object from the ResultMap and assign it.
3. ResultMap
It is also very useful when the return type is directly a ResultMap, which is mainly used for complex joint queries, because it is not necessary to conduct simple queries. Let’s first look at a simple query with a return type ResultMap, and then look at the usage of complex queries.
①Writing a simple query
<resultMap type="Blog" id="BlogResult"><id column="id" property="id"/><result column="title" property="title"/><result column="content" property="content"/><result column="owner" property="owner"/><result column="owner" property="owner"/><result column="owner" property="owner"/><result column="owner" property="owner"/><</resultMap><select id="selectBlog" parameterType="int" resultMap="BlogResult">select * from t_blog where id = #{id}</select>The value of resultMap in the select map is the id of an external resultMap, indicating which result is mapped to. The type attribute of the external resultMap indicates what type the result of the resultMap is. Here is the Blog type, so MyBatis will take it out as a Blog object. The child node id of the resultMap node is used to identify the id of the object, while the result child node is used to identify some simple properties. The Column property represents the attributes queried from the database, and the Property represents which property the corresponding value of the queryed property is assigned to the entity object. This is how to write resultMap for simple query.
②Complex query
There is a Comment class, which has a Blog reference, indicating which Blog it is for. When querying Comment, the corresponding Blog must also be found and assigned to its blog attribute.
public class Comment {private int id;private String content;private Date commentDate = new Date();private Blog blog;}<!--From CommentMapper.xml file--><resultMap type="Comment" id="CommentResult"><association property="blog" select="selectBlog" column="blog" javaType="Blog"/></resultMap><select id="selectComment" parameterType="int" resultMap="CommentResult">select * from t_Comment where id = #{id}</select><select id="selectBlog" parameterType="int" resultType="Blog">select * from t_Blog where id = #{id}</select>First, request the select map with id as selectComment, and then obtain a ResultMap object with id as CommentResult. You can see that the return type of the corresponding resultMap is a Comment object, which has only one association node, and there is no id and result child nodes corresponding to the simple query mentioned above. However, it will still assign the corresponding id and other attributes to the Comment object. This is what the MyBatis mentioned earlier It has automatic encapsulation function. As long as the return type is provided, MyBatis will use the query results to encapsulate the corresponding object according to its own judgment. Therefore, in the simple query above, if it does not clearly indicate which field corresponds to id and which field corresponds to title in the resultMap, MyBatis will also help encapsulate it according to its own judgment. MyBatis's own judgment is to compare the field of the query or its corresponding alias with the attributes of the return object. If it matches and the type also matches, MyBatis will assign it. A blog attribute is associated in the corresponding resultMap above, and its corresponding java type is Blog. In the above writing method, the associated object is associated through subqueries, and of course, it can also be associated directly through the association query. In the above association child node, the Property attribute indicates which associated property is the resultMap return type. For the example above, the blog attribute managed by Comment; select indicates which select map to map the corresponding associated attribute, that is, it will request a select map with the value corresponding to select to query the attribute object associated; Column indicates the key-value pair corresponding to the resultMap with id CommentResult. This key-value pair will be used as a parameter for the subquery of the associated object, that is, the value of the blog attribute query in selectComment is passed as a parameter to the subquery of the associated object blog to the subquery of the associated object blog; javaType indicates what type of the current associated object is in JAVA.
The above introduces a query of one-to-one or one-to-many relationships in the case of one-to-one. In actual applications, there is another application that uses more frequently. It is to find out the corresponding more parties through one-to-one. When taking out the more parties, it also needs to associate one-to-one: when taking out the Blog object, take out all the corresponding Comments, and when taking out the Comment, it still needs to take out the corresponding Blog, which is taken out in Java through a request.
<!-- From BlogMapper.xml file--><resultMap type="Blog" id="BlogResult"><id column="id" property="id"/><collection property="comments" select="selectCommentsByBlog" column="id" ofType="Comment"></collection></resultMap><resultMap type="Comment" id="CommentResult"><association property="blog" javaType="Blog" column="blog" select="selectBlog"/></resultMap><select id="selectBlog" parameterType="int" resultMap="BlogResult">select * from t_blog where id = #{id}</select><select id="selectCommentsByBlog" parameterType="int" resultMap="CommentResult">select * from t_Comment where blog = #{blogId}</select>The entry of the above request is a select map with id selectBlog, and the return result is a resultMap with id BlogResult. The type of id BlogResult is Blog, which specifies the attributes and fields of id. Specifying id will have a great effect on the internal construction of MyBatis. It is associated with a comments object. Because a Blog can have many comments, which are a collection, so it is mapped with a collection collection. The select still indicates which subquery is performed to query the corresponding comments. column means which field value found above is passed to the subquery as a parameter. ofType also represents the return type. The return type here is the type inside the collection. The reason why ofType is used instead of type is that it is used within MyBatis to distinguish it from the association association.
public void selectCommentsByBlogTest() {SqlSession session = Util.getSqlSessionFactory().openSession();CommentMapper commentMapper = session.getMapper(CommentMapper.class);List<Comment> comments = commentMapper.selectCommentsByBlog(6);for (Comment comment: comments)System.out.println(comment);session.close();}public void testSelectOne() {SqlSession session = Util.getSqlSessionFactory().openSession();BlogMapper blogMapper = session.getMapper(BlogMapper.class);Blog blog = blogMapper.selectBlog(6);List<Comment> comments = blog.getComments();if (comments != null) {for (Comment comment: comments)System.out.println(comment);}session.close();}The above is the resultType and resultMap in Mybatis introduced to you by the editor. I hope it will be helpful to you. If you have any questions, please leave me a message and the editor will reply to you in time. Thank you very much for your support to Wulin.com website!