mybatis输入输出映射—

0.#{}与${}区别

#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?。

<!-- 根据id查询用户信息 -->

	<select id="findUserById" parameterType="int" resultType="user">

		select * from user where id = #{id}

	</select>

使用占位符#{}可以有效防止sql注入，在使用时不需要关心参数值的类型，mybatis会自动进行java类型和jdbc类型的转换。#{}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}和#{}不同，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。使用${}不能防止sql注入，但是有时用${}会非常方便，如下的例子：

<!-- 根据名称模糊查询用户信息 -->

	<select id="selectUserByName" parameterType="string" resultType="user">

	   select * from user where username like '%${value}%'

	</select>

如果本例子使用#{}则传入的字符串中必须有%号，而%是人为拼接在参数中，显然有点麻烦，如果采用${}在sql中拼接为%的方式则在调用mapper接口传递参数就方便很多。

再比如order by排序，如果将列名通过参数传入sql，根据传的列名进行排序，应该写为：

ORDER BY ${columnName}

如果使用#{}将无法实现此功能。

实际可以这么理解，#{}会在里面加上单引号。${}不会加上单引号。比如:

如果变量的值是:safehatnum

(1)#{}加引号

select * from safehat order by #{order};

相当于

select * from safehat order by 'safehatnum';

(2)${}不加引号

select * from safehat order by ${order};

相当于

select * from safehat order by safehatnum;

--------------------------------parameterType输入类型--------------------

通过parameterType指定输入参数的类型，类型可以是简单类型、hashmap、pojo的包装类型

1 传递简单类型

