Mybatis XML查询List功能全面解析与实战应用！

在Mybatis中，使用XML进行查询List是一种常见的需求，特别是在处理复杂查询和分页场景时。本文将通过一个具体的例子，展示如何使用Mybatis XML配置文件来实现一个查询List的功能。假设我们需要从一个数据库中查询用户信息，并将结果以List的形式返回。这里我们将使用MySQL作为数据库，Mybatis作为ORM框架。

首先，我们需要创建一个数据库表来存储用户信息。假设表名为`users`，包含以下字段：`id`（主键）、`username`（用户名）、`email`（邮箱）和`age`（年龄）。以下是创建该表的SQL语句：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    age INT NOT NULL
);

接下来，我们需要在Mybatis中配置Mapper XML文件。假设我们的Mapper XML文件名为`UserMapper.xml`，位于`src/main/resources`目录下。在这个文件中，我们将定义一个查询List的SQL语句。首先，我们需要在XML文件中定义命名空间和ID，如下所示：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>
</mapper>

在这个示例中，`resultType=”com.example.entity.User”`表示查询结果将映射到`User`实体类中。假设我们的`User`实体类定义如下：

public class User {
    private Integer id;
    private String username;
    private String email;
    private Integer age;

    // 省略getter和setter方法
}

接下来，我们需要在Mybatis的配置文件`mybatis-config.xml`中注册这个Mapper XML文件。假设我们的Mapper XML文件位于`src/main/resources`目录下，配置如下：

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_db"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>

    <mapper resource="com/example/mapper/UserMapper.xml"/>
</configuration>

在这个配置文件中，我们定义了数据源和事务管理器，并注册了`UserMapper.xml`文件。接下来，我们需要在Mybatis的Mapper接口中定义一个方法来调用这个查询：

public interface UserMapper {
    List<User> selectUsers();
}

最后，我们需要在服务层中调用这个Mapper接口来获取用户列表。假设我们的服务层接口定义如下：

public interface UserService {
    List<User> getUsers();
}

在实现类中，我们注入Mybatis的SqlSessionTemplate来调用Mapper接口：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }
}

现在，我们可以通过调用`getUsers()`方法来获取用户列表。假设我们的控制器层代码如下：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }
}

通过以上步骤，我们成功地使用Mybatis XML配置文件实现了一个查询用户列表的功能。接下来，我们可以进一步扩展这个示例，例如添加分页查询、条件查询等功能。

假设我们需要实现一个分页查询，可以通过在Mapper XML文件中添加一个参数来传递分页信息。首先，我们需要在`User`实体类中添加`offset`和`limit`属性，并在Mapper接口中定义一个新的方法：

public interface UserMapper {
    List<User> selectUsersByPage(int offset, int limit);
}

然后在Mapper XML文件中定义相应的SQL语句：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>

    <!-- 分页查询用户列表 -->
    <select id="selectUsersByPage" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        LIMIT #{offset}, #{limit}
    </select>
</mapper>

在服务层中，我们同样需要更新`getUsersByPage()`方法来传递分页参数：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }

    @Override
    public List<User> getUsersByPage(int offset, int limit) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByPage(offset, limit);
    }
}

最后，在控制器层中添加一个新的接口来处理分页查询：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }

    @GetMapping("/page")
    public List<User> getUsersByPage(@RequestParam int offset, @RequestParam int limit) {
        return userService.getUsersByPage(offset, limit);
    }
}

通过以上步骤，我们成功地实现了分页查询用户列表的功能。接下来，我们可以进一步扩展这个示例，例如添加条件查询、排序等功能。

假设我们需要实现一个根据用户名和邮箱进行条件查询的功能，可以通过在Mapper XML文件中添加一个参数来传递查询条件。首先，我们需要在`User`实体类中添加`username`和`email`属性，并在Mapper接口中定义一个新的方法：

public interface UserMapper {
    List<User> selectUsersByCondition(@Param("username") String username, @Param("email") String email);
}

