如何在Java中使用PreparedStatement根据可变字段动态构建查询？

问题场景 #

我有一个UserDAO类，需要根据不同的搜索条件查询用户。最初采用方法重载的方式实现，代码如下：

public User getUserByUsername(String username) throws SQLException {
    try (Connection conn = JdbcUtils.getConnection()) {
        String sql = "SELECT * FROM user WHERE username = ? ;";

        PreparedStatement stm = conn.prepareCall(sql);
        stm.setString(1, username);

        ResultSet rs = stm.executeQuery();

        if (rs.next()) {
            User u = new User(rs.getInt("id"), rs.getString("username"),
                    rs.getString("password"), rs.getString("first_name"),
                    rs.getString("last_name"), rs.getString("email"), rs.getString("role"));
            return u;
        }
    }
    return null;
}

public User getUserByUsername(String username, String email) throws SQLException {
    try (Connection conn = JdbcUtils.getConnection()) {
        String sql = "SELECT * FROM user WHERE username = ? AND email = ? ;";

        PreparedStatement stm = conn.prepareCall(sql);
        stm.setString(1, username);
        stm.setString(2, email);

        ResultSet rs = stm.executeQuery();

        if (rs.next()) {
            User u = new User(rs.getInt("id"), rs.getString("username"),
                    rs.getString("password"), rs.getString("first_name"),
                    rs.getString("last_name"), rs.getString("email"), rs.getString("role"));
            return u;
        }
    }
    return null;
}

这种方法扩展性差，每次新增查询条件都要编写新的重载方法。期望的解决方案需满足：

• 支持动态传入不同搜索字段，灵活性高；
• 易于维护，无需为不同条件创建多个重载方法。

我尝试用Map<String, Object>存储条件，但不确定如何正确构建查询，请问最佳实现方案是什么？

解决方案 #

方案一：原生JDBC手动构建动态SQL #

通过遍历条件Map动态拼接WHERE子句，同时收集参数并使用PreparedStatement绑定，避免SQL注入风险。

实现代码

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.HashSet;

public class UserDAO {
    // 定义允许查询的字段白名单，防止非法字段传入
    private static final Set<String> ALLOWED_COLUMNS = new HashSet<>(Arrays.asList(
            "username", "email", "first_name", "last_name", "role", "id"
    ));

    public User getUserByConditions(Map<String, Object> conditions) throws SQLException {
        if (conditions == null || conditions.isEmpty()) {
            throw new IllegalArgumentException("查询条件不能为空");
        }

        StringBuilder sqlBuilder = new StringBuilder("SELECT * FROM user WHERE 1=1");
        List<Object> params = new ArrayList<>();

        // 遍历条件拼接SQL并收集参数
        for (Map.Entry<String, Object> entry : conditions.entrySet()) {
            String column = entry.getKey();
            // 校验字段是否在白名单内
            if (!ALLOWED_COLUMNS.contains(column)) {
                throw new IllegalArgumentException("不允许查询的字段：" + column);
            }
            sqlBuilder.append(" AND ").append(column).append(" = ?");
            params.add(entry.getValue());
        }

        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement stm = conn.prepareStatement(sqlBuilder.toString())) {

            // 绑定参数
            for (int i = 0; i < params.size(); i++) {
                stm.setObject(i + 1, params.get(i));
            }

            ResultSet rs = stm.executeQuery();
            if (rs.next()) {
                return new User(rs.getInt("id"), rs.getString("username"),
                        rs.getString("password"), rs.getString("first_name"),
                        rs.getString("last_name"), rs.getString("email"), rs.getString("role"));
            }
        }
        return null;
    }
}

使用示例

// 查询用户名和邮箱匹配的用户
Map<String, Object> conditions = new HashMap<>();
conditions.put("username", "john_doe");
conditions.put("email", "john@example.com");
User user = userDAO.getUserByConditions(conditions);

优势

• 灵活性高：新增查询条件只需传入对应的键值对，无需修改DAO方法；
• 安全性：通过PreparedStatement绑定参数+字段白名单校验，彻底避免SQL注入；
• 复用性强：统一的查询逻辑，减少重复代码。

方案二：JPA Criteria API（面向对象式动态查询） #

如果项目使用JPA，可以用CriteriaBuilder构建动态查询，完全避免手动拼接SQL，代码更具可读性和维护性。

实现代码

import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.Map;

public class UserDAO {
    private EntityManager entityManager;

    // 构造方法注入EntityManager
    public UserDAO(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public User getUserByConditions(Map<String, Object> conditions) {
        if (conditions == null || conditions.isEmpty()) {
            throw new IllegalArgumentException("查询条件不能为空");
        }

        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> cq = cb.createQuery(User.class);
        Root<User> root = cq.from(User.class);

        // 初始化谓词（默认true）
        Predicate predicate = cb.conjunction();
        for (Map.Entry<String, Object> entry : conditions.entrySet()) {
            predicate = cb.and(predicate, cb.equal(root.get(entry.getKey()), entry.getValue()));
        }

        cq.where(predicate);
        try {
            return entityManager.createQuery(cq).getSingleResult();
        } catch (javax.persistence.NoResultException e) {
            return null;
        }
    }
}

优势

• 面向对象：无需手动拼接SQL，通过API构建查询逻辑；
• 安全可靠：自动处理参数绑定，避免SQL注入；
• 扩展性好：支持复杂查询条件（如范围、模糊匹配等）。

方案三：ORM框架（如MyBatis）动态SQL #

如果项目使用MyBatis，可以利用其内置的动态SQL特性，在Mapper文件中通过<if>标签实现条件拼接，DAO层只需传入参数对象或Map。

Mapper XML配置

<mapper namespace="com.example.UserMapper">
    <select id="getUserByConditions" parameterType="map" resultType="com.example.User">
        SELECT * FROM user
        <where>
            <if test="username != null">
                AND username = #{username}
            </if>
            <if test="email != null">
                AND email = #{email}
            </if>
            <if test="role != null">
                AND role = #{role}
            </if>
            <!-- 可添加更多条件判断 -->
        </where>
    </select>
</mapper>

DAO接口

import java.util.Map;

public interface UserMapper {
    User getUserByConditions(Map<String, Object> conditions);
}

使用示例

Map<String, Object> conditions = new HashMap<>();
conditions.put("role", "ADMIN");
User user = userMapper.getUserByConditions(conditions);

优势

• SQL与代码分离：查询逻辑集中在XML文件，便于维护；
• 功能强大：支持复杂动态SQL（如<choose>、<foreach>等）；
• 自动映射：MyBatis自动处理参数绑定和结果集映射，减少重复代码。

方案选择建议 #

• 原生JDBC项目：优先选择方案一，兼顾灵活性和安全性；
• JPA项目：优先选择方案二，符合JPA的面向对象设计理念；
• 已使用ORM框架：优先选择方案三，利用框架特性简化开发。

内容的提问来源于stack exchange，提问作者Nhat Nguyen