JDBC Template查询复杂对象（封装为实体对象）

查询封装后的对象（queryxxxx）

在JAVA中，将每个用户的数据不可能全都封装到Map里面，不安全，所以要将用户数据封装到一个类里面，然后使用queryForObject查询出数据将其封装到类对象里，那么返回出来的就是一个用户类对象。而不是分散的Map集合。

之前是将数据封装到Map，现在是封装到类对象里。

首先定义一个用户类,创建三个属性，id , name, sex,一键生成相应的get和set方法和toString方法

public class User {
    private int id;
    private String name;
    private String sex;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

获取单个对象（queryForObject）

就是获取一行数据，封装到对象中，然后返回一个对象

queryFoeObject语法:
T queryFoeObject(String sql,RowMapper<T> mapper)
T queryFoeObject(String sql,new Object[] args,RowMapper<T> mapper)
T queryFoeObject(String sql,RowMapper<T> mapper,Object... arges)

三种方法还是那种，看是否带有不定参（就是？）分为三种，但是这种比较特别的是必须实现参数种RowMapper接口，该接口是干嘛的，就是你用sql语句调出来数据了，将数据封装到类对象里，然后返回对象。

例如返回 ID 为1 的用户数据，使用对象返回。（JDBCTemplate定义就不多解释了，在上篇文章中有）

public void test()
{  
    //使用了第三种用法,不定参在最后,实现接口在中间,在括号里卖弄实现，仔细看，最后参数在最后的1
    User user=jdbcTemplate.queryForObject("select * from user1 where id=?", new RowMapper<User>() {     
        public User mapRow(ResultSet resultSet, int i) throws SQLException {          //参数resuluSet就是执行sql语句获得的结果集
             User user1=new User();  //定义一个新对象
             
             user1.id=resultSet.getInt("id");   //这里就从结果集中将对象进行了封装，一 一对应关系
             user1.name=resultSet.getString("name");
             user1.sex=resultSet.getString("sex");
             return user1;
        }
    },1);
    System.out.println(user);   //输出user，其实是隐式执行了对象中的toString方法，就是之前类里面的toString方法
}

获取多个对象（query）

上面特别简单只是获得一个单一对象，就是上面，如果获得多个对象，那么第一个想见的肯定是 List 集合，将每个对象放到List集合里面。

query语法:
List<T> quert(String sql,RowMapper<T> mapper)
List<T> quert(String sql,Object[] args,RowMapper<T> mapper)
List<T> quert(String sql,RowMapper<T> mapper,Object... args)

那么和上面的一样，只不过是返回成了一个List集合，List的数据类型显然是用户对象，例如返回所有数据对象

public void test()
{
    List<User> list=jdbcTemplate.query("select * from user1", new RowMapper<User>() {
        public User mapRow(ResultSet resultSet, int i) throws SQLException {
           User user=new User();
           user.id=resultSet.getInt("id");
           user.name=resultSet.getString("name");
           user.sex=resultSet.getString("sex");
           return user;
        }
    });
    System.out.println(list);
}

其实没什么区别，就是语句变为了query，自然返回成了一个List集合
那么输出结果就如下

[User{id=1, name='xiaoming', sex='男'}, User{id=2, name='xiaohei', sex='男'}, User{id=3, name='xiaozhang', sex='女'}]

很简单理解，但你如果多次使用query语句，那么实现接口RowMapper显得冗余，肯定是将定义一个类实现该接口

private class rowmapper implements RowMapper<User>{

    public User mapRow(ResultSet resultSet, int i) throws SQLException {
        User user=new User();
        user.id=resultSet.getInt("id");
        user.name=resultSet.getString("name");
        user.sex=resultSet.getString("sex");
        return user;
    }
}

那么再次使用query或者queryForObject语句的时候，直接实现rowmapper类即可了，不用再写一大段代码，很简单。

List<User> list=jdbcTemplate.query("select * from user1", new rowmapper());