Spring框架 (11) —— Spring的JDBC操作、小结

Spring的JDBC操作

Spring对象也支持JDBC,对JDBC只进行了薄薄的一层封装
问题： Java开发已经有JDBC,为什么Spring还要支持JDBC操作呢?
最重要的原因: Spring操作JDBC能自动管理事务

操作步骤

1,创建数据库 spring_jdbc
2.创建数据表 t_user

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

3.创建对应的domain对象

public class User {
	private Integer id;
	private String name;
	private String email;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", email=" + email + "]";
	}
	public User(Integer id, String name, String email) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	
}

4.创建DAO层

public class UserDaoImpl implements UserDao {

	@Override
	public void save(User user) {
		
	}

	@Override
	public void delete(Integer id) {
	}

	@Override
	public void update(User user) {
		
	}

	@Override
	public User findById(Integer id) {
	
		return null;
	}

	@Override
	public List<User> list() {
		
		return null;
	}
}

5.创建Service层

public class UserServiceImpl implements UserService {
	
	private UserDao dao;
	
	@Override
	public void save(User user) {
		dao.save(user);
	}

	@Override
	public void delete(Integer id) {
		dao.delete(id);
	}

	@Override
	public void update(User id) {
		dao.update(id);
	}

	@Override
	public User findById(Integer id) {
		// TODO Auto-generated method stub
		return dao.findById(id);
	}

	@Override
	public List<User> list() {
		// TODO Auto-generated method stub
		return dao.list();
	}

	public void setDao(UserDao dao) {
		this.dao = dao;
	}
}

6.测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UserServiceTest {
	
	
	@Resource
	private UserService service;
	
	@Test
	public void testSave() {
		
		User user = new User(null, "乔峰", "qf@qq.com");
		
		service.save(user);
	}

	@Test
	public void testDelete() {
		service.delete(3);
	}

	@Test
	public void testUpdate() {
		User user = new User(2, "段誉", "123123sdfsdf@qq.com");
		service.update(user);
	}

	@Test
	public void testFindById() {
		
		User user = service.findById(1);
		System.out.println(user);
		
	}
	@Test
	public void testList() {
		
		List<User> users = service.list();
		System.out.println(users);
	}
}

ApplicationContext.xml配置

<!-- 引入 db.properties配置文件 -->
<context:property-placeholder location="classpath:db.properties"/>

<!-- 配置Druid连接池 : DataSource 数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" 
	destroy-method="close"
>
	<!-- setter方法注入属性值 -->
	<property name="driverClassName" value="${jdbc.driverClassName}"/>
	<property name="url" value="${jdbc.url}"/>
	<property name="username" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
	<!-- 最大连接数 -->
	<property name="maxActive" value="${jdbc.maxActive}"/>
</bean>


<!-- 配置DAO层 -->
<bean id="userDao" class="cn.xc.spring.dao.impl.UserDaoImpl2">
	<!-- setter方法注入数据源:连接池 -->
	<property name="dataSource" ref="dataSource"/>
</bean>

<!-- 配置Service层 -->
<bean id="userSercice" class="cn.xc.spring.service.impl.UserServiceImpl">
	<!-- 注入dao -->
	<property name="dao" ref="userDao"/>
</bean>

快速生成一个类有多个测试方法的单元测试类

JDBCTemplate模板类

Spring为各大框架提供对应的模板类可以直接操作数据库

如果使用JDBC就使用JDBCTemplate类(将数据库的基本操作方法已经封装好了,直接调用即可)

导入相关jar包

mysql-connector-java-5.x.jar:MySQL驱动包
spring-jdbc-4.3.2.RELEASE.jar:支持JDBC
spring-tx-4.3.2.RELEASE.jar: 支持事务
druid1.1.9.jar 连接池

配置文件配置JDBCTemplate

Xml方式配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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
        " >
   	
   	
   	<!-- 配置组件包扫描的位置 -->
   	<context:component-scan base-package="cn.xc.spring"/>
   	
   	
   	  <!-- 读取db.properties配置文件到Spring容器中 -->
     <context:property-placeholder location="classpath:db.properties"/>

	
	<!-- 配置 阿里巴巴的 druid 数据源（连接池） -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
	init-method="init" destroy-method="close">
		<!-- 
			SpringEL 语法 ${key} 
		 -->
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		
		<!-- 
			${username}如果key是username，name 默认spring框架调用的当前操作系统的账号
			解决方案：可以统一给key加一个前缀
		 -->
		
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
		<property name="maxActive" value="${jdbc.maxActive}"/>
	</bean>
   	
   	
   	
   	<!-- 配置jdbcTemplate 模板类  -->
   	<bean id="jdbcTemplate" scope=”prototype” class="org.springframework.jdbc.core.JdbcTemplate">
   		
   		<!-- 注入数据源,set方法注入 -->
   		<property name="dataSource" ref="dataSource"/>
   		<!-- 构造器注入 -->
   		<!-- <constructor-arg name="dataSource" ref="dataSource"/> -->
   	</bean>
</beans>

注解方式

package cn.xc.spring.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.core.JdbcTemplate;

import com.alibaba.druid.pool.DruidDataSource;