然后在Mapper XML文件中定义相应的SQL语句：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>

    <!-- 分页查询用户列表 -->
    <select id="selectUsersByPage" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        LIMIT #{offset}, #{limit}
    </select>

    <!-- 条件查询用户列表 -->
    <select id="selectUsersByCondition" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
    </select>
</mapper>

在服务层中，我们同样需要更新`getUsersByCondition()`方法来传递查询条件：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }

    @Override
    public List<User> getUsersByPage(int offset, int limit) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByPage(offset, limit);
    }

    @Override
    public List<User> getUsersByCondition(String username, String email) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByCondition(username, email);
    }
}

最后，在控制器层中添加一个新的接口来处理条件查询：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }

    @GetMapping("/page")
    public List<User> getUsersByPage(int offset, int limit) {
        return userService.getUsersByPage(offset, limit);
    }

    @GetMapping("/condition")
    public List<User> getUsersByCondition(@RequestParam String username, @RequestParam String email) {
        return userService.getUsersByCondition(username, email);
    }
}

通过以上步骤，我们成功地实现了根据用户名和邮箱进行条件查询的功能。接下来，我们可以进一步扩展这个示例，例如添加排序功能。

假设我们需要实现一个根据用户名进行排序的功能，可以通过在Mapper XML文件中添加一个参数来传递排序信息。首先，我们需要在Mapper接口中定义一个新的方法：

public interface UserMapper {
    List<User> selectUsersBySort(@Param("sortField") String sortField, @Param("sortOrder") String sortOrder);
}

然后在Mapper XML文件中定义相应的SQL语句：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>

    <!-- 分页查询用户列表 -->
    <select id="selectUsersByPage" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        LIMIT #{offset}, #{limit}
    </select>

    <!-- 条件查询用户列表 -->
    <select id="selectUsersByCondition" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
    </select>

    <!-- 排序查询用户列表 -->
    <select id="selectUsersBySort" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        ORDER BY #{sortField} #{sortOrder}
    </select>
</mapper>

在服务层中，我们同样需要更新`getUsersBySort()`方法来传递排序信息：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }

    @Override
    public List<User> getUsersByPage(int offset, int limit) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByPage(offset, limit);
    }

    @Override
    public List<User> getUsersByCondition(String username, String email) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByCondition(username, email);
    }

    @Override
    public List<User> getUsersBySort(String sortField, String sortOrder) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersBySort(sortField, sortOrder);
    }
}

最后，在控制器层中添加一个新的接口来处理排序查询：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }

    @GetMapping("/page")
    public List<User> getUsersByPage(int offset, int limit) {
        return userService.getUsersByPage(offset, limit);
    }

    @GetMapping("/condition")
    public List<User> getUsersByCondition(@RequestParam String username, @RequestParam String email) {
        return userService.getUsersByCondition(username, email);
    }

    @GetMapping("/sort")
    public List<User> getUsersBySort(@RequestParam String sortField, @RequestParam String sortOrder) {
        return userService.getUsersBySort(sortField, sortOrder);
    }
}

通过以上步骤，我们成功地实现了根据用户名进行排序的功能。接下来，我们可以进一步扩展这个示例，例如添加更多复杂的查询功能。

假设我们需要实现一个根据用户名和邮箱进行条件查询，并且进行分页和排序的功能，可以通过在Mapper XML文件中添加多个参数来传递查询条件、分页信息和排序信息。首先，我们需要在Mapper接口中定义一个新的方法：

public interface UserMapper {
    List<User> selectUsersByConditionAndPageAndSort(
            @Param("username") String username,
            @Param("email") String email,
            @Param("offset") int offset,
            @Param("limit") int limit,
            @Param("sortField") String sortField,
            @Param("sortOrder") String sortOrder
    );
}

