spring 2个jdbc_[Spring]-Spring框架-05-Spring JDBCTemplate

最新推荐文章于 2024-04-20 22:34:03 发布

Irisophia Xie

最新推荐文章于 2024-04-20 22:34:03 发布

阅读量54

点赞数

文章标签： spring 2个jdbc

本文链接：https://blog.csdn.net/weixin_34621309/article/details/113536360

版权

Spring框架

Spring JDBCTemplate

Spring 提供了不同的持久化技术

Spring为各种支持的持久化技术，都提供了简单操作的模板和回调

JDBCorg.springframework.jdbc.core.JdbcTemplate

Hibernateorg.springframework.orm.hibernate3.HibernateTemplate

IBatis(MyBatis)org.springframework.orm.ibatis.SqlMapClientTemplate

JPAorg.springframework.orm.jpa.JpaTemplate

入门案例

<1>导入相关的jar包

<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<spring-version>5.0.8.RELEASE</spring-version>
	<logging-version>1.2</logging-version>
	<mysql-version>5.1.6</mysql-version>
	<c3p0-version>0.9.5.2</c3p0-version>
	<dbcp-version>1.4</dbcp-version>
	<druid-version>1.1.10</druid-version>
</properties>         
<!-- 配置Spring内置数据库连接池 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jdbc</artifactId>
		<version>${spring-version}</version>
	</dependency>
<!-- mysql相关jar包 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>${mysql-version}</version>
	</dependency>
<!-- C3P0数据库连接池相关jar包 -->
	<dependency>
		<groupId>com.mchange</groupId>
		<artifactId>c3p0</artifactId>
		<version>${c3p0-version}</version>
	</dependency>
<!-- dbcp连接池相关jar包 -->
	<dependency>
		<groupId>commons-dbcp</groupId>
		<artifactId>commons-dbcp</artifactId>
		<version>${dbcp-version}</version>
	</dependency>
<!-- druid连接池相关jar包 -->
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>${druid-version}</version>
	</dependency>
<!-- spring内置测试相关jar包 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>${spring-version}</version>
		<scope>test</scope>
	</dependency>

第一次导入相关jar包，耐心等待加载完成，如果加载失败则需要彻底删除相关的内容后重新加载，否则无法正常使用，加载完成后有以下数据

<2>编写配置文件 (jdbc)

以下针对不同的数据库连接池进行测试，主要有4种连接池进行配置，可以通过xml文件直接配置，亦可通过外部文件进行配置（推荐使用）

基本步骤：

a.创建数据库连接池（在applicationContext.xml中进行配置）

b.创建JdbcTemplate对象

c.通过JdbcTemplate对象执行sql语句进行测试

Spring内置的数据库连接池

数据库连接池配置：

<!-- 
	a.需要在pom.xml中配置相关内容，导入所需的jar包
	b.在核心配置文件applicationContext.xml中编写配置文件
		主要是配置JdbcTemplate对象的设置和相应的连接数据库的4个参数的设置
	c.在测试中获取JdbcTemplate对象执行sql语句
 -->
 	<!-- 配置JdbcTemplate对象 -->
 	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>	
 
	<!-- 配置相应的数据库连接池 -->
	<!-- a.使用Spring内置的数据库连接池 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
   		<property name="url" value="jdbc:mysql://localhost:3306/guigu"></property>
   		<property name="username" value="root"></property>
   		<property name="password" value="root"></property>
   </bean>

测试：

/**
 * 使用下述注解需要导入spring-test jar包
 * @RunWith(SpringJUnit4ClassRunner.class)
 * @ContextConfiguration(locations="url")
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:spring/applicationContext.xml")
public class JdbcTest {

	@Autowired
	@Qualifier("jdbcTemplate")
	private JdbcTemplate jdbcTemplate;

	@Test
	public void testJdbc() {
		System.out.println(jdbcTemplate.getDataSource());
		jdbcTemplate.execute("create table suser(sid int primary key,sname varchar(40))");
	}
}

C3P0数据库连接池

C3P0数据池配置

<!-- 配置JdbcTemplate对象 -->
 	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>	
 
	<!-- b.使用C3P0数据库连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  destroy-method="close">
   		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
   		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/guigu"></property>
   		<property name="user" value="root"></property>
   		<property name="password" value="root"></property>
   </bean>

测试文件与上述相同，在测试的时候需要注释掉其他无关的数据库配置并删除指定数据库中已存在的表，避免造成错误

DBCP数据库连接池

DBCP数据库连接池配置

<!-- 配置JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- c..使用DBCP数据库连接池 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql://localhost:3306/guigu"></property>
		<property name="username" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

测试文件与上述相同，在测试的时候需要注释掉其他无关的数据库配置并删除指定数据库中已存在的表，避免造成错误

DRUID数据库连接池

DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池(据说是目前最好的连接池,不知道速度有没有BoneCP快)。

参考文档：https://blog.csdn.net/sdx1237/article/details/70305565

和其它连接池一样DRUID的DataSource类为：com.alibaba.druid.pool.DruidDataSource，基本配置参数如下：

druid数据库连接池配置

<!-- 配置JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- d.使用druid数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" 
			init-method="init" destroy-method="close"> 
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql://localhost:3306/guigu"></property>
		<property name="username" value="root"></property>
		<property name="password" value="root"></property>
	</bean>

测试文件与上述相同，在测试的时候需要注释掉其他无关的数据库配置并删除指定数据库中已存在的表，避免造成错误

利用外部文件的形式

druid数据库连接池配置：

applicationContext2.xml：

<?xml version="1.0" encoding="UTF-8"?>
<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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<!-- 
	SpringJDBC测试：利用外部文件配置
	引入context标签
	xmlns:context="http://www.springframework.org/schema/context"
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
-->
 
	<!-- 配置JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	 <!-- 引入配置文件 -->
	 <context:property-placeholder location="classpath:config/jdbc.properties"/>
	 <!-- 使用druid数据库连接池 -->
	 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"  init-method="init" destroy-method="close"> 
 			<property name="driverClassName" value="${jdbc.driver}"></property>
	   		<property name="url" value="${jdbc.url}"></property>
	   		<property name="username" value="${jdbc.username}"></property>
	   		<property name="password" value="${jdbc.password}"></property>
     </bean>
</beans>

在测试的时候与上述测试文件大同小异，在引入文件的时候是引入新建的applicationContext2.xml

实现增删改查CRUD

基本步骤：在删除创建的表格suer的基础上完成数据的增删改查

a.创建model实体类User（属性：id、name）

b.定义xxxDAO继承JdbcDaoSupport实现增删改查

c.在核心配置文件中进行相关配置（xxxDAO的注入和数据库连接池的配置）

d.定义测试文件完成基本的增删改查

代码分析：

代码分析：
User.java：
/**
 * model类：sid、sname
 */