1.int型

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAwsAAAA6CAIAAABwClJ4AAAPOUlEQVR4nO2dPZKjPBCGOc8egWQusUfY4g6OTDI5CTXRpptQTklduOYMJARbE3MIbcCffrpbAjQ29r5Pub5v1iDRSI300i1wogAAAAAAgEnyaAMAAAAAAA4HFBIAAAAAgA0UEgAAAACADRQSAAAAAIANFBIAAAAAgM29FFJbvZ3Pw+e9vdMxWerqnJzLohd2abPzOQs19JqpH4n63SlVqx+JOtX2Dn8L9SMZPz8L+3v9m1UMxa8bSx8X67y8zQsOhdxfO31+1bEeTF2dk/PwqQ5lWDB3bt64vnF06m8Zvf+vNhSJ4r13jiG17xEVUlu9navPDQVjK6TfqfqRqr+Td/7ujK2CjtnpzddM/cjGv0+WB9SEJbEYPG/5pOpvQCldJo6fjN5TPy/la95npa7OSRXnUuiacpqJtU/ZPKihQi6HdT7fqZ/MAPcMvtFWpEIiHeCpujI6rG/wDhCfex3LGuVWIFp4ZIV0z0lKRfLeAIXU39L8EslhjqGQQupeqZAGj7xmhFyYt0ZnqblTP00P+FuECpddx50OveIEA+6crBaTm/dZiaiQZrqmfNxsOhO/v3ifeQbfWKOQZl61K7fxPeGWxx5r+7xwz9aIyH0nKcV5b39L8w8xPGLgU0jtJcnz9BZcn6+6l1RIszQmnN5xi4gskty5ZrbfoKw67vTP8Es9ZKh162eb93l5XYUUvb+EkfQZfOOJFdJBmve7p9KHHMsOqARzz9aIyX0nKcV7b33JkzwPnN4lhdTdPsiKvppyXlRkaxRtvdEbcfkzCkkq1f8p52OdfzW9Y4CxyYO8MkDbek5WKCSSU+IklTQl8Tsdv7EvksmNTtS6JbfaQXu5ssPyiROf29JTZlaRU22kxq7DBlPz6Yd284nuKPA7pa8K8ry20WbnsujbbO5K06X0Xk41p6mrc9r0qq1IDyFLdU2ZVE1Rjl+O+2iH00tN7tQP+5sfI+dLlfJbqKhptWtK4kTGfVY01L5rYWCDz89F9M+uDEh4L5unbPba0lDWrRR1Z2UrJL8DqKN3pVJjr9mDg2/44uB8w+8ApBlUWeumyx0Ptznb71Sd6rHs/Mdw1tJ4OI2i80GthiKNly1kry/+lCU69TNRVxVkYcgleddJyntyt4/A0A+rkOpLnpDBKD5y89WU2qb+T+nKHUIhiaXad1ppeSzxQdzV9UXJDHx1ljikReAMTur9azYqAPfObO7sYQejuJXP0iS5XY+ZqBZiPCfdF/Ws8HCs1FjnpF/2tCtbeWUqzUzcOfHntY1xnhi7r29SbVbomnKZIdpKnzDGWWSccgx/4EoNq0bSpp//0FzL9CjTDMWGEKRSgoWznU7goc0MIahP4UJD8WZsvBw2+rxSamWQ0gPfhr6Wp4ehDQrJW6dSh+5KNc1YV+d7b1dytXG+McA5AGeGPKTI7rTW2WZtNBjzs1DXbKqBHw/H1ULptFW30DcekhbKbbjlCpqkp56mMGaHqcLAVT73nKSC6G9pnicXzw0DqZD64iNPuLVHbcU8j9b/Kc1ADqFgXIUklfpqyrey+eJsj6mQ7G9WZdkEuJDJgCsXluX3SilziLGq0jeRK+Cu2lFIG6wgp+Honfpplpqdz7oVOCX2P2dLiCAqlXMUzmsbdt8FTm/aHblSUppjKTXvs9zfz47UN6kbGbLCS65VYimvhaTNeilzB76hfMbvYJXPKxU7T822obfl6efR7qmQjtKV/D2Mpyt90IknzgHE1WnCkMKNh9KxRJuH2uY/hqjSvJUcD62G0o/rGQ99FpJtKJ0ywzAdLFWZFrqZDW8Y6Z6TVDBtlufJx03o8PUxJKVU3/wiclvtu5P5ClBIUqnPig8gqagKyYlgx1JIkusEyAVrLbZe1bLJCdWQF5WbvXLzgNd5G/+UgXV5WJFkYfH4XO1V/0Y4r61Qs8U8l/RNaiY4AuIEbClJIS15HDI7wxxOLOWd22hVt8yRfVFK0/nSUD7jN7PK50er9sYUDdg29J2y9pSZLjjuqpCO0ZXC8hFPV8qsVEKsGd4hhRkPhWP5bdaMP2nVcuMh6+Re42ULuTYUTpnBTorNM4J7iBBZed9JKogdMaTJZmYdknaM5tcikkJWYdMKiSv1WZ0PEEPakWUTXYd8CwC3SNmqyhD4zjXDDUyuAOdsE9ZTWxZae/4tiBspwwCrWuG8tiLfT3N5Cn7G4kv5FJL0FhxeIbGlNiokffGNsZVvKMGM3UnncJ+fi0RclyoqpKC3FnVNqYmk+yqkQ3SloHvkrpTh3orCOQBrRvCQ4qaH1jrbsn+t/aGdBTceEqNoFmS8bKH3DXnhz71bzbuM8+SCa2+j3XeS8hP8CNrOZ9mMHJm5ooiuzrcOyapeV2D01k1PxhGjhpbjnwIG+2NIot5ffL1TJzLuov9Tv7ewMsTmbQebm3euHyEmyY4+pmwnrrdhh4K+vSNyjsJ5bcWcLdpqmc+oZT2BCoksJSkkap2QjrvwVvlKbVZIqm/Sc5VVlkvzDeUzfivrfH4uco8YUvgpG3krvZS5GGiG0SiMA2hbD9qV8uofoSvnOAFRlvSN+XsuhsSbMYwhQ53cLOvWLDkbZfysbOY//hbU0kzyS/1hF2qcJ42XLweuDaXiZKdQQo2YicgpgK/wTpOUj2jPso2Y70OyniOz5Iv9lNl0YX5WTipNu2a5UkoZGT35cCHPsmnPerhPdizh6LLorSD2Njwid34KQ38WzIrHWP+c96c82KpNKSN0SSz157bybySzl2lTZ3dyvzefN7EKCue1DauX3XTq/Ehaq/eyoD+4UqJCUu5TS/zjUXrihi21XSGNdRJ3BVxD+YzfyEqfHzhxDrzFAKkNuVO2vjefO9PSWFmrjxviaGNX63+WzSz12K40HqoK78pa7ETHN2Y4ByDNUMKQIo+H4rFI4+fI0Dxbk2t0yMA5N4p6x0PpcnDb0HvKZKdYI7YwnrtTANPLd5ukPER+HxLYwYHf0fJtfPNrUkOItYbsleiL0ni1gVIKDfWcoCufiQOMhxt41lcufQNQSN/FgX8G4ds4xm9jYbawYRI6aKjnA135RBxjPNzA/3hvzwCFFJ/59Vb/jzyaw93XR1uiMFtozOmVkCfVwZFBVz4RhxoPN7D5fd+vBxQSAAAAAIANFBIAAAAAgA0UEgAAAACADRQSAAAAAIANFBIAAAAAgA0UUhTqLMmw9v/FqTPvrzLUWRLLEboiXfeLHpJNI5FMG2vcbRkAAByaQyikaTJwxnHnh4OWQbkrUm6IFko5RxuPZVkQ/BtFXZGmRadUnY3/C5uEeAutLbYF+marmcym8c+GXZFaO5lNuqFTPMZzLeHsN+oM10J9721meHzDa2s8hTS5jlJ1RjdBXAUSUbwppSj/AQCA1+LxCqnO+OlcGNU9Cokbuu2j1Zm5p1CtUGGaZVmWhegSn4XGlq5ItXnSnJK0Exm1zLSj9U8OUSFt6xTBeMkKSh6kRRegkNabEVsnSIf27jqY1RWpU2a1G0Y1LYxvsBEAAI7EwxWSeLMcWyH578y3DftrSwXO7rpGEARNV6RJVkwhia5Is5oKSxA2cwppY6ewxstWfKtCIoTlYRTSsCdVBgoJAAAezsMVkpgSiqyQAlIXq4f9IUYxxZACiwbO7nokhygync4QhOiKNKtHgUQmbijDGYW0sVNY4wXmMubRoykky4xtOkFeymNl7rzV0yldo8MIN5RbwzKD6HzGgYx4qrkHndKVbAQAgFfi4QpJaSMxuRqDmX3WrEPSFxt55q+Vw/6OdUj87B56urqSGJbtzDppp0JS2zqFMz6oKZZVPlPaSV4cts0MwaNW2Gq2GS3AnCOZbdlpMT/XCNJBTEVkHnnsd+0k7eLrFJJTu9ceAAB4NY6gkAbm+dC6LY4XQ/oGhaQdcu1US8+ci+1urohTSJMc6oo0TdNZbgScqbRSe9kpuFM4431mDJouLYpMV3wRYkjuPrtyTf7qwqufNSwhU0KSxKKjUmasUkhO7eI1hQXbAICX5DgKacBcWPs0CmklYRkiPRBE2T7tS6z5jaWQtF0DOoUz3mdGWnSDxJz/O8eS9mbZbDPiKiTHwpDqqeBS4ibZ5MSW01dOwG2XQiJtvMNiKQAAOBBHU0jm5BB5HVLA41VHUkhC2mPaOuX2qPBSyEztVEgXCuwU1niBocGLbE61LcvMo61DEtbarGJVDEnOshnLr1yDWDccy1nHtR17dwwppJkgkAAAL87RFJK5hCKyQiJyGLuf9t9E4OxOrAwymoYJJzDfkcfi1rU4O4Z0ij8xyFWuT81pmkZUSJYZkRWSbtEUxQmqnkuykUY7NmQZEUCy1mEFKCS9mNkNIfFWKCQAwIvzcIXEL8khNvIvNEysNBBfp7n5MZmD0NmdEieO5ZsVkmLbYmOnyMaLJlidN4dXZIW03gyPbwS0Et9WadGFxO6Usl6sQJgg9N/g+FSHL3bUmhmBxidZbRlvX2FIsgEA/jMerpAAADbPoD6ewUYAANgBFBIAx8PMgB6RoBeCAgDAEwOFBMARmZJcB9RJY27ugJYBAEBEoJAAAAAAAGygkAAAAAAAbKCQAAAAAABsoJAAAAAAAGygkAAAAAAAbHYqpL74yNNbv6uOtno7n4fPe7vPHAAAAACAGOxTSO0lyS+RXonSvkdUSG31dq4+I1UGAAAAgP+NAIXU31JGBtWX3QGkhbsopP6W5h9FLJMBAAAA8KL4FFJ7SXJGBkVWG3eKIdWXPMnzDOk8AAAAAPBICqm7fQhiort9JBd721dTzouKbI2irTd6q9xKGYUkler/lPOxzr+a3jHA2GSdV7zoFwAAAABeDVYh1Zc8kUJEbeaKJz5y89WU2qb+T+nKHUIhiaXad1ppeSyZKrulee4qPAAAAAAAxSikvvjIPUuwyTXabcU8j9b/Kc1ADqFgXIUklfpqyrey+WLNC1mp3WZ5nnzc8ONSAAAAALDYFkPiH/Lvm19Ebqt9dzJfAQpJKvVZ8QEkhRgSAAAAAHaxaR1SyBrtvvm1iKSQVdi0QuJKfVbn7TEkYfk5AAAAAMC2Z9nqS0j0xciRmSuK6CP51iFZ1esKjN5Kqis8ywYAAAAALxveh0St0VZKOc+RWfLFfspsypF9Vk4qTUufcaWUMjJ68uGWTXgfEgAAAAACWP1O7e72gdXNAAAAAHht1iqkGD/EBgAAAABwbHb+ci0AAAAAwAvyD2I6yx5k4vklAAAAAElFTkSuQmCC" alt="" />

