概述

Spring JDBC抽象框架core包提供了JDBC模板类，其中JdbcTemplate是core包的核心类，所以其他模板类都是基于它封装完成的，JDBC模板类是第一种工作模式。

JdbcTemplate类通过模板设计模式帮助我们消除了冗长的代码，只做需要做的事情（即可变部分），并且帮我们做哪些固定部分，如连接的创建及关闭。

JdbcTemplate类对可变部分采用回调接口方式实现，如ConnectionCallback通过回调接口返回给用户一个连接，从而可以使用该连接做任何事情、StatementCallback通过回调接口返回给用户一个Statement，从而可以使用该Statement做任何事情等等，还有其他一些回调接口

Spring除了提供JdbcTemplate核心类，还提供了基于JdbcTemplate实现的NamedParameterJdbcTemplate类用于支持命名参数绑定、 SimpleJdbcTemplate类用于支持Java5+的可变参数及自动装箱拆箱等特性。

JdbcTemplate类支持的回调类：

预编译语句及存储过程创建回调：用于根据JdbcTemplate提供的连接创建相应的语句；

PreparedStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的PreparedStatement；

CallableStatementCreator：通过回调获取JdbcTemplate提供的Connection，由用户使用该Conncetion创建相关的CallableStatement；

预编译语句设值回调：用于给预编译语句相应参数设值；

PreparedStatementSetter：通过回调获取JdbcTemplate提供的PreparedStatement，由用户来对相应的预编译语句相应参数设值；

BatchPreparedStatementSetter：；类似于PreparedStatementSetter，但用于批处理，需要指定批处理大小；

自定义功能回调：提供给用户一个扩展点，用户可以在指定类型的扩展点执行任何数量需要的操作；

ConnectionCallback：通过回调获取JdbcTemplate提供的Connection，用户可在该Connection执行任何数量的操作；

StatementCallback：通过回调获取JdbcTemplate提供的Statement，用户可以在该Statement执行任何数量的操作；

PreparedStatementCallback：通过回调获取JdbcTemplate提供的PreparedStatement，用户可以在该PreparedStatement执行任何数量的操作；

CallableStatementCallback：通过回调获取JdbcTemplate提供的CallableStatement，用户可以在该CallableStatement执行任何数量的操作；

结果集处理回调：通过回调处理ResultSet或将ResultSet转换为需要的形式；

RowMapper：用于将结果集每行数据转换为需要的类型，用户需实现方法mapRow(ResultSet rs, int rowNum)来完成将每行数据转换为相应的类型。

RowCallbackHandler：用于处理ResultSet的每一行结果，用户需实现方法processRow(ResultSet rs)来完成处理，在该回调方法中无需执行rs.next()，该操作由JdbcTemplate来执行，用户只需按行获取数据然后处理即可。

ResultSetExtractor：用于结果集数据提取，用户需实现方法extractData(ResultSet rs)来处理结果集，用户必须处理整个结果集；

下面详细讲解jdbcTmeplate的CRUD操作：

（一）增加、删除、修改操作：

1）增加、更新、删除（一条sql语句）（sql固定，不需要参数）：

(a) int update(final String sql)

其中sql参数为需要传入的插入sql语句。

(b)int update(PreparedStatementCreator psc)

    public void test() {

        jdbcTemplate.update(new PreparedStatementCreator() {

            @Override

            public PreparedStatement createPreparedStatement(Connection conn)

                    throws SQLException {

                return conn.prepareStatement("insert into test(name) values('name1')");

            }

        });

    }

(c)如果需要返回新插入数据的主键，采用如下方法（使用KeyHolder keyholder=new GeneratedKeyHolder();获得主键，jdbcTemplate和NamedParameterJdbcTemplate都可以通过此方法获得主键）：

int update(PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)

