Java 将对象列表映射到对象的ParameterizedRowMapper

我试图在ParameterizedRowMapper中设置父列表这是如何编写或实现的。我有两个对象，一个用于父对象，一个用于子对象，但是子对象包含一个列表。每个子对象的父对象存储在数据库中的一个单独的表中，映射为1-多

父项记录的选择将在单独的结果集中完成。映射是否必须单独进行（单独的ParameterizedRowMapper），如果是，我将如何编写ParameterizedRowMapper这是主要的问题ParameterizedRowMapper如何编写以容纳列表项

ParameterizedRowMapper

public static class ChildrenMapper implements ParameterizedRowMapper<Children>{         

         public Children mapRow(ResultSet rs, int rowNum) throws SQLException {
                Children child = new Children();
                child.setFirstName(rs.getString("firstName"));
                child.setLastName(rs.getString("lastName"));
                    //a child can have many Parents or gaurdians
                child.setParent(List<Parent>);                  

                return child;
            }       
    }

---

我将为一个规范的1对多示例演示如何实现这一点，您可以将其调整到您的vo类/表中

订单类

public class Order {
    private Long orderId;
    private String user;
    private List<LineItem> items;
    // Getter / setter omitted
}

使用两个行映射器，每个类一个，然后使用结果集提取器将多行转换为一个订单+行项目

订单存储库

public final static RowMapper<Order> orderMapper = ParameterizedBeanPropertyRowMapper.newInstance(Order.class);
public final static RowMapper<LineItem> lineItemMapper = ParameterizedBeanPropertyRowMapper.newInstance(LineItem.class);

public Order findOrderWithItems(Long orderId) {
    return jdbcTemplate.query("select * from orders, line_item "
            + " where orders.order_id = line_item.order_id and orders.order_id = ?", 
            new ResultSetExtractor<Order>() {
        public Order extractData(ResultSet rs) throws SQLException, DataAccessException {
            Order order = null;
            int row = 0;
            while (rs.next()) {
                if (order == null) {
                    order = orderMapper.mapRow(rs, row);
                }
                order.addItem(lineItemMapper.mapRow(rs, row));
                row++;
            }
            return order;
        }

    }, orderId);
}

public List<Order> findAllOrderWithItmes() {
    return jdbcTemplate.query("select * from orders, line_item "
            + " where orders.order_id = line_item.order_id order by orders.order_id",
            new ResultSetExtractor<List<Order>>() {
                public List<Order> extractData(ResultSet rs) throws SQLException, DataAccessException {
                    List<Order> orders = new ArrayList<Order>();
                    Long orderId = null;
                    Order currentOrder = null;
                    int orderIdx = 0;
                    int itemIdx = 0;
                    while (rs.next()) {
                        // first row or when order changes
                        if (currentOrder == null || !orderId.equals(rs.getLong("order_id"))) {
                            orderId = rs.getLong("order_id");
                            currentOrder = orderMapper.mapRow(rs, orderIdx++);
                            itemIdx = 0;
                            orders.add(currentOrder);
                        }
                        currentOrder.addItem(lineItemMapper.mapRow(rs, itemIdx++));
                    }
                    return orders;
                }

            });
}

public final static RowMapper orderMapper=ParameterizedBeanPropertyRowMapper.newInstance（Order.class）；
公共最终静态行映射器lineItemMapper=参数化BeanPropertyRowMapper.newInstance（LineItem.class）；
公共订单findOrderWithItems（长订单ID）{
返回jdbcTemplate.query（“从订单中选择*行项目”
+“其中orders.order\u id=行\u item.order\u id和orders.order\u id=？”，
新的resultSetTextRactor（）{
public Order extractData（结果集rs）引发SQLException、DataAccessException{
订单=空；
int行=0；
while（rs.next（））{
if（order==null）{
order=orderMapper.mapRow（rs，row）；
}
order.addItem（lineItemMapper.mapRow（rs，row））；
行++；
}
退货单；
}
}，orderId）；
}
公共列表FindAllowerWithitmes（）{
返回jdbcTemplate.query（“从订单中选择*行项目”
+“其中orders.order\u id=line\u item.order\u id order by orders.order\u id”，
新的resultSetTextRactor（）{
公共列表提取数据（ResultSet rs）引发SQLException、DataAccessException{
列表顺序=新的ArrayList（）；
Long orderId=null；
Order currentOrder=null；
int orderIdx=0；
int itemIdx=0；
while（rs.next（））{
//第一行或订单更改时
if（currentOrder==null | |！orderId.equals（rs.getLong（“order|id”））{
orderId=rs.getLong（“订单id”）；
currentOrder=orderMapper.mapRow（rs，orderIdx++）；
itemIdx=0；
订单。添加（当前订单）；
}
currentOrder.addItem（lineItemMapper.mapRow（rs，itemIdx++））；
}
退货订单；
}
});
}

我还没有测试过它。它应该进行一些小的调整-特别是如果两个表中的列名称相同..您可以在处找到它的工作版本-不会编译。RowMapper不是泛型使用3.0或更高版本的spring，或者去掉泛型并替换为强制类型转换。

public class Order {
    private Long orderId;
    private String user;
    private List<LineItem> items;
    // Getter / setter omitted
}

public class LineItem {
    private Long lineItemId;
    private String product;
    private int quantity;
    // Getter / setter omitted
}

public final static RowMapper<Order> orderMapper = ParameterizedBeanPropertyRowMapper.newInstance(Order.class);
public final static RowMapper<LineItem> lineItemMapper = ParameterizedBeanPropertyRowMapper.newInstance(LineItem.class);

public Order findOrderWithItems(Long orderId) {
    return jdbcTemplate.query("select * from orders, line_item "
            + " where orders.order_id = line_item.order_id and orders.order_id = ?", 
            new ResultSetExtractor<Order>() {
        public Order extractData(ResultSet rs) throws SQLException, DataAccessException {
            Order order = null;
            int row = 0;
            while (rs.next()) {
                if (order == null) {
                    order = orderMapper.mapRow(rs, row);
                }
                order.addItem(lineItemMapper.mapRow(rs, row));
                row++;
            }
            return order;
        }

    }, orderId);
}

public List<Order> findAllOrderWithItmes() {
    return jdbcTemplate.query("select * from orders, line_item "
            + " where orders.order_id = line_item.order_id order by orders.order_id",
            new ResultSetExtractor<List<Order>>() {
                public List<Order> extractData(ResultSet rs) throws SQLException, DataAccessException {
                    List<Order> orders = new ArrayList<Order>();
                    Long orderId = null;
                    Order currentOrder = null;
                    int orderIdx = 0;
                    int itemIdx = 0;
                    while (rs.next()) {
                        // first row or when order changes
                        if (currentOrder == null || !orderId.equals(rs.getLong("order_id"))) {
                            orderId = rs.getLong("order_id");
                            currentOrder = orderMapper.mapRow(rs, orderIdx++);
                            itemIdx = 0;
                            orders.add(currentOrder);
                        }
                        currentOrder.addItem(lineItemMapper.mapRow(rs, itemIdx++));
                    }
                    return orders;
                }

            });
}