2.String型

<select id="findUserByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">

        SELECT * FROM USER WHERE username like '%${value}%'

    </select>

2. 传递POJO对象

Mybatis使用ognl表达式解析对象字段的值，如下例子：

 　　<!-- 更新用户，根据Id更新 ,需要传入Id（int型）与更新信息

    parameterType类型为User类型，指定需要修改的用户id和修改后的属性值，#{username}表示从传入的对象中取对应的username属性

    #{id}表示从user对象中获取id

    -->

    <update id="updateUserByTd" parameterType="cn.itcast.mybatis.po.User">

    update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}

    where id=#{id}

    </update>

异常测试：

Sql中字段名输入错误后测试，username输入dusername测试结果报错：

org.apache.ibatis.exceptions.PersistenceException:

### Error querying database.  Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'

### Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-priority:99;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin:0cm;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.5pt;
mso-bidi-font-size:11.0pt;
font-family:"Calibri","sans-serif";
mso-ascii-font-family:Calibri;
mso-ascii-theme-font:minor-latin;
mso-hansi-font-family:Calibri;
mso-hansi-theme-font:minor-latin;
mso-font-kerning:1.0pt;}

3. 传递pojo包装对象(传递QueryVo，取值的时候取其属性User对象的属性，相当于取传的对象的属性的属性，只不过对象的属性是对象)