/*
 * @Configuration 
 * 把当前类作为Spring框架的配置文件 等价于 applicationContext.xml
 * 
 * @ComponentScan 配置包扫描位置
 * 
 * 
 * @PropertySource 读取.properties配置文件
 * 
 */
@Configuration
@ComponentScan("cn.xc.spring")//等价于 <context:component-scan base-package="cn.zj.spring"/>
//@ComponentScan(basePackages = {"cn.zj.spring.dao","cn.zj.spring.service","cn.zj.spring.controller"} )
@PropertySource("classpath:db.properties")//<context:property-placeholder location="classpath:db.properties"/>
public class SpringConfig {
	/*
	 * @Value 读取 Spring加载 .properties 配置文件 key 对应的值
	 * 
	 * @Value("${key}")
	 * 	 注解贴在 成员变量上面，自动会把读取出来key对应的值赋值给成员变量
	 * 	如果不读取值，可以直接写值
	 * 
	 * @Value("com.mysql.jdbc.Driver");
	 */
	
	@Value("${jdbc.driverClassName}") //等价于 <property name="username" value="${jdbc.username}"/>
	//@Value("com.mysql.jdbc.Driver")
	private String driverClassName;
	
	@Value("${jdbc.url}")
	private String url;
	
	@Value("${jdbc.username}")
	private String username;
	
	@Value("${jdbc.password}")
	private String password;
	
	@Value("${jdbc.maxActive}")
	private Integer maxActive;
	
	
	
	@Bean(name = "dataSource",initMethod = "init",destroyMethod = "close")
	//@Scope("singleton")
	//等价于 <bean  id="dataSouce" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
	public DataSource getDataSource() {
		//创建阿里巴巴连接池对象
		DruidDataSource ds = new DruidDataSource();
		ds.setDriverClassName(driverClassName);
		ds.setUrl(url);
		ds.setUsername(username);
		ds.setPassword(password);
		ds.setMaxActive(maxActive);
		return ds;
	}
	
	/**
	 * 返回jdbcTemplate对象的 配置
	 */
	@Bean
	@Scope("prototype")//每一个dao中需要一个独立jdbcTeample对象，所以是多例
	public JdbcTemplate getJdbcTemplate() {
		JdbcTemplate jdbcTemplate = new JdbcTemplate(getDataSource());
		return jdbcTemplate;
	}

}

Dao层代码

// 引入JDBCTemplate 模板类
	private JdbcTemplate jdbcTemplate;

	//使用setter方式注入数据源即可
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}

	@Override
	public void save(User user) {
		this.jdbcTemplate.update("insert into t_user (name,email) values (?,?)",
				user.getName(),user.getEmail());
	}

	@Override
	public void delete(Integer id) {
		this.jdbcTemplate.update("delete from t_user where id = ?",id);

	}

	@Override
	public void update(User user) {
		this.jdbcTemplate.update("update t_user set name = ?,email = ? where id = ?",
				user.getName(),user.getEmail(),user.getId());
	}

	@Override
	public User findById(Integer id) {
		String sql = "select * from t_user where id = ?";
		User user = this.jdbcTemplate.queryForObject(sql,new Object[] {id}, new RowMapper<User>() {
			@Override
			public User mapRow(ResultSet rs, int rowNum) throws SQLException {
				User user = new User();
				user.setName(rs.getString("name"));
				user.setEmail(rs.getString("email"));
				user.setId(id);
				return user;
			}
		});
		return user;
	}

	@Override
	public List<User> list() {
		String sql = "select * from t_user";
		
		List<User> users = this.jdbcTemplate.query(sql,new RowMapper<User>(){
			@Override
			public User mapRow(ResultSet rs, int rowNum) throws SQLException {
				User user = new User();
				user.setName(rs.getString("name"));
				user.setEmail(rs.getString("email"));
				user.setId(rs.getInt("id"));
				return user;
			}
		});
		
		return users;
	}

小结

Spring的IOC和DI 的配置 可以使用XML配置，也可以注解配置
1. 注解配置IOC （控制反正，将对象的创建权交给Spring）-重点
(1) @Component 通用IOC 组件，试用任意Spring对象管理
(2) @Controller 主要在表现层使用
(3) @Service 业务层使用
(4) @Repository DAO层使用
(5) 必须在xml中配置包扫描的位置
(6) <context:component-scan base-package=”cn.xc.spring”>
(7) Scope 设置对象的生命周期（作用范围）
① Singleton 单例 默认
② Prototype 多例
③ Request Web开发一次请求有效
④ Session Web开发一次会话有效
(8) PostConstructor 初始化方法
(9) PreDestory 销毁方法
2. 注解配置DI （依赖注入）注入对象的属性（值，集合，引用）-重点
(1) @Autowired + @Qualifier Spring 框架提供
① 字段注入
② Setter注入
③ 构造器注入
(2) @Resource JavaEE 官方的规范
① 字段注入
② Setter注入
③ 没有构造器注入
3. Spring纯注解配置-重点
(1) 纯注解配置替代xml配置，但是所有配置依然存在，只是配置方式变换成在类上面贴注解的形式（未来的趋势）–SpringBoot（纯注解）
4. Spring测试-（理解）
(1) 为了更方便的开发Spring程序
5. SpringJDBC-（理解）
(1) 优点 ：主要能够让Spring自动控制事务
(2) JdbcTemplate 模板类 进行数据表的增删改查