public class User {
	private int sid;
	private String sname;
	public User() {
		super();
	}
	public User(int sid, String sname) {
		super();
		this.sid = sid;
		this.sname = sname;
	}
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	@Override
	public String toString() {
		return "User [sid=" + sid + ", sname=" + sname + "]";
	}
}

UserDAO.java：
/**
 * 定义UserRowMapper将查询的数据封装为相应的对象 
 */
class UserRowMapper implements RowMapper<User> {
	@Override
	public User mapRow(ResultSet rs, int rowNum) throws SQLException {
		User user = new User();
		// 与数据库中定义的内容一一对应
		user.setSid(rs.getInt("sid"));
		user.setSname(rs.getString("sname"));
		return user;
	}
}
/**
 * 定义UserDAO继承JdbcDaoSupport，实现数据的增删改查
 */
public class UserDAO extends JdbcDaoSupport {

	// 添加用户信息
	public void addUser(User user) {
		String sql = "insert into suser values(?,?)";
		Object[] args = { user.getSid(), user.getSname() };
		this.getJdbcTemplate().update(sql, args);
	}

	// 修改用户信息
	public void updateUser(User user) {
		String sql = "update suser set sname=? where sid=?";
		Object[] args = { user.getSname(), user.getSid() };
		this.getJdbcTemplate().update(sql, args);
	}

	// 根据用户id删除用户信息
	public void deleteUserById(int sid) {
		String sql = "delete from suser where sid=?";
		this.getJdbcTemplate().update(sql, sid);

	}

	// 查找某个字段信息
	public String getSnameBySid(int sid) {
		String sql = "select sname from suser where sid=?";
		// queryForObject(sql,返回类型,参数值...)
		return this.getJdbcTemplate().queryForObject(sql, String.class, sid);
	}

	// 查找某个对象信息
	public User getSuserBySid(int sid) {
		String sql = "select * from suser where sid=?";
		// queryForObject(sql,返回类型,参数值...)
		return this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(), sid);
	}

	// 查找某个集合信息
	public List<User> findAll() {
		String sql = "select * from suser";
		return this.getJdbcTemplate().query(sql, new UserRowMapper());
	}
}

数据库连接池配置文件：applicationContext3.xml

<?xml version="1.0" encoding="UTF-8"?>
<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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<!-- 
	SpringJDBC测试：利用外部文件配置
	引入context标签
	xmlns:context="http://www.springframework.org/schema/context"
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
-->
 
	<!-- 配置JdbcTemplate对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	 <!-- 引入配置文件 -->
	 <context:property-placeholder location="classpath:config/jdbc.properties"/>
	 <!-- 使用druid数据库连接池 -->
	 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"  init-method="init" destroy-method="close"> 
 			<property name="driverClassName" value="${jdbc.driver}"></property>
	   		<property name="url" value="${jdbc.url}"></property>
	   		<property name="username" value="${jdbc.username}"></property>
	   		<property name="password" value="${jdbc.password}"></property>
     </bean>
     <!-- 注入userDAO对象 -->
     <bean id="userDAO" class="com.guigu.spring.dao.UserDAO">
     	<property name="jdbcTemplate" ref="jdbcTemplate"></property>
     </bean>
</beans>

测试代码：

/**
 * 使用下述注解需要导入spring-test jar包 
 * @RunWith(SpringJUnit4ClassRunner.class) 
 * @ContextConfiguration(locations="url")
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext3.xml")
public class UserCRUDTest {

	@Autowired
	@Qualifier("userDAO")
	private UserDAO userDAO;

	@Test
	public void testAdd() {
		User user = new User(1, "李四");
		userDAO.addUser(user);
	}
	
	@Test
	public void testUpdate() {
		User user = new User(2, "小傻子");
		userDAO.updateUser(user);
	}
	
	@Test
	public void testDelete() {
		userDAO.deleteUserById(1);
	}
	
	@Test
	public void testFind() {
		System.out.println(userDAO.getSnameBySid(2));
		System.out.println(userDAO.getSuserBySid(2));
		System.out.println(userDAO.findAll());
	}
}