BeanMapHandler

/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements.  See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License.  You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.apache.commons.dbutils.handlers;import java.sql.ResultSet;import java.sql.SQLException;import org.apache.commons.dbutils.RowProcessor;/** * <p> * <code>ResultSetHandler</code> implementation that returns a Map of Beans. * <code>ResultSet</code> rows are converted into Beans which are then stored in * a Map under the given key. * </p> * <p> * If you had a Person table with a primary key column called ID, you could * retrieve rows from the table like this: * * <pre> * ResultSetHandler<Map<Long, Person>> h = new BeanMapdHandler<Long, Person>(Person.class, "id"); * Map&ltLong, Person> found = queryRunner.query("select id, name, age from person", h); * Person jane = found.get(1L); // jane's id is 1 * String janesName = jane.getName(); * Integer janesAge = jane.getAge(); * </pre> * * Note that the "id" passed to BeanMapHandler can be in any case. The data type * returned for id is dependent upon how your JDBC driver converts SQL column * types from the Person table into Java types. The "name" and "age" columns are * converted according to their property descriptors by DbUtils. * </p> * <p> * This class is thread safe. * </p> * * @param <K> *            the type of keys maintained by the returned map * @param <V> *            the type of the bean * @see org.apache.commons.dbutils.ResultSetHandler * @since DbUtils 1.5 */public class BeanMapHandler<K, V> extends AbstractKeyedHandler<K, V> {    /**     * The Class of beans produced by this handler.     */    private final Class<V> type;    /**     * The RowProcessor implementation to use when converting rows into Objects.     */    private final RowProcessor convert;    /**     * The column index to retrieve key values from. Defaults to 1.     */    private final int columnIndex;    /**     * The column name to retrieve key values from. Either columnName or     * columnIndex will be used but never both.     */    private final String columnName;    /**     * Creates a new instance of BeanMapHandler. The value of the first column     * of each row will be a key in the Map.     *     * @param type     *            The Class that objects returned from <code>createRow()</code>     *            are created from.     */    public BeanMapHandler(Class<V> type) {        this(type, ArrayHandler.ROW_PROCESSOR, 1, null);    }    /**     * Creates a new instance of BeanMapHandler. The value of the first column     * of each row will be a key in the Map.     *     * @param type     *            The Class that objects returned from <code>createRow()</code>     *            are created from.     * @param convert     *            The <code>RowProcessor</code> implementation to use when     *            converting rows into Beans     */    public BeanMapHandler(Class<V> type, RowProcessor convert) {        this(type, convert, 1, null);    }    /**     * Creates a new instance of BeanMapHandler.     *     * @param type     *            The Class that objects returned from <code>createRow()</code>     *            are created from.     * @param columnIndex     *            The values to use as keys in the Map are retrieved from the     *            column at this index.     */    public BeanMapHandler(Class<V> type, int columnIndex) {        this(type, ArrayHandler.ROW_PROCESSOR, columnIndex, null);    }    /**     * Creates a new instance of BeanMapHandler.     *     * @param type     *            The Class that objects returned from <code>createRow()</code>     *            are created from.     * @param columnName     *            The values to use as keys in the Map are retrieved from the     *            column with this name.     */    public BeanMapHandler(Class<V> type, String columnName) {        this(type, ArrayHandler.ROW_PROCESSOR, 1, columnName);    }    /**     * Private Helper     *     * @param convert     *            The <code>RowProcessor</code> implementation to use when     *            converting rows into Beans     * @param columnIndex     *            The values to use as keys in the Map are retrieved from the     *            column at this index.     * @param columnName     *            The values to use as keys in the Map are retrieved from the     *            column with this name.     */    private BeanMapHandler(Class<V> type, RowProcessor convert,            int columnIndex, String columnName) {        super();        this.type = type;        this.convert = convert;        this.columnIndex = columnIndex;        this.columnName = columnName;    }    /**     * This factory method is called by <code>handle()</code> to retrieve the     * key value from the current <code>ResultSet</code> row.     * @param rs ResultSet to create a key from     *     * @return K from the configured key column name/index     *     * @throws SQLException if a database access error occurs     * @throws ClassCastException if the class datatype does not match the column type     *     * @see org.apache.commons.dbutils.handlers.AbstractKeyedHandler#createKey(ResultSet)     */    // We assume that the user has picked the correct type to match the column    // so getObject will return the appropriate type and the cast will succeed.    @SuppressWarnings("unchecked")    @Override    protected K createKey(ResultSet rs) throws SQLException {        return (columnName == null) ?               (K) rs.getObject(columnIndex) :               (K) rs.getObject(columnName);    }    @Override    protected V createRow(ResultSet rs) throws SQLException {        return this.convert.toBean(rs, type);    }}