Spring中jdbcTemplate和RowMapper的用法
Spring中的JDBCTemplate使用(非常详细的配置过程)
Spring中的JDBCTemplate使用(非常详细的配置过程)Spring中的JDBCT emplate使用数据库准备:创建数据库创建表:Java代码:1、创建web 工程 springJdbcTemplate2、添加Spring能力在此需要将jdbc包也同时加入3、配置上mysql的连接驱动(拷贝mysql驱动包,如果不拷贝报错很诡异)在applicationContext.xml中进行配置在beans标签中填写<bean id="jdbcTemplate"class="org.springframework.jdbc. core.JdbcTemplate"><property name="dataSource"><ref local="dataSource"/></property></bean><bean id="dataSource"class="org.springframework.jdbc.d atasource.DriverManagerDataSource"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property><property name="url"><value>jdbc:mysql://localhost:3306/myspringjdbcdb</valu e></property><property name="username"><value>root</value></property><property name="password"><value>root</value></property></bean>4、创建包结构并且写出类(每个类中可以没内容)5、每个类中的源代码UserDao.javaUserDaoImp.java此项写完填写在applicationContext.xml中进行配置在beans标签中填写User.java每个成员变量都写上get和set方法并且在此类中还要加入此项写完填写在applicationContext.xml中进行配置在beans标签中填写测试类T estAction.java打印出结果:。
jdbctemplate类中的方法
jdbctemplate类中的方法JdbcTemplate类是Spring框架中的一个核心类,它被广泛用于数据库访问。
它简化了常用的数据库操作,如查询、更新、删除等,同时还提供了许多便利的方法来处理SQL语句和参数。
以下是JdbcTemplate类中的一些常用方法:1. queryForObject该方法用于执行一个SQL查询,并返回单个结果对象。
如果查询结果为空,则返回null。
如果查询结果不止一个,则抛出异常。
2. queryForList该方法用于执行一个SQL查询,并返回多个结果对象。
结果以List形式返回,每个对象都代表一行记录。
如果查询结果为空,则返回空List。
3. query该方法用于执行一个SQL查询,并将结果映射到指定的Java对象。
可以使用RowMapper接口来实现自定义的映射逻辑。
4. update该方法用于执行一个SQL更新操作,如INSERT、UPDATE、DELETE 等。
它返回更新的行数。
5. batchUpdate该方法用于批量执行一组SQL更新操作。
它接受一个SQL数组作为参数,并返回一个整数数组,其中每个元素代表相应的更新操作影响的行数。
6. execute该方法用于执行任意的SQL语句,不返回任何结果。
它可以用于执行存储过程、DDL语句等。
JdbcTemplate类提供了许多其他方法,如queryForRowSet、queryForMap、queryWithParameters等,它们都可以根据具体的需求来选择使用。
使用JdbcTemplate类可以大大简化数据库访问的代码量,提高开发效率。
jdbctemplate调用存储过程返回多行
jdbctemplate调用存储过程返回多行在Spring 的JdbcTemplate 中,如果要调用存储过程并返回多行结果,可以使用`query` 方法,并通过`RowMapper` 将每行结果映射到相应的对象。
下面是一个简单的示例:假设有一个存储过程,接收输入参数,并返回多行结果:```sqlCREATE PROCEDURE getEmployees(IN departmentId INT)BEGINSELECT * FROM employees WHERE department_id = departmentId;END;```然后,你可以使用JdbcTemplate 来调用这个存储过程:```javaimport org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;import org.springframework.stereotype.Repository;import java.sql.ResultSet;import java.sql.SQLException;import java.util.List;@Repositorypublic class EmployeeRepository {private final JdbcTemplate jdbcTemplate;public EmployeeRepository(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}public List<Employee> getEmployeesByDepartment(int departmentId) {String sql = "CALL getEmployees(?)";// 使用query 方法调用存储过程,通过RowMapper 映射结果到Employee 对象return jdbcTemplate.query(sql, new Object[]{departmentId}, new EmployeeRowMapper());}private static class EmployeeRowMapper implements RowMapper<Employee> {@Overridepublic Employee mapRow(ResultSet resultSet, int i) throws SQLException {// 将查询结果映射到Employee 对象Employee employee = new Employee();employee.setId(resultSet.getInt("id"));employee.setName(resultSet.getString("name"));// 其他属性的映射...return employee;}}}```在上述示例中,`EmployeeRepository` 类通过`jdbcTemplate.query` 方法调用存储过程,并使用`EmployeeRowMapper` 将查询结果映射到`Employee` 对象。
jdbctemplate方法详解
JdbcTemplate是Spring框架中提供的一个模板类,用于简化Java 应用程序与数据库之间的交互。
它提供了许多方便的方法,使得开发人员可以轻松地执行CRUD(创建、读取、更新和删除)操作。
以下是JdbcTemplate常用方法的详解:1. `getDataSource()`:返回与该模板关联的数据源。
2. `query(String sql, Object[] args, RowMapper<T> rowMapper)`:执行查询语句,返回结果集中的数据列表。
其中,sql是查询语句,args是查询参数的数组,rowMapper是将每一行数据映射为对象的映射器。
3. `queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)`:执行查询语句,返回结果集中的第一行数据。
如果结果集为空,则返回null。
与`query()`方法类似,但只返回单个对象。
4. `update(String sql, Object[] args)`:执行更新语句,返回受影响的行数。
其中,sql是更新语句,args是更新参数的数组。
5. `update(String sql, Object[] args, int[] updateCounts)`:执行更新语句,返回受影响的行数数组。
其中,sql是更新语句,args是更新参数的数组,updateCounts是每个参数对应的受影响行数。
6. `execute(String sql, Object[] args, int[] updateCounts)`:执行任意类型的SQL语句(不只是更新语句),返回受影响的行数数组。
其中,sql是任意类型的SQL语句,args是参数的数组,updateCounts是每个参数对应的受影响行数。
7. `queryForList(String sql, Object[] args)`:执行查询语句,返回结果集中的数据列表。
【Spring】利用spring的JdbcTemplate查询返回结果映射到自定义类型
【Spring】利⽤spring的JdbcTemplate查询返回结果映射到⾃定义类型// org.springframework.jdbc.core.JdbcTemplate 中的查询⽅法基本都有⽀持参数RowMapper<T> rowMapper的重载⽅法。
下⾯只是随便举例2个,还有很多public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {...};public <T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {...};//demo01List<Person> person = jdbcTemplate.query(sql, new RowMapper<Person>() {@Overridepublic Person mapRow(ResultSet rs, int i) throws SQLException {Person p = new Person(); //特别需要new,不然如果结果集是list就只有1个对象p.setId(rs.getString("id"));return p;}});//特别如果如demo写,很⿇烦要set很多。
此时spring提供了⼀个RowMapper的实现类BeanPropertyRowMapper//demo02List<Person> person = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Person.class));这篇博客的主要⽬的是分析BeanPropertyRowMapper的实现是怎么样。
spring中jdbctemplete的使用
spring中jdbctemplete的使用问题:spring中jdbctemplete的使用回答:前言:本文指在介绍Spring框架中的JdbcTemplate类的使用方法,涉及基本的Spring反转控制的使用方法和JDBC的基本概念。
目标是使读者能够对JdbcTemplate快速地掌握和使用。
环境搭建:1. Spring配置JdbcTemplate的使用需要有DataSource的支持,所以在配置文件中,我们首先要配置一个OracleDataSource,然后在将这个DataSource配置到JdbcTemplate里。
接着将JdbcTemplate配置进DAO层,最后将DAO配置进Model层。
jdbc:oracle:thin:root/123@localhost:1521/XE 2. 环境配置,如图:使用方法:查找多行查询:class UserRowMapper implements RowMapper public Object mapRow(ResultSet rs,int index) throws SQLException User u = new User();u.setId(rs.getString("ID"));u.setName(rs.getString("Nam e"));u.setPassword(rs.getString("Password"));return u; public List select(String where) List list;String sql = "select * from admin "+where;list = jdbcTemplate.query(sql,new RowMapperResultReader(new UserRowMapper()));return list; List最终返回的是满足条件的User队列。
jdbctemplate 的用法
JdbcTemplate是Spring框架中提供的一个模板类,用于简化数据库的操作。
以下是JdbcTemplate的一些基本用法:1. 创建JdbcTemplate对象:```javaDataSource dataSource = createDataSource(); // 创建数据源对象JdbcTemplate template = new JdbcTemplate(dataSource); // 创建JdbcTemplate对象```2. 执行增、删、改操作:```java// 定义要执行的SQL语句String sql = "UPDATE user SET age = ? WHERE name = ?";// 执行更新操作,返回受影响的行数int affectedRows = template.update(sql, new Object[]{30, "Tom"});```3. 执行查询操作:```java// 定义要执行的SQL语句String sql = "SELECT * FROM user WHERE name = ?";// 执行查询操作,将查询结果封装为List<Map<String, Object>>类型List<Map<String, Object>> results = template.queryForList(sql, new Object[]{"Tom"});```4. 执行查询操作,并将结果封装为JavaBean类型:```java// 定义要执行的SQL语句String sql = "SELECT * FROM user WHERE name = ?";// 执行查询操作,将查询结果封装为User对象User user = template.queryForObject(sql, new Object[]{"Tom"}, new UserMapper());```其中,UserMapper是一个用于映射查询结果和JavaBean类型的Mapper接口。
jdbctemplate 参数
jdbctemplate 参数JdbcTemplate是Spring框架提供的一种方便的JDBC操作方式,可以大大简化JDBC的开发。
它的构造方法如下:public JdbcTemplate(DataSource dataSource)。
其中,dataSource是实现DataSource接口的数据源。
下面是JdbcTemplate的常用方法及其参数:- execute(String sql):执行任意SQL语句,返回boolean类型的值,表示是否执行成功。
- query(String sql, RowMapper<T> rowMapper, Object... args):执行查询操作,返回查询结果的List集合,rowMapper是实现RowMapper接口的行映射器,args是可变参数,用于传递查询参数。
- queryForObject(String sql, Class<T> requiredType, Object... args):执行查询操作,返回一个单一结果,requiredType是返回结果的类型,args是可变参数,用于传递查询参数。
- update(String sql, Object... args):执行更新操作,返回更新的记录数,args是可变参数,用于传递更新参数。
- batchUpdate(String sql, List<Object[]> batchArgs):批量执行更新操作,batchArgs是一个二维数组,表示批量更新的参数列表。
- call(CallableStatementCreator csc, List<SqlParameter> declaredParameters):执行存储过程或函数,csc是实现CallableStatementCreator接口的回调对象,用于创建CallableStatement对象;declaredParameters是存储过程或函数的参数列表。
jdbctemplate查询方法
jdbctemplate查询方法JdbcTemplate是Spring JDBC的核心类,用于执行SQL语句和处理结果集。
JdbcTemplate提供了多种查询方法,包括:1. querypublic List<T> query(String sql, RowMapper<T> rowMapper, Object... args)该方法执行SQL语句,并将结果集映射为指定类型的List对象。
参数说明:- sql:要执行的SQL语句- rowMapper:结果集映射接口,用于将结果集映射为指定类型的对象,可以使用匿名内部类或Lambda表达式实现该接口- args:可选的查询参数,用于替换SQL语句中的占位符(?)示例:List<User> userList = jdbcTemplate.query("SELECT * FROM users WHERE age > ?", new RowMapper<User>() {@Overridepublic User mapRow(ResultSet rs, int rowNum) throws SQLException {User user = new User();user.setId(rs.getInt("id"));user.setName(rs.getString("name"));user.setAge(rs.getInt("age"));return user;}}, 20);2. queryForObjectpublic <T> T queryForObject(String sql, Class<T> requiredType, Object... args)该方法执行SQL语句,并将结果集的第一行映射为指定类型的对象。
jdbctemplate的方法
jdbctemplate的方法jdbcTemplate的方法jdbcTemplate是Spring框架中的一个核心类,用于简化数据库操作。
它提供了一系列方法,用于执行SQL语句、处理结果集、处理事务等操作。
本文将详细介绍jdbcTemplate的常用方法及其使用。
一、execute()方法execute()方法用于执行任意的SQL语句,可以是DDL语句、DML语句或存储过程等。
例如:```String sql = "CREATE TABLE user (id INT PRIMARY KEY, name VARCHAR(50))";jdbcTemplate.execute(sql);```上述代码创建了一个名为user的表。
二、query()方法query()方法用于执行查询操作,并返回结果集。
它接受三个参数:SQL语句、参数数组和RowMapper对象。
参数数组用于传递SQL语句中的参数,RowMapper对象用于将结果集中的每一行映射成Java 对象。
例如:```String sql = "SELECT * FROM user WHERE age > ?";Object[] params = new Object[]{18};RowMapper<User> rowMapper = new BeanPropertyRowMapper<>(User.class);List<User> userList = jdbcTemplate.query(sql, params, rowMapper);```上述代码执行了一个带参数的查询操作,并将结果集映射成User对象的List。
三、update()方法update()方法用于执行插入、更新和删除操作,并返回受影响的行数。
它接受两个参数:SQL语句和参数数组。
例如:```String sql = "INSERT INTO user (name, age) VALUES (?, ?)"; Object[] params = new Object[]{"Tom", 20};int rows = jdbcTemplate.update(sql, params);```上述代码插入了一条记录,并返回受影响的行数。
jdbctemplate query用法
文章标题:深度剖析JdbcTemplate query用法及个人观点在使用Spring框架进行数据库操作时,JdbcTemplate是一个非常常用的工具类。
其中的query方法更是被广泛使用,因此我们有必要对其用法进行深入的了解和分析。
1. JdbcTemplate query方法简介JdbcTemplate是Spring框架中的核心类之一,它封装了对数据库的常用操作,简化了JDBC编程的复杂性。
其中的query方法用于执行查询操作,并返回查询结果集。
它的用法非常灵活,可以适用于各种复杂的查询场景。
2. JdbcTemplate query方法的基本用法及参数含义- query方法的基本用法如下:```javapublic <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException;public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException;public <T> List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper) throws DataAccessException;```这些重载的query方法分别接受不同的参数组合,通过sql语句、参数数组和RowMapper对象来执行查询操作并返回结果集。
3. 深入理解RowMapper接口的作用- RowMapper接口的作用是将查询结果集中的每一行数据映射为相应的Java对象。
我们可以通过实现RowMapper接口来定义自己的数据映射规则,使得查询结果集中的数据能够直接转换为我们需要的对象类型。
jdbctemplate的query方法
jdbctemplate的query方法
JdbcTemplate是Spring提供的一个用于简化JDBC操作的工具类,其中最为常用的方法就是query()方法。
query()方法用于执行SQL查询语句,返回结果集。
方法有多种重载形式,可以根据需要传入不同的参数。
一般来说,query()方法至少需要传入两个参数:SQL语句和RowMapper对象。
SQL语句是一个字符串,可以包含占位符(?)和命名参数
(:paramName)等。
占位符和命名参数需要和后面的参数一一对应,用于传入SQL参数值。
RowMapper对象用于将SQL结果集中的每一行数据映射为Java
对象。
通常需要自己编写一个RowMapper实现类,并实现mapRow()方法。
除了这两个必须的参数外,query()方法还可以传入其他一些参数,比如PreparedStatementSetter对象、ResultSetExtractor对象、FetchSize、MaxRows等等。
使用JdbcTemplate的query()方法可以大大简化JDBC操作,提高代码的可读性和可维护性。
- 1 -。
jdbctemplate 字段映射
文章标题:深度解析jdbctemplate字段映射技术1. jdbctemplate字段映射概述jdbctemplate是Spring框架中的一个重要组件,它提供了方便、灵活的方式来访问数据库,并且在实际开发中得到了广泛的应用。
其中,字段映射是jdbctemplate中的一个关键技术,它能够将数据库表中的字段与Java对象中的属性进行映射,极大地简化了数据操作的流程。
2. jdbctemplate字段映射的基本原理在jdbctemplate中,字段映射的基本原理是利用RowMapper接口或者BeanPropertyRowMapper类,将查询结果集中的每一行数据映射到一个Java对象中。
这样,我们就能够直接操作Java对象,而不需要去关心数据库表的字段名和数据类型,大大提高了代码的可维护性和扩展性。
3. jdbctemplate字段映射的使用方法在实际使用中,我们可以通过自定义RowMapper接口的实现类,或者直接使用Spring提供的BeanPropertyRowMapper类,来实现字段映射。
如果在数据库表和Java对象属性之间存在对应关系,则可以使用BeanPropertyRowMapper类;如果需要更加灵活地处理结果集,则可以自定义RowMapper接口的实现类。
这样,我们可以根据实际的业务需求来选择合适的字段映射方式,以满足不同的开发场景。
4. jdbctemplate字段映射的优势和局限性jdbctemplate字段映射技术的优势在于简化了数据操作的流程,提高了开发效率,并且能够有效地减少开发中的重复代码。
然而,它也存在一些局限性,比如在处理复杂的映射关系时可能会比较繁琐,而且在某些特定的业务场景下可能无法完全满足需求。
5. 我的观点和理解在我看来,jdbctemplate字段映射技术是一项非常实用的技术,它能够有效地帮助我们简化数据操作的流程,提高开发效率。
但是,在实际使用中,我们需要根据具体的业务需求来选择合适的映射方式,并且需要注意避免一些潜在的局限性,从而更好地发挥其优势。
JdbcTemplate查询数据中两种处理结果集方法的简单比较
JdbcTemplate查询数据中两种处理结果集⽅法的简单⽐较public List<Cat> listCats(){//多条数据查询String sql = "select id, name, description, mother_id, createDate from tbl_cat";/*//⽅法1、使⽤RowMapper<Cat>处理结果集return jdbcTemplate.query(sql, new RowMapper<Cat>(){@Overridepublic Cat mapRow(ResultSet rs, int index) throws SQLException {// TODO Auto-generated method stubCat cat = new Cat();cat.setId(rs.getInt("id"));cat.setMother_id(rs.getInt("mother_id"));cat.setDescription(rs.getString("description"));cat.setCreateDate(rs.getDate("creatDate"));return cat;}});*///⽅法2、使⽤RowCallbackHandler()final List<Cat> catList = new ArrayList<Cat>();//在内部匿名类中使⽤jdbcTemplate.query(sql, new RowCallbackHandler() {@Overridepublic void processRow(ResultSet rs) throws SQLException {// TODO Auto-generated method stubCat cat = new Cat();cat.setId(rs.getInt("id"));cat.setMother_id(rs.getInt("mother_id"));cat.setDescription(rs.getString("description"));cat.setCreateDate(rs.getDate("creatDate"));//####do somethingcatList.add(cat);}});return catList;} 两种⽅法在功能上并没有太⼤的区别,都是⽤于定义结果集⾏的读取逻辑,将ResultSet中的数据映射到对象或者list中。
jdbcTemplate详细使用
jdbcTemplate详细使⽤RowMapper:⽤于将结果集每⾏数据转换为需要的类型,⽤户需实现⽅法mapRow(ResultSet rs, int rowNum)来完成将每⾏数据转换为相应的类型。
RowCallbackHandler:⽤于处理ResultSet的每⼀⾏结果,⽤户需实现⽅法processRow(ResultSet rs)来完成处理,在该回调⽅法中⽆需执⾏rs.next(),该操作由JdbcTemplate来执⾏,⽤户只需按⾏获取数据然后处理即可。
ResultSetExtractor:⽤于结果集数据提取,⽤户需实现⽅法extractData(ResultSet rs)来处理结果集,⽤户必须处理整个结果集;//1.查询⼀⾏数据并返回int型结果jdbcTemplate.queryForInt("select count(*) from test");//2. 查询⼀⾏数据并将该⾏数据转换为Map返回jdbcTemplate.queryForMap("select * from test where name='name5'");//3.查询⼀⾏任何类型的数据,最后⼀个参数指定返回结果类型jdbcTemplate.queryForObject("select count(*) from test", Integer.class);//4.查询⼀批数据,默认将每⾏数据转换为MapjdbcTemplate.queryForList("select * from test");//5.只查询⼀列数据列表,列类型是String类型,列名字是namejdbcTemplate.queryForList("select name from test where name=?", new Object[]{"name5"}, String.class);//6.查询⼀批数据,返回为SqlRowSet,类似于ResultSet,但不再绑定到连接上SqlRowSet rs = jdbcTemplate.queryForRowSet("select * from test");其中下⾯这些查询⽅法⽀持多列结果集:List query(String sql, RowMapper rowMapper)Map queryForMap(String sql)Object queryForObject(String sql, RowMapper rowMapper)List queryForList(String sql)其他不⽀持多列结果集的查询⽅法则会抛出IncorrectResultSetColumnCountException异常。
Spring-JDBCTemplate操作数据库(查询)
Spring-JDBCTemplate操作数据库(查询)jdbcTemplate操作数据库(查询)⼀、查询返回某个值查询表⾥⾯有多少条记录,返回是某个值queryForObject(String sql, Class<T> requiredType)第⼀个参数:sql语句第⼆个参数:返回类型Class⼆、查询返回对象queryForObject(String sql, RowMapper rowMapper, Object... args) 第⼀个参数:sql语句 第⼆个参数:RowMapper,是接⼝,返回不同类型数据,使⽤这个接⼝⾥⾯实现类完成数据封装 第三个参数:sql语句值三、查询返回集合query(String sql, RowMapper<T> rowMapper, @Nullable Object... args)第⼀个参数:sql第⼆个参数:RowMapper,是接⼝,返回不同类型数据,使⽤这个接⼝⾥⾯实现类完成数据封装第三个参数:sql语句值package com.orzjiangxiaoyu.spring.dao;import er;import java.util.List;/*** @author orz* @create 2020-08-18 9:36*/public interface UserDao {public int findCount();public User findUserInfo(int id);public List<User> findUserListInfo();}package com.orzjiangxiaoyu.spring.dao;import er;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.BeanPropertyRowMapper;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Repository;import java.util.Arrays;import java.util.List;/*** @author orz* @create 2020-08-18 9:37*/@Repositorypublic class UserDaoImpl implements UserDao {//注⼊JdbcTemplate@Autowiredprivate JdbcTemplate jdbcTemplate;@Overridepublic int findCount() {//1.创建sql语句String sql = "select count(*) from t_user";//2.调⽤⽅法实现Integer count = jdbcTemplate.queryForObject(sql, Integer.class);return count;}@Overridepublic User findUserInfo(int id) {//1.创建sql语句String sql = "select * from t_user where user_id=?";//2.调⽤⽅法实现User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);return user;}@Overridepublic List<User> findUserListInfo() {//1.创建sql语句String sql = "select * from t_user ";//2.调⽤⽅法实现List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));return list;}}package com.orzjiangxiaoyu.spring.service;import erDao;import er;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;/*** @author orz* @create 2020-08-18 9:36*/@Servicepublic class UserService {//注⼊dao@Autowiredprivate UserDao userDao;//查询表记录数public int selectCount(){int i=userDao.findCount();return i;}//查询返回对象public User findUser(int id){return userDao.findUserInfo(id);}//查询返回集合public List<User> findUserList(){return userDao.findUserListInfo();}}package com.orzjiangxiaoyu.spring.mysqltestdemo;import er;import erService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import java.util.ArrayList;import java.util.List;/*** @author orz* @create 2020-08-18 10:20*/public class Test2 {//查询返回某个值@Testpublic void test4(){ApplicationContext context=new ClassPathXmlApplicationContext("jdbcbean.xml"); UserService userService = context.getBean("userService", UserService.class);int i = userService.selectCount();System.out.println(i);}//查询返回对象@Testpublic void test5(){ApplicationContext context=new ClassPathXmlApplicationContext("jdbcbean.xml"); UserService userService = context.getBean("userService", UserService.class);User user = userService.findUser(1);System.out.println(user);}//查询返回集合@Testpublic void test6(){ApplicationContext context=new ClassPathXmlApplicationContext("jdbcbean.xml"); UserService userService = context.getBean("userService", UserService.class);List<User> userList = userService.findUserList();System.out.println(userList);}}。
Spring之jdbcTemplate:查询的三种方式(单个值、单个对象、对象集合)
Spring之jdbcTemplate:查询的三种⽅式(单个值、单个对象、对象集合)JdbcTemplateDemo2.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.JdbcTemplate;45import java.sql.*;6import java.util.List;78/**9 * 功能:通过JdbcTemplate实现查询操作10 * 查询结果需要⾃⼰封装(实现RowMapper接⼝)11*/1213public class JdbcTemplateDemo2 {14// JdbcTemplate使⽤步骤:15// 1、导⼊jar包;2、设置数据库信息;3、设置数据源;4、调⽤jdbcTemplate对象中的⽅法实现操作1617public static void main(String[] args) {18// 设置数据库信息和据源19 JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();20 JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();2122// 插⼊数据23// insertData();2425// 查询返回某⼀个值:查询表中数据总数26 queryForOne(jdbcTemplate);2728// 查询返回对象29 queryForObject(jdbcTemplate);3031// 查询返回list集合32 queryForList(jdbcTemplate);3334// 使⽤JDBC底层实现查询35 queryWithJDBC();36 }3738// 插⼊数据39public static void insertData() {40 JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();41 JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();42// 调⽤jdbcTemplate对象中的⽅法实现操作43 String sql = "insert into user value(?,?,?)";44//表结构:id(int、⾃增),name(varchar 100),age(int 10)45int rows = jdbcTemplate.update(sql, null, "Tom", 35);46 System.out.println("插⼊⾏数:" + rows);47 }4849/**50 * 查询返回某⼀个值:查询表中数据总数51*/52public static void queryForOne(JdbcTemplate jdbcTemplate) {53 String sql = "select count(*) from user";54// 调⽤⽅法获得记录数55int count = jdbcTemplate.queryForObject(sql, Integer.class);56 System.out.println("数据总数:" + count);57 }5859/**60 * 功能:查询返回单个对象61 * 步骤:新建MyRowMapper类实现RowMapper接⼝,重写mapRow⽅法,指定返回User对象62*/63public static void queryForObject(JdbcTemplate jdbcTemplate) {64 String sql = "select * from user where name = ?";65// 新建MyRowMapper类实现RowMapper接⼝,重写mapRow⽅法,指定返回User对象66 User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "Tom");67 System.out.println(user);68 }6970/**71 * 功能:查询返回对象集合72 * 步骤:新建MyRowMapper类实现RowMapper接⼝,重写mapRow⽅法,指定返回User对象73*/74public static void queryForList(JdbcTemplate jdbcTemplate) {75 String sql = "select * from user";76// 第三个参数可以省略77 List<User> users = jdbcTemplate.query(sql, new MyRowMapper());78 System.out.println(users);79 }8081/**82 * 使⽤JDBC底层实现查询83*/84public static void queryWithJDBC() {85 Connection conn = null;86 PreparedStatement psmt = null;87 ResultSet rs = null;88 String jdbcUrl = "jdbc:mysql://192.168.184.130:3306/gxrdb";8990try {91// 加载驱动92 Class.forName("com.mysql.jdbc.Driver");93// 创建连接94 conn = DriverManager.getConnection(jdbcUrl, "root", "root");95 String sql = "select * from user where name = ?";96// 预编译sql97 psmt = conn.prepareStatement(sql);98// 从1开始,没有就不需要99 psmt.setString(1, "Tom");100// 执⾏sql101 rs = psmt.executeQuery();102// int num = psmt.executeUpdate(); //增删改,返回操作记录数103104// 遍历结果集105while (rs.next()) {106//根据列名查询对应的值,也可以是位置序号107 String name = rs.getString("name");108 String age = rs.getString("age");109 System.out.println(name);110 System.out.println(age);111 }112 } catch (Exception e) {113 e.printStackTrace();114 } finally {115try {116 rs.close();117 psmt.close();118 conn.close();119 } catch (SQLException e) {120 e.printStackTrace();121 }122 }123 }124125 }MyRowMapper.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.RowMapper;45import java.sql.ResultSet;6import java.sql.SQLException;78/**9 * 实现RowMapper接⼝,返回User对象10 * */11public class MyRowMapper implements RowMapper<User>{1213 @Override14public User mapRow(ResultSet resultSet, int i) throws SQLException { 15// 获取结果集中的数据16 String name = resultSet.getString("name");17 String age = resultSet.getString("age");18// 把数据封装成User对象19 User user = new User();20 user.setName(name);21 user.setAge(age);22return user;23 }24 }JdbcTemplateObject.java1package helloworld.jdbcTemplate;23import org.springframework.jdbc.core.JdbcTemplate;4import org.springframework.jdbc.datasource.DriverManagerDataSource;56/**7 * 功能:设置数据库信息和数据源8 *9 * JdbcTemplat使⽤10 * 1、导⼊jar包;2、设置数据库信息;3、设置数据源;4、调⽤jdbcTemplate对象中的⽅法实现操作11*/12public class JdbcTemplateObject {13 DriverManagerDataSource dataSource;14 JdbcTemplate jdbcTemplate;1516public JdbcTemplateObject() {17// 设置数据库信息18this.dataSource = new DriverManagerDataSource();19this.dataSource.setDriverClassName("com.mysql.jdbc.Driver");20this.dataSource.setUrl("jdbc:mysql://192.168.184.130:3306/gxrdb");21this.dataSource.setUsername("root");22this.dataSource.setPassword("root");2324// 设置数据源25this.jdbcTemplate = new JdbcTemplate(dataSource);2627 }2829public DriverManagerDataSource getDataSource() {30return dataSource;31 }3233public void setDataSource(DriverManagerDataSource dataSource) {34this.dataSource = dataSource;35 }3637public JdbcTemplate getJdbcTemplate() {38return jdbcTemplate;39 }4041public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {42this.jdbcTemplate = jdbcTemplate;43 }44 }User.java1package helloworld.jdbcTemplate;23/**4 * 数据封装类5 * */6public class User {7private String name;8private String age;910public String getName() {11return name;12 }1314public void setName(String name) { = name;16 }1718public String getAge() {19return age;20 }2122public void setAge(String age) {23this.age = age;24 }2526 @Override27public String toString() {28return "User{姓名:" + name + "; 年龄:" + age + "}";29 }30 }。
SpringJdbcTemplate类的常用方法
SpringJdbcTemplate类的常用方法•execute(String sql)可执行任何sql语句,但返回值是void,所以一般用于数据库的新建、修改、删除和数据表记录的增删改。
•int update(String sql)•int update(String sql, Object...args)增删改,args传递实参,返回受影响的记录数。
•int[] batchUpdate(String...sql)•int[] batchUpdate(String...sql, List<Object[]> args)批量执行sql语句(增删改),返回受影响的记录数。
•setMaxRows(int max) //设置返回的最大记录数•setQueryTimeout(int timeout) //设置查询超时•setDataSource(DataSource dataSource) //设置数据源以上3个方法都有对应的get方法。
queryForObject() # 必须且只能返回一条记录,且只能查询一个字段•<T> queryForObject(String sql, T.class) //不需向sql语句传递参数•<T> queryForObject(String sql, Object[] args, T.class) //args是sql语句中?对应的值•<T> queryForObject(String sql, T.class, Object... args)String sql="select id from student_tb where name = ? and gender = ?"Object[] args=new Object[]{"张三",1};int id=jdbcTemplate.queryForObject(sql,args,int.class);ForObject,顾名思义,必须且只能返回一条记录,如果返回多条记录或没有记录匹配,都会报错;且只能查询一个字段。
Spring框架的JdbcTemplate使用
Spring框架的JdbcTemplate使⽤⽬录JdbcTemplate 概述对JdbcTemplate进⾏分步演⽰1:测试数据源2:为IoC容器配置⼀个JdbcTemplate3:更新4:批量插⼊5:查询emp_id=5的记录,封装为⼀个Java对象返回。
6:查询salary>4000的记录,封装为List集合返回7:查询最⼤的salary8:使⽤具名参数SQL插⼊⼀条员⼯记录,并以Map形式传⼊参数值。
9:使⽤具名参数SQL插⼊⼀条员⼯记录,并以SqlparamSource传⼊参数值。
JdbcTemplate 概述在之前的Javaweb学习中,学习了⼿动封装JdbcTemplate,其好处是通过(sql语句+参数)模板化了编程。
⽽真正的JdbcTemplate类,是Spring框架为我们写好的。
它是 Spring 框架中提供的⼀个对象,是对原始 Jdbc API 对象的简单封装。
除了JdbcTemplate,spring 框架还为我们提供了很多的操作模板类。
操作关系型数据的:JdbcTemplate和HibernateTemplate。
操作 nosql 数据库的:RedisTemplate。
操作消息队列的:JmsTemplate。
Spring框架的JdbcTemplate在spring-jdbc的jar包中,,除了要导⼊这个 jar 包外,还需要导⼊⼀个spring-tx的jar包(它是和事务相关的)。
当然连接池的jar包也不能忘记,这⾥使⽤的是c3p0。
使⽤JdbcTemplate⼀定要导⼊Spring的数据库模块的三个jar:使⽤JdbcTemplate可以快捷的操作数据库,本⽂章针对JdbcTemplate进⾏演⽰。
本⽂所使⽤的数据库表为jdbctemplate中的employee,表的内容如下。
对JdbcTemplate进⾏分步演⽰1:测试数据源数据库配置⽂件jdbctemplate数据库在本地数据库中已经创建。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Spring中jdbcTemplate的用法实例(一)
博客分类:
spring
一、首先配置JdbcTemplate;
要使用Jdbctemplate 对象来完成jdbc 操作。
通常情况下,有三种种方式得到JdbcTemplate 对象。
第一种方式:我们可以在自己定义的DAO 实现类中注入一个DataSource 引用来完成JdbcTemplate 的实例化。
也就是它是从外部“注入” DataSource 到DAO 中,然后自己实例化JdbcTemplate,然后将DataSource 设置到JdbcTemplate 对象中。
第二种方式:在 Spring 的 IoC 容器中配置一个 JdbcTemplate 的 bean,将DataSource 注入进来,然后再把JdbcTemplate 注入到自定义DAO 中。
第三种方式: Spring 提供了类,这个类中定义了 JdbcTemplate 属性,也定义了DataSource 属性,当设置DataSource 属性的时候,会创建jdbcTemplate 的实例,所以我们自己编写的DAO 只需要继承JdbcDaoSupport 类,然后注入DataSource 即可。
提倡采用第三种方法。
虽然下面的用法中采用了前两种方法
配置方法有3种:
1、
Java代码
1.public class UserServiceImpl implements UserService {
2.~
3.
4.private JdbcTemplate jdbcTemplate;
5.
6.public JdbcTemplate getJdbcTemplate() {
7.return jdbcTemplate;
8.}
9.
1.pdate(sql);
2.}
1.etUsername());
2.(2, ((User)(i)).getPassword
());
3.*
4.(3, ((User)(i)).getId
());
5.}
6.
7.@Override
8.public int getBatchSize() {
9.return();
10.}
11.}
12.);
13.
14.return updateCounts;
15./
16.}
17.
我们在数据库查询中,如果返回的类型是用户自定义的类型(其实我们在数据库查询中大部分返回的都是自定义的类)则需要包装,如果是Java自定义的类型,如:String则不需要.
如果sping与hibernate 相结合了,基本上是用不到,大多数都是在spring单独使用时用到.
可以通过建立内部类实现RowMapper接口,RowMapper中有一个mapRow方法,所以实现RowMapper接口一定要实现mapRow方法,而对自定义类的包装就在mapRow方法中实现.
这里只是一个简单的例子:
public class TestDao { private JdbcTemplate jt; public void
setJt(JdbcTemplate jt) { = jt; } public List<TNpc>
getAll(){ String sql = "select * from t_npc"; //使用 List list = (sql, new NpcRowMapper()); return list; } /** * 定义内部类实现RowMapper接口 */ public class NpcRowMapper implements
RowMapper{ //实现mapRow方法 public Object mapRow(ResultSet rs, int num) throws SQLException { //对类进行封装 TNpc npc = new TNpc(); ("id")); ("name")); return
npc; } } }
try
{
("true");
}
catch
{
("false");
}
finally
{
("finally");
}
try
{
//执行的代码,其中可能有异常。
一旦发现异常,则立即跳到catch执行。
否则不会执行catch里面的内容
}
catch
{
//除非try里面执行代码发生了异常,否则这里的代码不会执行
}
finally
{
//不管什么情况都会执行,包括try catch 里面用了return ,可以理解为只要执行了try或者catch,就一定会执行 finally
}。