public void test() {

        KeyHolder keyHolder = new GeneratedKeyHolder();

        jdbcTemplate.update(new PreparedStatementCreator() {

            @Override

            public PreparedStatement createPreparedStatement(Connection conn)

                    throws SQLException {

                return conn.prepareStatement("insert into test(name) values('name1')");  

            }

        },keyHolder);

        int i = keyHolder.getKey().intValue();//这就是刚插入的数据的主键

    }

2）增加、更新、删除（一条sql语句）（sql需要注入参数填充‘？’）：

　　(a)int update(String sql, PreparedStatementSetter pss)

public void test() {

        String sql = "insert into test(name) values (?)";

        //返回的是更新的行数

        int count = jdbcTemplate.update(sql, new PreparedStatementSetter(){

            @Override

            public void setValues(PreparedStatement pstmt)

                    throws SQLException {

                pstmt.setObject(1, "name4");

            }

        });

    }

(b)int update(String sql, Object[] args, int[] argTypes)

其中参数含义： sql:预处理sql语句； args:sql需要注入的参数； argTypes:需要注入的sql参数的JDBC类型（java.sql.Types中来获取类型的常量）；

    public void test() {

        String sql = "insert into test(name,age,create_date) values (?,?,?)";

        Date now = new Date(System.currentTimeMillis());

        //返回的是更新的行数

        int count = jdbcTemplate.update(sql, new Object[]{"小明",14,now}, new int[]{Types.VARCHAR,Types.INTEGER,Types.DATE});

    }

(c)int update(String sql, Object... args)

其实内部还是调用方法a实现的，JdbcTemplate提供这种更简单的方式“update(String sql, Object... args)”来实现设值，所以只要当使用该种方式不满足需求时才应使用PreparedStatementSetter（上面方法a）。

public void test() {

        String sql = "insert into test(name,age,create_date) values (?,?,?)";

        Date now = new Date(System.currentTimeMillis());

        //返回的是更新的行数

        int count = jdbcTemplate.update(sql, "小明", 14, now);

    }

public void test() {

        String sql = "insert into test(name,age,create_date) values (?,?,?)";

        Date now = new Date(System.currentTimeMillis());

        //返回的是更新的行数

        int count = jdbcTemplate.update(sql, new Object[]{"小明",14,now});

    }

这两种实际上调用的都是该方法，由此可见Object...args实际上就是可变的数组，而数组长度是固定的，必须先定义一个数组，而Object...args在传递时参数可以任意，所以也可以传递一个固定的Object数组。

(d)int update(PreparedStatementCreator psc)

使用该方法可以自己使用原始jdbc方式给预编译sql注入参数，来进行增加、删除、更新操作：

public void test(final Customer customer) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        //方法局部必须是final的，匿名内部类中才能引用

        final String sql = "insert into test(name,age,create_date) values (?,?,?)";

        Date now = new Date(System.currentTimeMillis());

        //返回的是更新的行数

        int count = jdbcTemplate.update(new PreparedStatementCreator() {

            @Override

            public PreparedStatement createPreparedStatement(Connection conn)

                    throws SQLException {

                PreparedStatement ps = conn.prepareStatement(sql);

                ps.setString(1, customer.getName());

                ps.setInt(2, customer.getAge());

                ps.setDate(3, customer.getCreateDate());

                return ps;

            }

        });

    }

如果需要返回插入的主键，只能用此方法，增加KeyHolder参数：

public void test(final Customer customer) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        KeyHolder keyHolder = new GeneratedKeyHolder();

        //方法局部必须是final的，匿名内部类中才能引用

        final String sql = "insert into test(name,age,create_date) values (?,?,?)";

        Date now = new Date(System.currentTimeMillis());

        //返回的是更新的行数

        int count = jdbcTemplate.update(new PreparedStatementCreator() {

            @Override

            public PreparedStatement createPreparedStatement(Connection conn)

                    throws SQLException {

                PreparedStatement ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS); //有的数据库版本不一样，需要添加第二个参数，不然会报错；
　　　　　　　　　　ps.setString(1, customer.getName()); 
　　　　　　　　　　ps.setInt(2, customer.getAge()); 
　　　　　　　　　　ps.setDate(3, customer.getCreateDate()); 
　　　　　　　　　　return ps; 
　　　　　　　　} 
　　　　},keyHolder); 
　　　　
　　　　int i = keyHolder.getKey().intValue();//这就是刚插入的数据的主键  }