开发中通过pojo传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

3.1 定义包装对象

定义包装对象将查询条件(pojo)以类组合的方式包装起来。

aaarticlea/png;base64,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" alt="" />

3.2 mapper.xml映射文件

aaarticlea/png;base64,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" alt="" />

说明：mybatis底层通过ognl从pojo中获取属性值：#{user.username}，user即是传入的包装对象的属性。queryVo是别名，即上边定义的包装对象类型。

4. 传递hashmap

Sql映射文件定义如下：

<!-- 传递hashmap综合查询用户信息 -->

    <select id="findUserByHashmap" parameterType="hashmap" resultType="user">

       select * from user where id=#{id} and username like '%${username}%'

    </select>

上边红色标注的是hashmap的key。

测试：

Public void testFindUserByHashmap()throws Exception{

        //获取session

        SqlSession session = sqlSessionFactory.openSession();

        //获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        //构造查询条件Hashmap对象

        HashMap<String, Object> map = new HashMap<String, Object>();

        map.put("id", 1);

        map.put("username", "管理员");

        //传递Hashmap对象查询用户列表

        List<User>list = userMapper.findUserByHashmap(map);

        //关闭session

        session.close();

    }

异常测试：

传递的map中的key和sql中解析的key不一致。

测试结果没有报错，只是通过key获取值为空。

5.传递List

sql定义:(输入类型为List,collection定义为list)

    <select id="getQuestionsForExamPaper" parameterType="java.util.List"

        resultMap="questionAndOptionForPaper">

        SELECT * FROM questions q,options o WHERE

        q.questionId=o.questionId and

        q.questionId in

        <foreach collection="list" item="id" separator="," open="("

            close=")">

            #{id}

        </foreach>

    </select>