然后在Mapper XML文件中定义相应的SQL语句：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>

    <!-- 分页查询用户列表 -->
    <select id="selectUsersByPage" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        LIMIT #{offset}, #{limit}
    </select>

    <!-- 条件查询用户列表 -->
    <select id="selectUsersByCondition" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
    </select>

    <!-- 排序查询用户列表 -->
    <select id="selectUsersBySort" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        ORDER BY #{sortField} #{sortOrder}
    </select>

    <!-- 条件查询、分页查询和排序查询用户列表 -->
    <select id="selectUsersByConditionAndPageAndSort" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
        LIMIT #{offset}, #{limit}
        ORDER BY #{sortField} #{sortOrder}
    </select>
</mapper>

在服务层中，我们同样需要更新`getUsersByConditionAndPageAndSort()`方法来传递查询条件、分页信息和排序信息：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }

    @Override
    public List<User> getUsersByPage(int offset, int limit) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByPage(offset, limit);
    }

    @Override
    public List<User> getUsersByCondition(String username, String email) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByCondition(username, email);
    }

    @Override
    public List<User> getUsersBySort(String sortField, String sortOrder) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersBySort(sortField, sortOrder);
    }

    @Override
    public List<User> getUsersByConditionAndPageAndSort(
            String username,
            String email,
            int offset,
            int limit,
            String sortField,
            String sortOrder
    ) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByConditionAndPageAndSort(username, email, offset, limit, sortField, sortOrder);
    }
}

最后，在控制器层中添加一个新的接口来处理条件查询、分页查询和排序查询：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }

    @GetMapping("/page")
    public List<User> getUsersByPage(int offset, int limit) {
        return userService.getUsersByPage(offset, limit);
    }

    @GetMapping("/condition")
    public List<User> getUsersByCondition(@RequestParam String username, @RequestParam String email) {
        return userService.getUsersByCondition(username, email);
    }

    @GetMapping("/sort")
    public List<User> getUsersBySort(@RequestParam String sortField, @RequestParam String sortOrder) {
        return userService.getUsersBySort(sortField, sortOrder);
    }

    @GetMapping("/conditionAndPageAndSort")
    public List<User> getUsersByConditionAndPageAndSort(
            @RequestParam String username,
            @RequestParam String email,
            @RequestParam int offset,
            @RequestParam int limit,
            @RequestParam String sortField,
            @RequestParam String sortOrder
    ) {
        return userService.getUsersByConditionAndPageAndSort(username, email, offset, limit, sortField, sortOrder);
    }
}

通过以上步骤，我们成功地实现了根据用户名和邮箱进行条件查询，并且进行分页和排序的功能。接下来，我们可以进一步扩展这个示例，例如添加更多复杂的查询功能。

假设我们需要实现一个根据用户名和邮箱进行条件查询，并且进行分页和排序，同时支持动态SQL的功能。可以通过在Mapper XML文件中使用``标签来实现动态SQL。首先，我们需要在Mapper接口中定义一个新的方法：

public interface UserMapper {
    List<User> selectUsersByConditionAndPageAndSortWithDynamicSql(
            @Param("username") String username,
            @Param("email") String email,
            @Param("offset") int offset,
            @Param("limit") int limit,
            @Param("sortField") String sortField,
            @Param("sortOrder") String sortOrder
    );
}