3）批量增加、删除、更新数据（多条sql语句）

　　（a）批量执行多条sql（固定的sql，不需要注入参数，但是sql格式不固定）

　　 int[] batchUpdate(final String[] sql)

参数是一个String数组，存放多条sql语句；返回值是int数组，即每条sql更新影响的行数。

　　（b）批量执行多条sql（预处理sql，需要注入参数）

　　 int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss)

参数sql：一条预处理sql（如果是批量处理预处理sql，那么sql的格式就是固定的，只填充参数而已）；第二个参数就是回调类，前面有统一介绍回调类。

举两个例子，一个更新，一个插入：

批量插入：

public void test(final List<Customer> customer) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        String sql = "insert into test(name,age,create_date) values (?,?,?)";

        //返回的是更新的行数

        int[] count = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {

            @Override

            public void setValues(PreparedStatement ps, int i)

                    throws SQLException {

                //注入参数值

                ps.setString(1, customer.get(i).getName());

                ps.setInt(2, customer.get(i).getAge());

                ps.setDate(3, customer.get(i).getCreateDate());

            }

            @Override

            public int getBatchSize() {

                //批量执行的数量

                return customer.size();

            }

        });

    }

批量更新：

public void test(final List<Customer> customer) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        String sql = "update test set name = ?,age = ? where id = ?";

        //返回的是更新的行数

        int[] count = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {

            @Override

            public void setValues(PreparedStatement ps, int i)

                    throws SQLException {

                //注入参数值

                ps.setString(1, customer.get(i).getName());

                ps.setInt(2, customer.get(i).getAge());

                ps.setInt(3, customer.get(i).getId());

            }

            @Override

            public int getBatchSize() {

                //批量执行的数量

                return customer.size();

            }

        });

    }

　　（c）批量处理多条预处理sql语句还有下面几种简单方法（参数和前面类似，这里就不详解）：

int[] batchUpdate(String sql, List<Object[]> batchArgs)；

int[] batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes)；

前面讲了增加、删除、更新操作，这节讲一下查询。

查询操作：

(一)查询一个值（不需要注入参数）

queryForObject(String sql, Class<T> requiredType)；

注意：参数requiredType只能是String，Integer这种类型，不能是自定义的实体类型，只能返回一个值，不能映射对象（映射对象下面会说）；

　　sql:预处理sql；requiredType：查询单列结果的类型；

public void test() {

        String sql = "select count(*) from test";

        int count = jdbcTemplate.queryForObject(sql, Integer.class);

    }

（二）查询一个值（使用预处理sql，需要注入参数）

queryForObject(String sql, Object[] args, Class<T> requiredType)；

public void test(Integer id) {

        String sql = "select name from test where id = ?";

        String name = jdbcTemplate.queryForObject(sql, new Object[]{id}, String.class);

    }

还有如下方式：queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType)；

（三）查询单行记录，转换成一个对象（固定sql，不需要参数）

<T> T queryForObject(String sql, RowMapper<T> rowMapper)

public void test() {

        String sql = "select name,age from test where id = 10";

        Customer customer = jdbcTemplate.queryForObject(sql, new RowMapper<Customer>() {

            @Override

            public Customer mapRow(ResultSet rs, int i)

                    throws SQLException {

                Customer c = new Customer();

                c.setName(rs.getString("name"));

                c.setAge(rs.getInt("age"));

                return c;

            }

        });

    }

（四）查询单行记录，转换成一个对象（预处理sql，需要注入参数）

<T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)

