Spring JDBC
Spring对JDBC的支持和事务
spring对jdbc的支持好处
传统jdbc：
a.获取连接
b.定义sql
c.获取preparestament
d.预编译下sql 有参数还需要赋值
c.执行
f.封装（查询）
g.关闭连接
spring支持：
a.spring提供了统一的异常处理类（DataAccessException）,该异常类型是非检查型异常，不需要捕获
好处：1.各自异常都可以转换 2.不需要我们时时try catch
b.spring提供了编写DAO的支持类DaoSupport:JdbcDaoSupport，通过该类可以获取连接对象以及JdbcTemplete
jdbcTemplate：封装了增删改查的方法
Spring对JDBC的支持
DAO :
Spring中对数据访问对象(DAO)的支持旨在简化Spring与数据访问技术的操作，使JDBC、Hibernate、JPA和JDO等采用统一的方式访问
Spring提供了@Repository注解，这一注解同样允许组件扫描来发现和配置自定义DAO
而DAO的实现依赖于某个持久化源，比如一个基于JDBC的DAO需要一个数据源DataSource
JDBCTemplate
JDBC已经能够满足大部分用户最基本的需求，但是在使用JDBC时，必须自己来管理数据库资源如：获取PreparedStatement，设置SQL语句参数，关闭连接等步骤。
JDBCTemplate是什么
JDBCTemplate就是Spring对JDBC的封装，目的是使JDBC更加易于使用。
JDBCTemplate是Spring的一部分，JDBCTemplate处理了资源的建立和释放。他帮助我们避免一些常见的错误，比如忘了总要关闭连接。
使用JdbcTemplate编程我们只需要做以下步骤：
①提供SQL语句和占位符的值
②得到封装好的查询结果集
JdbcTemplate主要提供以下五类方法：
execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；
batchUpdate方法用于执行批处理相关语句；
query方法及queryForXXX方法：用于执行查询相关语句；
call方法：用于执行存储过程、函数相关语句。
如何获取template对象
方式一:类继承JdbcDaoSupport用getJdbcTemplate()获取
a.实现类继承JdbcDaoSupport
b.在实现类中通过getJdbcTemplate()获取
注:为实现类注入连接池dataSource
代码展示
接口
public interface AdminDAO {
public void del(int id);
public List<Admin> findAll();
public Admin findById(int id);
public void add(Admin admin);
public void update(Admin admin);
}
实现类
//实现类继承JdbcDaoSupport
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class AdminDAOImpl extends JdbcDaoSupport implements AdminDAO {
@Override
public void del(int id) {
String sql = "delete from admin where id=?";
Object[] params = {id};//参数
//在实现类中通过getJdbcTemplate()获取
getJdbcTemplate().update(sql,params);
}
@Override
public List<Admin> findAll() {
// 1.定义sql 2.定义参数 3.执行
String sql = "select * from admin";
List<Admin> list = getJdbcTemplate().query(sql, new AdminMapper());
return list;
}
@Override
public Admin findById(int id) {
String sql = "select * from admin where id=?";
Object[] params = {id};
Admin admin =
getJdbcTemplate().
queryForObject(sql,params,new AdminMapper());
return admin;
}
@Override
public void add(Admin admin) {
String sql =
"insert into admin values (null,?,?,?)";
Object[] params = {admin.getUsername(),
admin.getPassword(),admin.getRealname()};
getJdbcTemplate().update(sql,params);
}
@Override
public void update(Admin admin) {
String sql = "update admin set username=?,"
+ "password=?,realname=? where id=?";
Object[] params = {admin.getUsername(),
admin.getPassword(),admin.getRealname(),
admin.getId()};
getJdbcTemplate().update(sql,params);
}
}
配置文件
<!-- 导入资源文件 -->
<util:properties id="db" location="classpath:db.properties"></util:properties>
<!-- 定义连接池 -->
<bean id="myDataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="username" value="#{db.username}"></property>
<property name="password" value="#{db.password}"></property>
<property name="url" value="#{db.url}"></property>
<property name="driverClassName" value="#{db.driver}"></property>
</bean>
<bean id="adminDao" class="com.xms.dao.AdminDAOImpl">
<property name="dataSource" ref="myDataSource"></property>
</bean>
方式二:将JdbcTemplate通过bean的定义交给spring容器管理，并将dataSource给其注入
a.在实现类中定义template成员变量，并提供set方法
b.在配置文件中添加以下定义
–将JdbcTemplate通过bean的定义交给spring容器管理，并将dataSource给其注入
–将实现类交给spring容器管理，并将template对象给其注入
实现类定义template成员变量，并提供set方法
public class AdminDAOImpl2 implements AdminDAO {
private JdbcTemplate template;
public void setTemplate(JdbcTemplate template) {
this.template = template;
}
@Override
public void del(int id) {
String sql = "delete from admin where id=?";
Object[] params = {id};//参数
template.update(sql,params);
}
@Override
public List<Admin> findAll() {
// 1.定义sql 2.定义参数 3.执行
String sql = "select * from admin";
List<Admin> list = template.query(sql, new AdminMapper());
return list;
}
@Override
public Admin findById(int id) {
String sql = "select * from admin where id=?";
Object[] params = {id};
Admin admin =
template.
queryForObject(sql,params,new AdminMapper());
return admin;
}
@Override
public void add(Admin admin) {
String sql =
"insert into admin values (null,?,?,?)";
Object[] params = {admin.getUsername(),
admin.getPassword(),admin.getRealname()};
template.update(sql,params);
}
@Override
public void update(Admin admin) {
String sql = "update admin set username=?,"
+ "password=?,realname=? where id=?";
Object[] params = {admin.getUsername(),
admin.getPassword(),admin.getRealname(),
admin.getId()};
template.update(sql,params);
}
}
配置文件
在配置文件中添加以下定义
–将JdbcTemplate通过bean的定义交给spring容器管理，并将dataSource给其注入
<!-- 连接池配置文件 -->
<util:properties id="db" location="classpath:db.properties"></util:properties>
<!-- 定义连接池 -->
<bean id="myDataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="username" value="#{db.username}"></property>
<property name="password" value="#{db.password}"></property>
<property name="url" value="#{db.url}"></property>
<property name="driverClassName" value="#{db.driver}"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="myDataSource"></property>
</bean>
在spring中使用JDBC编程步骤
添加配置文件
a.新建web工程，引入jar包 (IOC/AOP/JDBC/DBCP/Mysql)
b.添加dbcp数据库，db.properties文件
#mysql的驱动
driver=com.mysql.jdbc.Driver
#连接地址
url=jdbc:mysql://localhost:3306/spring_jdbc?useUnicode=true&characterEncoding=UTF-8
#连接用户名
user=root
#连接密码
password=123456
#初始化数量
initsize=5
#最大数量
maxsize=15
#最大空闲数
maxIdle=3
#最小空闲数
minIdle=1
c.导入资源文件、配置dbcp连接池数据、配置 Spring 的 jdbcTemplate
在spring的配置文件applicationContext.xml配置中添加：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!--指定注解扫描包路径-->
<context:component-scan base-package="com.oak"/>
<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:dbutil.properties"/>
<!-- 配置dbcp连接池参数 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${driver}" />
<property name="url"
value="${url}" />
<property name="username" value="${user}" />
<property name="password" value="${password}" />
<!-- 连接池启动时的初始值 -->
<property name="initialSize" value="${initsize}" />
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxsize}" />
<!-- 最大空闲值。当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
<property name="maxIdle" value="${maxIdle}" />
<!-- 最小空闲值。当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
<property name="minIdle" value="${minIdle}" />
</bean>
<!-- 配置 Spring 的 jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
代码层书写
a.在src下新建一个包com.oak.domain，在包中新建一个实体类User
public class User {
//用户id
private Integer id;
//用户名称
private String name;
//构造方法，getter，setter方法和toString()略写
}
b.在src新建一个包com.oak.dao,在其中新建一个UserDao接口
public interface UserDao {
/**
* 根据id删除用户
* @param id
*/
void delete(Integer id);
/**
* 根据id查找用户
* @param id
* @return
*/
User findById(Integer id);
/**
* 修改用户信息
* @param user
*/
void update(User user);
/**
* 增加用户
* @param user
*/
void add(User user);
/**
* 查询所有
* @return
*/
List<User> list();
}
c.在dao包下新建类UserRowMapper实现RowMapper接口
单独定义一个类，对数据进行精细话处理，这样不用写在实现类中，解耦
public class UserRowMapper implements RowMapper<User>{
//rs为返回结果集，以每行为单位封装着
@Override
public User mapRow(ResultSet rs, int rowNum) throws SQLException {
// rs 已经指向每一条数据，不需要自己调用 next，将rs指向数据 转换 User对象
User user=new User(
rs.getInt("id"),
rs.getString("name"));
return user;
}
}
d.新建一个UserDaoImpl实现UserDao接口
@Repository
public class UserDaoImpl implements UserDao{
@Autowired
private JdbcTemplate jdbcTemplate;
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void delete(Integer id) {
jdbcTemplate.update("delete from user where id=?",new Object[]{id});
}
@Override
public User findById(Integer id) {
return jdbcTemplate.queryForObject("select * from user where id=?", new Object[]{id},
new UserRowMapper());
}
@Override
public void update(User user) {
jdbcTemplate.update("update user set name=? where id=?",new Object[]{user.getName(),user.getId()});
}
@Override
public void add(User user) {
jdbcTemplate.update("insert into user values(?,?)", new Object[]{null,user.getName()});
}
@Override
public List<User> list() {
return jdbcTemplate.query("select * from user", new UserRowMapper());
}
}
数据库层
a.创建数据库数据
在数据库spring_jdbc中新建一张数据表user:
CREATE TABLE `user` (
`id` int(4) NOT NULL AUTO_INCREMENT,
`name` varchar(15) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
测试类
@Test
public void testJdbc(){
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao=ctx.getBean("userDaoImpl",UserDao.class);
//测试增加
userDao.add(new User(null,"zs"));
}
查看数据库
测试查询：
@Test
public void testJdbc(){
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao=ctx.getBean("userDaoImpl",UserDao.class);
//测试增加
//userDao.add(new User(null,"zs"));
//测试查询
System.out.println(userDao.list());
}
控制台输出:
[User [id=1, name=zs]]
测试删除：
@Test
public void testJdbc(){
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao=ctx.getBean("userDaoImpl",UserDao.class);
//测试增加
//userDao.add(new User(null,"zs"));
//测试查询
//System.out.println(userDao.list());
//测试删除
userDao.delete(1);
}
查看数据库删除
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
