首页 / 更多教程 / SpringJDBC数据库的基本使用
SpringJDBC数据库的基本使用
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了SpringJDBC数据库的基本使用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9441字，纯文字阅读大概需要14分钟。
内容图文
SpringJDBC的基础使用部分内容
云笔记项目数据库部分采用的是Spring-MyBatis，前面学过了JDBC，SpringJDBC，Mybatis和Spring-MyBatis，有必要重新复习一下各个数据库连接的使用方法，理解差异点后再开始项目环境配置，磨刀不误砍柴工。
(1)Spring JDBC是什么
是Spring框架对JDBC的封装，简化JDBC操作
(2)编程步骤
step1 导包
spring-webmvc，spring-jdbc，ojdbc，dbcp，junit等
在pom.xml中进行如下配置
<dependencies> <!-- 导入spring-webmvc的jar包 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.2.3.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.2.3.RELEASE</version> <classifier>sources</classifier> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.2.3.RELEASE</version> <classifier>javadoc</classifier> </dependency> <!-- 导入junit测试包--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <classifier>sources</classifier> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <classifier>javadoc</classifier> </dependency> <!-- 导入数据库包 --> <dependency> <groupId>commons-dbcp</groupId> <artifactId>commons-dbcp</artifactId> <version>1.4</version> </dependency> <dependency> <groupId>com.oracle</groupId> <artifactId>ojdbc6</artifactId> <version>11.2.0.1.0</version> </dependency> <!-- 针对mysql的导包 --> <dependency> <groupId>org.wisdom-framework</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.34_1</version> </dependency> <!-- 针对spring JDBC导包 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.2.3.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.2.3.RELEASE</version> <classifier>sources</classifier> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.2.3.RELEASE</version> <classifier>javadoc</classifier> </dependency> </dependencies>
step2 添加Spring JDBC配置文件，主要有两步：
1.读取配置文件，初始化连接池：
类似于以前的工具类DBUtils，先读取properties属性内容，然后初始化连接池BasicDataSource，设置数据库连接驱动，url，用户名和密码等，还可以配置其他参数，如最大连接数maxactive或者等待时间maxwait。
2.将连接池注入到SpringJDBCTemplate里，初始化SpringJDBCTemplate，后面就可以被使用了
<bean //此部分内容省略>
<!-- 读取properties属性文件 --> <util:properties id="db" location="classpath:config.properties"> </util:properties> <!-- 配置连接池,可以参考DBUtil的方法，这里采用spring创建连接池--> <!-- destroy-method方法作用是：当spring容器关闭后，会将连接释放回到连接池，避免资源浪费 --> <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="#{db.driver}"/>
<property name="url" value="#{db.url}" /> <property name="username" value="#{db.user}" /> <property name="password" value="#{db.pwd}" /
</bean> <!-- 配置JDBCTemplate --> <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 说明JdbcTemplate里有dataSource属性，有setDataSource方法，将连接池注入进去 --> <!-- 查看JdbcTemplate源码发现，连接池是通过构造器方式注入的 --> <property name="dataSource" ref="ds"></property> </bean> <!-- 配置组件扫描 --> <context:component-scan base-package="DAO"></context:component-scan>
可以对比下DBUtil里的方法，也是读取properties属性文件，然后初始化BasicDataSource，然后写出建立连接和关闭连接的静态方法供使用，在SpringJDBC下，会使用依赖注入的方式，帮忙初始化连接池，这是Spring的特点，降低耦合度。
package Day03;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import org.apache.commons.dbcp.BasicDataSource;
import Day01.DBUtilByDBCPInMac;
public class DBUtil {
//数据库连接池
private static BasicDataSource ds;
//为不同线程管理连接
private static ThreadLocal<Connection> tl;
//不需要实例，只需要调用静态方法
static {
try {
//创建properties
Properties prop=new Properties();
//获取文件输入流
InputStream is=DBUtilByDBCPInMac.class.getClassLoader().getResourceAsStream("day01/config.properties");
//加载文件输入流
prop.load(is);
is.close();
//读取配置信息
//初始化连接池
ds=new BasicDataSource();
//设置驱动（Class.forName()）
ds.setDriverClassName(prop.getProperty("driver"));
//设置url
ds.setUrl(prop.getProperty("url"));
//设置数据库用户名
ds.setUsername(prop.getProperty("user"));
//设置数据库密码
ds.setPassword(prop.getProperty("psw"));
//设置初始连接数
ds.setInitialSize(Integer.parseInt(prop.getProperty("initsize")));
//设置最大连接数
ds.setMaxActive(Integer.parseInt(prop.getProperty("maxactive")));
//设置等待时间
ds.setMaxWait(Integer.parseInt(prop.getProperty("maxwait")));
//设置最小空闲数
ds.setMinIdle(Integer.parseInt(prop.getProperty("minidle")));
//设置最大连接数
ds.setMaxIdle(Integer.parseInt(prop.getProperty("maxidle")));
//初始化线程本地
tl=new ThreadLocal<Connection>();
}catch(Exception e) {
e.printStackTrace();
}
}
/**
* 使用连接池获取连接
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
Connection conn=ds.getConnection();
tl.set(conn);
return conn;
}
/**
* 关闭数据库连接
*/
public static void closeConnection() {
try {
Connection conn=tl.get();
if(conn!=null) {
//恢复连接为自动提交事务
conn.setAutoCommit(true);
//关闭了连接
conn.close();
//但是连接池是不关闭连接的，为什么这里可以关闭？
//因为这里关闭的只是连接池下连接的一个子类，关闭子类不影响连接池的连接
//而是将连接归还
tl.remove();
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
step3 配置JDBC Template，生成JDBC模板
JDBCTemplate把一些重复性的代码，比如获取连接关闭连接异常处理都写好了，只需要调用该对象的方法就可以很方便的访问数据库
step4 调用JDBCTemplate的方法来进行数据库操作，通常将JDBCTemplate注入到DAO，采用依赖注入的package DAO
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import Entity.Employee;
/**
* Spring JDBC的使用
*
*/
@Repository("employeeDAO")
public class EmployeeDAO {
//依赖注入jdbcTemplate
@Resource(name="jt")//也可以用@Autowired和@Qualifier("jt")组合注解
private JdbcTemplate jt;
//把一个员工插入到数据库
public void save(Employee e) {
//只需要一条语句，完成自动创建连接，执行sql，关闭连接
String sql ="INSERT INTO T_TABLE VALUES(2,?,?)";
Object[] args= {e.getName(),e.getAge()};//元素的位置，跟上述sql一致
jt.update(sql,args);
}
/**
* 查询所有的员工
* @return
*/
//查询所有员工的方法
public List<Employee> findAll(){
String sql="SELECT * FROM T_TABLE";
return jt.query(sql, new EmpRowMapper());
}
/**
* 匿名内部类，这个类只能被当前类引用
* @author
*
*/
class EmpRowMapper implements RowMapper<Employee>{
/**
* 告诉JDBCTemplate，如何将结果集转换成一个实体对象
* rowNum：正在被处理的记录的下标，从0开始，为啥它好像在方法中就没用到过？
*/
public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
Employee e=new Employee();
e.setId(rs.getInt("ID"));
e.setName(rs.getString("NAME"));
e.setAge(rs.getInt("age"));
return e;
}
}
/**
* 使用SpringJDBCTemplate进行查询
* @param id
* @return
*/
public Employee findById(int id) {
String sql="SELECT * FROM T_TABLE WHERE ID=?";
Employee emp=null;
try {
Object[] object= {id};
emp=jt.queryForObject(sql, object, new EmpRowMapper());
}catch(EmptyResultDataAccessException e) {
//空结果数据访问异常：没有数据查询到时会抛出此异常
e.printStackTrace();
return null;
}
return emp;
}
/**
* SpringJDBC修改更新的方法
* @param emp
*/
public void modify(Employee emp) {
String sql="UPDATE T_TABLE SET NAME=?,AGE=? WHERE ID=?";
Object[] args= {emp.getName(),emp.getAge(),emp.getId()};
jt.update(sql, args);
}
/**
* SpringJDBC删除的方法
* @param id
*/
public void delete(int id) {
String sql="DELETE FROM T_TABLE WHERE ID=?";
Object[] args= {id};
jt.update(sql, args);
}
}
（3）使用junit包进行测试数据库操作，SpringJDBC底层还是调用了PreparedStatement，参数绑定在数据对象数组里
package Test;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import DAO.EmployeeDAO;
import Entity.Employee;
public class testCase {
private EmployeeDAO dao;
/**
* @before注解修饰的作用是在其他测试方法运行之前会执行
*/
@Before
public void init() {
String config="spring-jdbc.xml";
ApplicationContext ac=new ClassPathXmlApplicationContext(config);
dao=ac.getBean("employeeDAO",EmployeeDAO.class);
}
/**
* 测试springJDBCTemplate
*/
@Test
public void test() {
Employee e=new Employee();
e.setName("duanyu");e.setAge(20);
dao.save(e);
}
/**
* 测试查询方法
*/
@Test
public void test1() {
List<Employee> list=dao.findAll();
System.out.println(list);
}
/**
* 根据ID查询的测试
*/
@Test
public void test2() {
Employee emp=dao.findById(2);
System.out.println(emp);
}
/**
* 更新ID为1的员工信息，UPDATE
*/
@Test
public void test3() {
//先查到一个
Employee employee=dao.findById(2);
//对信息进行修改
employee.setAge(employee.getAge()+10);
dao.modify(employee);
Employee newEmployee=dao.findById(2);
System.out.println(newEmployee);
}
/**
* 删除id为1的员工，方法测试
*/
@Test
public void test4() {
dao.delete(2);
}
}
总结：SpringJDBC相比JDBC，降低了耦合度，并且实现自动连接和关闭数据库连接，要方便不少。
内容总结
以上是互联网集市为您收集整理的SpringJDBC数据库的基本使用全部内容，希望文章能够帮你解决SpringJDBC数据库的基本使用所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】