public void test(Integer id) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        String sql = "select name,age from test where id = ?";

        Customer customer = jdbcTemplate.queryForObject(sql, new Object[]{id}, new RowMapper<Customer>() {

            @Override

            public Customer mapRow(ResultSet rs, int paramInt)

                    throws SQLException {

                Customer c = new Customer();

                c.setName(rs.getString("name"));

                c.setAge(rs.getInt("age"));

                return c;

            }

        });

    }

也可以使用如下方式：（1）<T> T queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper);

　　　　　　　　　　（2）<T> T queryForObject(String sql, RowMapper<T> rowMapper, Object... args);

（五）查询数据库中一列多行数据，即查询数据库中单列数据存入一个list中，方式如下：（固定sql，没参数）

　　（a）List<Map<String, Object>> queryForList(String sql)

这个方法封装成map放入list中，key:列名（Oracle数据库sql执行结果列名默认为大写，需要小写用as取别名，别名用双引号） value:列的值

public void test() {//如果Oracle用这个sql查询，返回的列名就是NAME(大写的)，对应Map里面的key就是NAME

        String sql = "select name from test where id > 0";

        //如果用这个sql查询，返回的列名就是name(小写的)，对应Map里面的key就是name

        String sql2 = "select name as \"name\" from test where id > 0";

        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);//这里用的是第一个sql

    }

　　（b）<T> List<T> queryForList(String sql, Class<T> elementType)

这个方法就是直接将单类型数据存入List中。

　　注意：这个T虽然是泛型，但是只支持Integer.class String.class 这种单数据类型的，自己定义的Bean不支持。（所以用来查询单列数据）

public void test() {

        String sql = "select name from test where id > 0";

        List<String> list = jdbcTemplate.queryForList(sql, String.class);

    }

（六）查询数据库中一列多行数据，即查询数据库中单列数据存入一个list中，方式如下：（预处理sql，需要注入参数）

　　（a）<T> List<T> queryForList(String sql, Object[] args, Class<T> elementType)

　　注意：这个T虽然是泛型，但是只支持Integer.class String.class 这种单数据类型的，自己定义的Bean不支持。（所以用来查询单列数据,同前面一个意思，后面不再解释）

public void test(Integer id) {

        String sql = "select name from test where id > ?";

        List<String> list = jdbcTemplate.queryForList(sql, new Object[]{id}, String.class);

    }

　　还有如下方式实现：（1）<T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType)；

　　　　　　　　　　（2）<T> List<T> queryForList(String sql, Class<T> elementType, Object... args)；

　　（b）List<Map<String, Object>> queryForList(String sql, Object... args)

　　封装成map存入List,和之前一样，要注意Oracle数据库返回的列名默认是大写的，如果需要，用别名变小写。

public void test(Integer id) {

        String sql = "select name from test where id > ?";

        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, new Object[]{id});

    }

　　还有一种方式实现：List<Map<String, Object>> queryForList(String sql, Object[] args, int[] argTypes)；

（七）查询多条数据（固定sql，没有参数）

　　（a）<T> List<T> query(String sql, RowMapper<T> rowMapper)

　　　　每条数据映射为java对象，放入List中。

public void test() {

        String sql = "select name,age from test where id > 10";

        List<Customer> list = jdbcTemplate.query(sql, new RowMapper<Customer>() {

            @Override

            public Customer mapRow(ResultSet rs, int rowNum)

                    throws SQLException {

                //这里必须new对象，不能在方法外new，然后用同一个，因为是一个List，查询出来多个对象映射，

                //必须保证每一次调用都使用一个新的。

                //如果不new，而是使用同一个对象，会导致存入到List中的都是一样的对象（都是最后一个对象）。

                Customer customer = new Customer();

                customer.setName(rs.getString("name"));

                customer.setAge(rs.getInt("age"));

                return customer;

            }

        });

    }

　　该方法也可以把每一行数据转换为自定义key-value的map对象放入list中，如下：（所以说使用回调类比简单方法更强大，里面逻辑自己按需求写）