Java 测试:

    // 测试根据ID集合查询试题

    @Test

    public void test2() throws SQLException {

        Map<String, Object> condition = new HashMap<String, Object>();

        condition.put("type", "单选题");

        condition.put("level", 1);

        condition.put("num", 3);

        List<String> IDs = questionsCustomMapper.getQuestionsIdsForExamPaper(condition);

        List<Questions> questions = questionsCustomMapper.getQuestionsForExamPaper(IDs);

        System.out.println(questions.size());

    }

foreach 的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item，index，collection，open，separator，close。item表示集合中每一个元素进行迭代时的别名，index指定一个名字，用于表示在迭代过程中，每次迭代到的位置，open表示该语句以什么开始，separator表示在每次进行迭代之间以什么符号作为分隔符，close表示以什么结束，在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有一下3种情况：

如果传入的是单参数且参数类型是一个List的时候，collection属性值为list .
如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array .
如
果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map，实际上如果你在传入参数的时候，在MyBatis里面也
是会把它封装成一个Map的，map的key就是参数名，所以这个时候collection属性值就是传入的List或array对象在自己封装的map
里面的key.

------------------------------------resultType输出类型----------------------------------------

1. 输出简单类型

Mapper.xml文件

<!-- 获取用户列表总数 -->

    <select id="findUserCount" parameterType="user" resultType="int">

       select count(1) from user

    </select>

Mapper接口

public int findUserCount(User user) throws Exception;

测试:

Public void testFindUserCount() throws Exception{

       //获取session

       SqlSession session = sqlSessionFactory.openSession();

       //获取mapper接口实例

       UserMapper userMapper = session.getMapper(UserMapper.class);

       User user = new User();

       user.setUsername("管理员");

       int count = userMapper.findUserCount(user);

       //关闭session

       session.close();

    }

总结：

输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

使用session的selectOne可查询单条记录。

2. 输出pojo对象

Mapper.xml

   <!-- 根据id查询用户信息 -->

    <select id="findUserById" parameterType="int" resultType="user">

       select * from user where id = #{id}

    </select>

Mapper接口：

public User findUserById(int id) throws Exception;

测试：

Public void testFindUserById() throws Exception {

       //获取session

       SqlSession session = sqlSessionFactory.openSession();

       //获限mapper接口实例

       UserMapper userMapper = session.getMapper(UserMapper.class);

       //通过mapper接口调用statement

       User user = userMapper.findUserById(1);

       System.out.println(user);

       //关闭session

       session.close();

    }

使用session调用selectOne查询单条记录。

3. 输出pojo列表(list集合)

Mapper.xml

<!-- 根据名称模糊查询用户信息 -->

    <select id="findUserByUsername" parameterType="string" resultType="user">

       select * from user where username like '%${value}%'

    </select>

Mapper接口：

public List<User> findUserByUsername(String username) throws Exception;

测试：

Public void testFindUserByUsername()throws Exception{

       //获取session

       SqlSession session = sqlSessionFactory.openSession();

       //获限mapper接口实例

       UserMapper userMapper = session.getMapper(UserMapper.class);

       //如果使用占位符号则必须人为在传参数中加%

       //List<User> list = userMapper.selectUserByName("%管理员%");

       //如果使用${}原始符号则不用人为在参数中加%

       List<User> list = userMapper.findUserByUsername("管理员");

       //关闭session

       session.close();

    }

使用session的selectList方法获取pojo列表。

4. 输出hashmap(一般不用,在需要查询指定列并转为接送的时候可以使用)

　　输出pojo对象可以改用hashmap输出类型，将输出的字段名称作为map的key，value为字段值。

　　这样一个语句简单作用于所有列被自动映射到 HashMap 的键上,这由 resultType 属性指定。这在很多情况下是有用的,但是 HashMap 不能很好描述一个领域模型。那样你的应用程序将会使用 JavaBeans 或 POJOs(Plain Old Java Objects,普通 Java 对象)来作为领域模型。

    <!-- S 查询部门树 -->

    <select id="getDepartmentTreeForExam" resultType="map">

        SELECT

        departmentId,upDepartmentId,departmentName FROM department

    </select>

    <!-- E 查询部门树 -->