然后在Mapper XML文件中定义相应的SQL语句，并使用``标签来实现动态SQL：

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户列表 -->
    <select id="selectUsers" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
    </select>

    <!-- 分页查询用户列表 -->
    <select id="selectUsersByPage" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        LIMIT #{offset}, #{limit}
    </select>

    <!-- 条件查询用户列表 -->
    <select id="selectUsersByCondition" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
    </select>

    <!-- 排序查询用户列表 -->
    <select id="selectUsersBySort" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        ORDER BY #{sortField} #{sortOrder}
    </select>

    <!-- 条件查询、分页查询和排序查询用户列表 -->
    <select id="selectUsersByConditionAndPageAndSort" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        WHERE username LIKE CONCAT('%', #{username}, '%') AND email LIKE CONCAT('%', #{email}, '%')
        LIMIT #{offset}, #{limit}
        ORDER BY #{sortField} #{sortOrder}
    </select>

    <!-- 动态SQL查询用户列表 -->
    <select id="selectUsersByConditionAndPageAndSortWithDynamicSql" resultType="com.example.entity.User">
        SELECT id, username, email, age FROM users
        <where>
            <if test="username != null and username != ''">
                AND username LIKE CONCAT('%', #{username}, '%')
            </if>
            <if test="email != null and email != ''">
                AND email LIKE CONCAT('%', #{email}, '%')
            </if>
        </where>
        LIMIT #{offset}, #{limit}
        ORDER BY #{sortField} #{sortOrder}
    </select>
</mapper>

在服务层中，我们同样需要更新`getUsersByConditionAndPageAndSortWithDynamicSql()`方法来传递查询条件、分页信息和排序信息：

public class UserServiceImpl implements UserService {
    private final SqlSessionTemplate sqlSessionTemplate;

    public UserServiceImpl(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsers();
    }

    @Override
    public List<User> getUsersByPage(int offset, int limit) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByPage(offset, limit);
    }

    @Override
    public List<User> getUsersByCondition(String username, String email) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByCondition(username, email);
    }

    @Override
    public List<User> getUsersBySort(String sortField, String sortOrder) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersBySort(sortField, sortOrder);
    }

    @Override
    public List<User> getUsersByConditionAndPageAndSortWithDynamicSql(
            String username,
            String email,
            int offset,
            int limit,
            String sortField,
            String sortOrder
    ) {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUsersByConditionAndPageAndSortWithDynamicSql(username, email, offset, limit, sortField, sortOrder);
    }
}

最后，在控制器层中添加一个新的接口来处理动态SQL查询：

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getUsers();
    }

    @GetMapping("/page")
    public List<User> getUsersByPage(int offset, int limit) {
        return userService.getUsersByPage(offset, limit);
    }

    @GetMapping("/condition")
    public List<User> getUsersByCondition(@RequestParam String username, @RequestParam String email) {
        return userService.getUsersByCondition(username, email);
    }

    @GetMapping("/sort")
    public List<User> getUsersBySort(@RequestParam String sortField, @RequestParam String sortOrder) {
        return userService.getUsersBySort(sortField, sortOrder);
    }

    @GetMapping("/conditionAndPageAndSortWithDynamicSql")
    public List<User> getUsersByConditionAndPageAndSortWithDynamicSql(
            @RequestParam String username,
            @RequestParam String email,
            @RequestParam int offset,
            @RequestParam int limit,
            @RequestParam String sortField,
            @RequestParam String sortOrder
    ) {
        return userService.getUsersByConditionAndPageAndSortWithDynamicSql(username, email, offset, limit, sortField, sortOrder);
    }
}

通过以上步骤，我们成功地实现了根据用户名和邮箱进行条件查询，并且进行分页和排序，同时支持动态SQL的功能。接下来，我们可以进一步扩展这个示例，例如添加更多复杂的查询功能。

接下来，我们可以讨论一些常见的问题和解决方案。

Q1: 如何在Mybatis中实现复杂的分页查询？

A1: 在Mybatis中实现复杂的分页查询，可以通过在Mapper XML文件中使用`LIMIT`语句来实现。例如，假设我们需要根据用户名和邮箱进行分页查询，可以在Mapper XML文件中定义一个方法，并在该方法中使用`LIMIT`语句来限制查询结果的数量。具体实现可以参考前面的示例。

Q2: 如何在Mybatis中实现动态SQL查询？

A2: 在Mybatis中实现动态SQL查询，可以通过在Mapper XML文件中使用``标签来实现。例如，假设我们需要根据用户名和邮箱进行动态SQL查询，可以在Mapper XML文件中定义一个方法，并在该方法中使用``标签来动态生成SQL语句。具体实现可以参考前面的示例。

Q3: 如何在Mybatis中实现排序查询？

A3: 在Mybatis中实现排序查询，可以通过在Mapper XML文件中使用`ORDER BY`语句来实现。例如，假设我们需要根据用户名进行排序查询，可以在Mapper XML文件中定义一个方法，并在该方法中使用`ORDER BY`语句来对查询结果进行排序。具体实现可以参考前面的示例。