public void test() {

        String sql = "select name,age from test where id > 10";

        List<Map<Integer,Object>> list = jdbcTemplate.query(sql, new RowMapper<Map<Integer,Object>>() {

            @Override

            public Map<Integer,Object> mapRow(ResultSet rs, int rowNum)

                    throws SQLException {

                Map<Integer, Object> map = new HashMap<Integer, Object>();

                map.put(rowNum, rs.getString("name"));

                map.put(rowNum, rs.getInt("age"));

                return map;

            }

        });

    }

map中的key，value类型根据需要自定义，非常方便。像这种实现RowMapper<T>接口的匿名类，T可以为Map，也可以为自定义的对象类型，如上两种，根据需要选择。

　　（b） void query(String sql, RowCallbackHandler rch)

　　　注意：如果使用RowCallbackHandler 回调类，这个方法是没有返回值的，而是在回调类中将结果放入预先定义的List中，用法如下：

public void test() {

        String sql = "select name,age from test where id > 10";

        //局部变量，必须用final修饰，内部类中才能访问（全局变量不用）

        final List<Customer> list = new ArrayList<Customer>();

        jdbcTemplate.query(sql, new RowCallbackHandler() {

            @Override

            public void processRow(ResultSet rs) throws SQLException {

                Customer customer = new Customer();

                customer.setName(rs.getString("name"));

                customer.setAge(rs.getInt("age"));

                list.add(customer);

            }

        });

    }

当然，这种方式也可以转换为map，存入list中，和上面a方式一样，这里就不详解了。

　　（c）<T> T query(final String sql, final ResultSetExtractor<T> rse)

　　ResultSetExtractor使用回调方法extractData(ResultSet rs)提供给用户整个结果集，让用户决定如何处理该结果集。

public void test() {

        String sql = "select name,age from test where id > 10";

        List<Customer> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Customer>>() {

            @Override

            public List<Customer> extractData(ResultSet rs)

                    throws SQLException, DataAccessException {

                List<Customer> result = new ArrayList<Customer>();

                while(rs.next()) {

                    Customer customer = new Customer();

                    customer.setName(rs.getString("name"));

                    customer.setAge(rs.getInt("age"));

                    result.add(customer);

                }

                return result;

            }

        });

    }

同样也可以转换为map对象放入list中，如下：

public void test() {

        String sql = "select name,age from test where id > 10";

        List<Map<String, Integer>> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Map<String, Integer>>>() {

            @Override

            public List<Map<String, Integer>> extractData(ResultSet rs)

                    throws SQLException, DataAccessException {

                List<Map<String, Integer>> result = new ArrayList<Map<String, Integer>>();

                while(rs.next()) {

                    Map<String, Integer> map = new HashMap<String, Integer>();

                    map.put(rs.getString("name"), rs.getInt("age"));

                    result.add(map);

                }

                return result;

            }

        });

    }

　　（d）<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper)

public void test() {//局部变量，必须用final修饰，内部类中才能访问（全局变量不用）

        final String sql = "select name,age from test where id > 10";

        List<Customer> list = jdbcTemplate.query(new PreparedStatementCreator() {

            @Override

            public PreparedStatement createPreparedStatement(Connection conn)

                    throws SQLException {

                PreparedStatement ps = conn.prepareStatement(sql);
　　　　　　　　　//如果sql是预处理的，需要传入参数，可以在这里写jdbc代码传入，后面就不列举这种方法了

                return ps;

            }

        }, new RowMapper<Customer>() {

            @Override

            public Customer mapRow(ResultSet rs, int rowNum)

                    throws SQLException {

                Customer customer = new Customer();

                customer.setAge(rs.getInt("age"));

                customer.setName(rs.getString("name"));

                return customer;

            }

        });

    }

可以将RowMapper换成ResultSetExtractor或者RowCallbackHandler回调类，和前面一样，因此还有下面两种方法：

　　（1）void query(PreparedStatementCreator psc, RowCallbackHandler rch)；

　　（2）<T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse)；

（八）查询多条数据（预处理sql，需要传入参数）

　　（a）<T> List<T> query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)

public void test(final Integer id) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）

        String sql = "select name,age from test where id > ?";

        List<Customer> list = jdbcTemplate.query(sql, new PreparedStatementSetter() {

            @Override

            public void setValues(PreparedStatement ps)

                    throws SQLException {

                ps.setInt(1, id);

            }

        }, new RowMapper<Customer>() {

            @Override

            public Customer mapRow(ResultSet rs, int rowNum)

                    throws SQLException {

                Customer customer = new Customer();

                customer.setName(rs.getString("name"));

                customer.setAge(rs.getInt("age"));

                return customer;

            }

        });

    }

用RowMapper回调类还有三种方法：

　　　　（1）<T> List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)；

　　　　（2）<T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper)；

　　　　（3）<T> List<T> query(String sql, RowMapper<T> rowMapper, Object... args)；

而如果把回调类换成ResultSetExtractor或者RowCallbackHandler回调类，又有八种方法（像上面一样各有四种），这里就不举出来了，和前面用法一致。

使用Spring的JdbcTemplate或者NamedParameterJdbcTemplate查询数据库，获取结果，数据库表字段和实体类自动对应，可以使用BeanPropertyRowMapper。

注意：

　　自动绑定，需要列名称和Java实体类名字一致，如：属性名 “userName” 可以匹配数据库中的列字段（这里说的列字段是sql执行结果的列名，也就是如果有别名就用别名，（Oracle默认列名大写）） "USERNAME" 或 “user_name”。这样，我们就不需要一个个手动绑定了，大大提高了开发效率。

下面讲解BeanPropertyRowMapper用法：

BeanPropertyRowMapper<T> implements RowMapper<T>这个类是实现了RowMapper接口的，所以之前讲的查询中，能用到RowMapper回调类的都可以用BeanPropertyRowMapper来将结果直接映射为实体类。

public List<UserEntity> findUser(UserEntity user) {

        List<UserEntity> userList = jdbcTemplate.query(SEL_BY_USERNAME_PWD,

                new Object[] { user.getUserName(), user.getPwd() },

                new BeanPropertyRowMapper<UserEntity>(UserEntity.class));

        return userList;

    }

正如上面，直接利用BeanPropertyRowMapper的构造方法传递一个需要映射的类的class对象进去即可实现，当然必须满足之前说的要求：

1.属性名“userName”要按如下规则匹配sql结果列：结果列要是"user_name"(大小写都行)，因为BeanPropertyRowMapper的中会将结果列都转为小写去和对象中set属性对应；

2.属性名“user”这对应结果列为“USER”（大小写都行），理由同上；

JdbcTemplate完全学习的更多相关文章

JdbcTemplate应用学习
一.Spring对不同的持久化支持: Spring为各种支持的持久化技术,都提供了简单操作的模板和回调 ORM持久化技术模板类 JDBC org.springframework.jdbc.core. ...
JDBCTemplate基础学习
JDBCTemplate:spring提供的用于操作数据库的模板,类似DbUtils.使用时必须设置数据源(DataSource):数据源如DBCP.C3P0等一.JDBCAPI简单使用Demo 1 ...
spring-boot-route（十）多数据源切换
前面我们已经介绍了三种方式来操作数据库,在实际开发中,往往会出现一个服务连接多个数据库的需求,这时候就需要在项目中进行灵活切换数据源来完成多个数据库操作.这一章中,我们使用jdbcTemplate来学 ...
Hibernate框架基本使用
时间:2017-1-16 00:36 --什么是Hibernate Hibernate是一个开放源代码的关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以使用对象编程思 ...
[原创]java WEB学习笔记109：Spring学习---spring对JDBC的支持：使用 JdbcTemplate 查询数据库，简化 JDBC 模板查询，在 JDBC 模板中使用具名参数两种实现
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
Spring JdbcTemplate 的使用与学习
JDBCTemplate 是SPRING 框架自带的一种对sql 语句查询的封装 ,封装非常完善,虽然与Hibernate比起来有一点麻烦,但是学号JDBCTemplate可以让我们用Spirngmv ...
Spring JdbcTemplate 的使用与学习(转)
紧接上一篇 (JdbcTemplate是线程安全的,因此可以配置一个简单的JdbcTemplate实例,将这个共享的实例注入到多个DAO类中.辅助的文档) Spring DAO支持 http://ww ...
JdbcTemplate学习笔记
JdbcTemplate学习笔记 1.使用JdbcTemplate的execute()方法执行SQL语句 Java 代码 jdbcTemplate.execute("CREATE TABLE ...
Spring之JDBCTemplate学习
一.Spring对不同的持久化支持: Spring为各种支持的持久化技术,都提供了简单操作的模板和回调 ORM持久化技术模板类 JDBC org.springframework.jdbc.core. ...

随机推荐

WPF Bitmap转成Imagesource的性能优化
之前有个需求是在WPF中生成二维码,用的是QRCoder. QRCoder生成的是Bitmap,在wpf中需要转换成ImageSource才能显示. 之前的转换方式是: IntPtr hBitmap ...
codefirst数据迁移技术，在保留数据库数据下实现对模型的修改并映射到数据库
一前言这是我的处女作,写的不好的地方还望指出共同讨论.EF的数据访问方式有三种DbFirst,ModelFirst,还有本文要提到的CodeFirst 三者都是以ORM的方式建立.本人之前学习的.n ...
unity 人工智能AI，装备解锁临时笔记
A*算法的一种改进设想:1.如何让角色到达目标点的过程中更加平滑:获取一串到达目标点的网格串之后,就实时用带形状的物理射线检测能否直接到达下一个目标点的再下一个目标点,如果能到达,那么直接朝该方向运动 ...
给Ubuntu18.04安装mac os主题<转载>
给Ubuntu18.04安装mac os主题转载来自 https://www.cnblogs.com/feipeng8848(作者) 参考文献 https://linuxhint.com/gnom ...
[学习笔记]状压dp
状压 \(dp\) 1.[SDOI2009]Bill的挑战 \(f[i][j]\) 表示匹配到字符串的第 \(i\) 位状态为 \(j\) 的方案数那么方程就很明显了,每次枚举第 \(i\) 位的字 ...
漏洞复现-vsftpd-v2.3.4
vsftpd-2.3.4早期版本存在恶意的后门,在钟馗之眼上目前骇客以收到如此的主机,不过很多的服务器都已经被修复过,但总有漏网之鱼,有兴趣的小伙伴不妨去试试 0×01前言: vsftpd-2.3.4 ...
javascript数据结构与算法--高级排序算法（快速排序法，希尔排序法）
javascript数据结构与算法--高级排序算法(快速排序法,希尔排序法) 一.快速排序算法 /* * 这个函数首先检查数组的长度是否为0.如果是,那么这个数组就不需要任何排序,函数直接返回. * ...
在matlab中实现线性回归和logistic回归
本文主要讲解在matlab中实现Linear Regression和Logistic Regression的代码,并不涉及公式推导.具体的计算公式和推导,相关的机器学习文章和视频一大堆,推荐看Andr ...
线程同步辅助类CyclicBarrier
CyclicBarrier 是一个可重置的多路同步点,在某些并行编程风格中很有用. 集合点同步:CyclicBarrier 多条线程同时执行一个阶段性任务时,相互等待,等到最后一个线程执行完阶段后,才 ...
STL简洁 && c++读取cfg文件
在c++工程中,往往需要修改一些变量来实现不同的功能效果,这是cfg文件的使用可以使得工程更加高效与便利,这篇文章介绍的就是c++读取cfg文件的相关内容,以便及时总结和日后回顾. STL即标准模板库 ...

JdbcTemplate完全学习

概述

注意：

JdbcTemplate完全学习的更多相关文章

随机推荐

热门专题