1.环境搭建
导入所需jar包:
- commons-logging-1.2.jar
- aopalliance-1.0.jar
- spring-aop.4.2.1.RELEASE.jar
- spring-beans.4.2.1.RELEASE.jar
- spring-core.4.2.1.RELEASE.jar
- spring-context.4.2.1.RELEASE.jar
- spring-expression.4.2.1.RELEASE.jar
- spring-jdbc.4.2.1.RELEASE.jar
- spring-tx.4.2.1.RELEASE.jar
- mysql-connector-java-5.0.8-bin.jar
- junit-4.7.jar
- hamcrest-core-1.3.jar(与junit-4.7.jar配套)
2.配置文件
- 开启注解扫描,注册通过注解方式声明的dao和service类
- 加载jdbc.properties配置文件
- 注册spring自带的数据源
- 注册spring的jdbc模板类,并注入数据源(因为模板类需要在增删改查前开连接,之后关连接,依赖数据源)
jdbc配置文件的内容:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123
spring的配置文件的内容:
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 通过注解的方式注册的bean(dao,service) -->
<context:component-scan base-package="com.lyu.template" />
<!-- 加载编译路径下的jdbc配置文件(驱动,url,username,password) -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 注册Spring自带的数据源:用于开连接,关连接 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<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>
<!-- 注册jdbc模板类,并注入数据源 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
3.实体类
package com.lyu.template.entity;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 8608786494105727736L;
private Long userId;
private String userName;
private String loginName;
private String password;
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
4.dao
dao接口:增加用户,删除用户,修改用户,查询用户列表,查询用户列表(以map的形式返回)
package com.lyu.template.dao;
import java.util.List;
import java.util.Map;
import com.lyu.template.entity.User;
public interface IUserDao {
// 增加用户
boolean addUser(User user);
// 删除用户
boolean delUser(User user);
// 更新用户
boolean updateUser(User user);
// 查询用户列表
List<User> listUser();
// 将用户信息以 "字段-值" 的方式查询出来
List<Map<String, Object>> listUserMap();
}
dao实现类-jdbcTemplate的几个方法:
- int update(String sql, Object…args) 增删改
- List< T> query(String sql, RowMapper rowMapper, Object…args) 查询用户列表,rowMapper是一个接口,作用是将一条结果集映射成一个对象,可以通过new匿名内部类的形式来创建RowMapper也可以直接使用子类BeanPropertyRowMapper直接映射,详见代码。
- List< Map< String, Object>> queryForList(String sql) 同样是返回用户列表,不过返回的是map结构的列表(字段-值的形式)
package com.lyu.template.dao.impl;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import com.lyu.template.dao.IUserDao;
import com.lyu.template.entity.User;
@Repository("userDao")
public class UserDaoImpl implements IUserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public boolean addUser(User user) {
boolean flag = false;
String addSql = "insert into user(user_name, login_name, password) values(?,?,?)";
int rows = jdbcTemplate.update(addSql, user.getUserName(), user.getLoginName(), user.getPassword());
if (rows > 0) {
flag = true;
}
return flag;
}
@Override
public boolean delUser(User user) {
boolean flag = false;
String delSql = "delete from user where user_id = ?";
int rows = jdbcTemplate.update(delSql, user.getUserId());
if (rows > 0) {
flag = true;
}
return flag;
}
@Override
public boolean updateUser(User user) {
boolean flag = false;
String updateSql = "update user set user_name = ? where user_id = ?";
int rows = jdbcTemplate.update(updateSql, user.getUserName(), user.getUserId());
if (rows > 0) {
flag = true;
}
return flag;
}
@Override
public List<User> listUser() {
List<User> userList = null;
String listUserSql = "select user_id, user_name, login_name from user";
// new一个匿名内部类实现结果集到对象的映射
userList = jdbcTemplate.query(listUserSql, new RowMapper<User>(){
@Override
public User mapRow(ResultSet result, int rows) throws SQLException {
User user = new User();
user.setUserId(result.getLong("user_id"));
user.setUserName(result.getString("user_name"));
user.setLoginName(result.getString("login_name"));
return user;
}
});
// 可以使用RowMapper的子类BeanPropertyRowMapper来直接映射
userList = jdbcTemplate.query(listUserSql, new BeanPropertyRowMapper<User>(User.class));
return userList;
}
@Override
public List<Map<String, Object>> listUserMap() {
List<Map<String, Object>> userListMap = null;
String listUserMapSql = "select user_id, user_name, login_name from user";
userListMap = jdbcTemplate.queryForList(listUserMapSql);
return userListMap;
}
}
List< User>形式的返回:
List< Map< Sting,Object>>形式的返回:
5.Service
接口
package com.lyu.template.service;
import java.util.List;
import java.util.Map;
import com.lyu.template.entity.User;
public interface IUserService {
// 增加用户
boolean addUser(User user);
// 删除用户
boolean delUser(User user);
// 更新用户
boolean updateUser(User user);
// 查询用户列表
List<User> listUser();
// 将用户信息以 "字段-值" 的方式查询出来
List<Map<String, Object>> listUserMap();
}
实现类
package com.lyu.template.service.impl;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.lyu.template.dao.IUserDao;
import com.lyu.template.entity.User;
import com.lyu.template.service.IUserService;
@Service("userService")
public class UserServiceImpl implements IUserService {
@Autowired
private IUserDao userDao;
@Override
public boolean addUser(User user) {
return userDao.addUser(user);
}
@Override
public boolean delUser(User user) {
return userDao.delUser(user);
}
@Override
public boolean updateUser(User user) {
return userDao.updateUser(user);
}
@Override
public List<User> listUser() {
return userDao.listUser();
}
@Override
public List<Map<String, Object>> listUserMap() {
return userDao.listUserMap();
}
}
6.Test测试
package com.lyu.template.test;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.lyu.template.entity.User;
import com.lyu.template.service.IUserService;
public class JdbcTemplateTest {
ApplicationContext ac = null;
@Before
public void init() {
ac = new ClassPathXmlApplicationContext("applicationContext.xml");
}
// 测试增加用户
@Test
public void testAddUser() {
IUserService userService = (IUserService) ac.getBean("userService");
User user = new User();
user.setUserName("eee");
user.setLoginName("bolg");
user.setPassword("helloaaa");
boolean flag = userService.addUser(user);
System.out.println(flag?"增加用户成功":"增加用户失败");
}
// 测试删除用户
@Test
public void testDelUser() {
IUserService userService = (IUserService) ac.getBean("userService");
User user = new User();
user.setUserId(27L);
boolean flag = userService.delUser(user);
System.out.println(flag?"删除用户成功":"删除用户失败");
}
// 测试更新用户
@Test
public void testUpdateUser() {
IUserService userService = (IUserService) ac.getBean("userService");
User user = new User();
user.setUserId(15L);
user.setUserName("小菜");
boolean flag = userService.updateUser(user);
System.out.println(flag?"更新用户成功":"更新用户失败");
}
// 测试查询用户列表
@Test
public void testListUser() {
IUserService userService = (IUserService) ac.getBean("userService");
List<User> userList = userService.listUser();
for (User user : userList) {
System.out.println(user.getUserId() + "\t" + user.getUserName() + "\t" + user.getLoginName());
}
}
// 测试查询用户列表(用map返回)
@Test
public void testListUserMap() {
IUserService userService = (IUserService) ac.getBean("userService");
List<Map<String, Object>> userListMap = userService.listUserMap();
for (Map<String, Object> map : userListMap) {
for (Entry<String, Object> entry : map.entrySet()) {
System.out.println(entry.getKey() + "-" + entry.getValue());
}
System.out.println();
}
}
}
注:在实现dao层的时候也可以不注入JdbcTemplate,让dao直接继承JdbcDaoSupport,然后直接向dao注入dataSource即可(实际上是注入到了JdbcDaoSupport中),spring在调用setDataSource( )向其中注入数据源的时候在setDataSource方法内会判断是否创建了JdbcTemplate,如果没有创建模板类,就会自动创建一个模板类,在dao层只需要通过this.getJdbcTemplate()获取模板类调用增删改查方法即可。不过这样做的话spring就具有了侵入性,所以不推荐这么做。
其他:我们一般在开发中不使用spring自带的数据源,而是使用第三方的数据源例如:
-
c3p0 com.mchange.v2.c3p0.ComboPooledDataSource
连接数据库的四要素(属性):
driverClass
jdbcUrl
user
password -
druid(阿里) com.alibaba.druid.pool.DruidDataSource
连接数据库的四要素(属性):
driverClassName
url
username
password -
dbcp(阿帕奇) org.apache.commons.dbcp.BasicDataSource
连接数据库的四要素(属性):
driverClassName
url
username
password
可以看出c3p0是比较特立独行的:驱动,url,用户名都与其他两个不同,在使用c3p0的时候要注意,需要导入c3p0-0.9.0.jar
dbcp数据源在1.0版本之前性能很差,但是1.4版本之后还是可以一用的,使用的时候要导入两个包(commons-dbcp-1.4.jar, commons-pool-1.6.jar)。
druid是阿里的数据源,可以用来监控SQL的执行时间,有效的优化SQL,是一款不错的数据源,需要导入druid-1.1.5.jar。
总结:这是spring自己的jdbc模块,用的不多,仅作为了解,一般使用hibernate或者MyBatis来访问数据库。