mapper接口:

    /**

     * 查询部门id，上级id，部门名称生成内部部门树

     *

     * @return 一个map包含部门的部门id，上级id，部门名称

     * @throws SQLException

     */

    public List<Map<String,Object>> getDepartmentTreeForExam() throws SQLException;

测试:

package cn.xm.exam.test.daoTest;

import java.sql.SQLException;

import java.util.List;

import java.util.Map;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.xm.exam.mapper.employee.in.custom.DepartmentCustomMapper;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:spring/applicationContext-*.xml")

public class DepartmentCustomMapperTest {

    @Autowired

    private DepartmentCustomMapper departmentCustomMapper;

    @Test

    public void testGeneDepartmentTree() throws SQLException {

        List<Map<String, Object>> departmentTree = departmentCustomMapper.getDepartmentTreeForExam();

        System.out.println(departmentTree);

    }

}

结果:

[{departmentId=10, departmentName=厂级-1}, {departmentId=10001, departmentName=部门1_10, upDepartmentId=10}, {departmentId=10001001, departmentName=班组1_10001, upDepartmentId=10001}, {departmentId=10002, departmentName=部门2_10, upDepartmentId=10}, {departmentId=10002001, departmentName=班组2_10002, upDepartmentId=10002}, {departmentId=10003, departmentName=部门3_10, upDepartmentId=10}, {departmentId=11, departmentName=厂级-2}, {departmentId=11001, departmentName=部门1_11, upDepartmentId=11}, {departmentId=12, departmentName=厂级-3}]

5.输出Set集合(去掉重复元素)

接口:

    /**

     * 根据用户ID查询用户所有的角色名称

     * @param userId    用户ID

     * @return

     * @throws SQLException

     */

    public Set<String> getUserRoleNameByUserId(@Param("userId") String userId)throws SQLException;

XML实现:

    <!--4.根据userid查询所有的用户角色名称-->

    <select id="getUserRoleNameByUserId" resultType="string" parameterType="string">

        SELECT DISTINCT

          roleName

        FROM role

        WHERE roleid IN(SELECT

                          roleid

                        FROM user_role

                        WHERE userid = #{userId})

    </select>

resultType总结:

　　输出pojo对象和输出pojo列表在sql中定义的resultType是一样的。

　　返回单个pojo对象要保证sql查询出来的结果集为单条，内部使用session.selectOne方法调用，mapper接口使用pojo对象作为方法返回值。

　　返回pojo列表表示查询出来的结果集可能为多条，内部使用session.selectList方法，mapper接口使用List<pojo>对象作为方法返回值。

---------------------- ----------- resultMap输出结果---------------------------------------------

　　resultType可以指定pojo将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。

如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系，resultMap实质上还需要将查询结果映射到pojo对象中。

resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。

1 Mapper.xml定义

aaarticlea/png;base64,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" alt="" />

2. 定义resultMap

<!-- 定义resultMap

    将SELECT id id_,username username_ FROM USER 和User类中的属性作一个映射关系

    type：resultMap最终映射的java对象类型,可以使用别名

    id：对resultMap的唯一标识

     -->

     <resultMap type="user" id="userResultMap">

         <!-- id表示查询结果集中唯一标识

         column：查询出来的列名

         property：type指定的pojo类型中的属性名

         最终resultMap对column和property作一个映射关系 （对应关系）

         -->

         <id column="id_" property="id"/>

         <!--

         result：对普通名映射定义

         column：查询出来的列名

         property：type指定的pojo类型中的属性名

         最终resultMap对column和property作一个映射关系 （对应关系）

          -->

         <result column="username_" property="username"/>

     </resultMap>

<id />：此属性表示查询结果集的唯一标识，非常重要。如果是多个字段为复合唯一约束则定义多个<id />。

Property：表示person类的属性。

Column：表示sql查询出来的字段名。

Column和property放在一块儿表示将sql查询出来的字段映射到指定的pojo类属性上。

<result />：普通结果，即pojo的属性。

3. Mapper接口定义

public List<User> findUserListResultMap() throws Exception;

参考:http://www.cnblogs.com/qlqwjy/p/7295426.html

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE