Spring JDBC CRUD-优快云博客

本文介绍了一个使用 Spring JDBC 进行数据库操作的示例项目。项目包括 Maven 依赖配置、数据库表结构定义、实体类、DAO 接口及其实现类、Spring 配置文件等关键部分。演示了如何通过 Spring JDBC 实现数据的增删改查。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.Maven Dependency

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.fool.springjdbc</groupId>
	<artifactId>springjdbc</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springjdbc</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring-version>3.2.2.RELEASE</spring-version>
		<commons-dbcp-version>1.4</commons-dbcp-version>
		<junit-version>4.11</junit-version>
		<mysql-connector-version>5.1.24</mysql-connector-version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-version}</version>
		</dependency>
	
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>${commons-dbcp-version}</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit-version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-connector-version}</version>
		</dependency>
	</dependencies>
</project>

2.Project Directory

3.src/main/resources

schema.sql

drop table if exists t_user ;
drop table if exists t_group ;

create table t_group
(
	gid integer not null auto_increment,
	name varchar(20) not null,
	constraint group_gid_pk primary key(gid)
);

create table t_user
(
	uid integer not null auto_increment,
	username varchar(20) not null,
	password varchar(20) not null,
	nickname varchar(20) not null,
	gid integer,
	constraint user_uid_pk primary key(uid),
	constraint group_user_gid_fk foreign key(gid) references t_group(gid)
);

jdbc.properties

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8 
jdbc.username = root
jdbc.password = 123456

beans.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-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<!-- 打开Spring的Annotation支持 -->
	<context:annotation-config />

	<!-- 设定Spring 去哪些包中找Annotation -->
	<context:component-scan base-package="org.fool.springjdbc" />

	<!-- 导入src/main/resources目录下的jdbc.properties文件 -->
	<context:property-placeholder location="classpath:jdbc.properties" />

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>
</beans>

4.src/main/java

User.java

package org.fool.springjdbc.model;

public class User
{
	private int id;
	private String username;
	private String password;
	private String nickname;
	private Group group;

	public User()
	{
	}

	public User(String username, String password, String nickname)
	{
		this.username = username;
		this.password = password;
		this.nickname = nickname;
	}

	public int getId()
	{
		return id;
	}

	public void setId(int id)
	{
		this.id = id;
	}

	public String getUsername()
	{
		return username;
	}

	public void setUsername(String username)
	{
		this.username = username;
	}

	public String getPassword()
	{
		return password;
	}

	public void setPassword(String password)
	{
		this.password = password;
	}

	public String getNickname()
	{
		return nickname;
	}

	public void setNickname(String nickname)
	{
		this.nickname = nickname;
	}

	public Group getGroup()
	{
		return group;
	}

	public void setGroup(Group group)
	{
		this.group = group;
	}

	@Override
	public String toString()
	{
		return "User [id=" + id + ", username=" + username + ", password="
				+ password + ", nickname=" + nickname + ", group=" + group
				+ "]";
	}

}

Group.java

package org.fool.springjdbc.model;

public class Group
{
	private int id;
	private String name;

	public int getId()
	{
		return id;
	}

	public void setId(int id)
	{
		this.id = id;
	}

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	@Override
	public String toString()
	{
		return "Group [id=" + id + ", name=" + name + "]";
	}

}

GroupDAO.java

package org.fool.springjdbc.dao;

import org.fool.springjdbc.model.Group;

public interface GroupDAO
{
	public void add(Group group);
}

GroupDAOImpl.java

package org.fool.springjdbc.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.annotation.Resource;

import org.fool.springjdbc.model.Group;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;

@Repository("groupDAO")
public class GroupDAOImpl implements GroupDAO
{
	@Resource
	private JdbcTemplate jdbcTemplate;

	@Override
	public void add(final Group group)
	{
		/**
		 * 返回数据库的表自增主键值
		 */
		KeyHolder keyHolder = new GeneratedKeyHolder();
		
		jdbcTemplate.update(new PreparedStatementCreator()
		{
			@Override
			public PreparedStatement createPreparedStatement(Connection con)
					throws SQLException
			{
				String sql = "insert into t_group (name) value(?)";
				PreparedStatement ps = con.prepareStatement(sql,
						new String[] { "id" });
				ps.setString(1, group.getName());
				return ps;
			}
		}, keyHolder);

		group.setId(keyHolder.getKey().intValue());
	}

}

UserDAO.java

package org.fool.springjdbc.dao;

import java.util.List;

import org.fool.springjdbc.model.User;

public interface UserDAO
{
	public void add(User user, int gid);

	public void update(User user);

	public void delete(int id);

	public User load(int id);

	public List<User> list(String sql, Object[] args);
}

UserDAOImpl.java

package org.fool.springjdbc.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.fool.springjdbc.model.Group;
import org.fool.springjdbc.model.User;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

@Repository("userDAO")
public class UserDAOImpl implements UserDAO
{
	@Resource
	private JdbcTemplate jdbcTemplate;

	@Override
	public void add(User user, int gid)
	{
		String sql = "insert into t_user(username, password, nickname, gid) value(?, ?, ?, ?)";

		jdbcTemplate.update(sql, user.getUsername(), user.getPassword(),
				user.getNickname(), gid);
	}

	@Override
	public void update(User user)
	{
		String sql = "update t_user set username=?, password=?, nickname=? where uid=?";

		jdbcTemplate.update(sql, user.getUsername(), user.getPassword(),
				user.getNickname(), user.getId());
	}

	@Override
	public void delete(int id)
	{
		String sql = "delete from t_user where uid=?";

		jdbcTemplate.update(sql, id);
	}

	@Override
	public User load(int id)
	{
		String sql = "select t1.uid uid, t1.*, t2.* from t_user t1 left join t_group t2 on(t1.gid=t2.gid) where t1.uid=?";

		/*
		 * 第一个参数是SQL语句 第二个参数是SQL语句中的参数值，需要传入一个对象数组
		 * 第三个参数是一个RowMapper,这个rowMapper可以完成一个对象和数据库字段的对应，实现这个RowMapper需要
		 * 实现mapRow方法，在mapRow方法中有rs这个参数，通过rs可以有效的获取数据库的字段
		 * 如果这个方法在该DAO中会被重复使用，建议通过内部类来解决，而不要使用匿名的内部类
		 */
		User u = (User) jdbcTemplate.queryForObject(sql, new Object[] { id },
				new UserMapper());

		return u;
	}

	@Override
	public List<User> list(String sql, Object[] args)
	{
		String sql1 = "select username from t_user";
		List<String> list = jdbcTemplate.queryForList(sql1, String.class);
		for (String username : list)
		{
			System.out.println("--->" + username);
		}

		String sql2 = "select username, password from t_user";
		List<User> list2 = jdbcTemplate.query(sql2, new RowMapper<User>()
		{
			@Override
			public User mapRow(ResultSet rs, int rowNum) throws SQLException
			{
				User u = new User();
				u.setUsername(rs.getString("username"));
				u.setPassword(rs.getString("password"));
				return u;
			}
		});

		for (User user : list2)
		{
			System.out.println(user.getUsername() + "\t" + user.getPassword());
		}

		return jdbcTemplate.query(sql, args, new UserMapper());
	}

	private class UserMapper implements RowMapper<User>
	{
		@Override
		public User mapRow(ResultSet rs, int rowNum) throws SQLException
		{
			Group g = new Group();
			g.setId(rs.getInt("gid"));
			g.setName(rs.getString("name"));

			User u = new User();
			u.setGroup(g);
			u.setId(rs.getInt("uid"));
			u.setUsername(rs.getString("username"));
			u.setPassword(rs.getString("password"));
			u.setNickname(rs.getString("nickname"));

			return u;
		}
	}

}

5.src/test/java

TestSpringJDBC.java

package org.fool.springjdbc.test;

import java.util.List;

import javax.annotation.Resource;

import org.fool.springjdbc.dao.GroupDAO;
import org.fool.springjdbc.dao.UserDAO;
import org.fool.springjdbc.model.Group;
import org.fool.springjdbc.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class TestSpringJDBC
{
	@Resource(name = "userDAO")
	private UserDAO userDAO;
	@Resource(name = "groupDAO")
	private GroupDAO groupDAO;

	@Test
	public void testAdd()
	{
		Group g = new Group();
		g.setName("Develop");
		groupDAO.add(g);
		System.out.println(g.getId());

		User u = new User("SpringJDBC", "123456", "SJ");
		userDAO.add(u, g.getId());
	}

	@Test
	public void testUpdate()
	{
		User u = new User("SpringJDBC", "653421", "JS");
		u.setId(3);
		userDAO.update(u);
	}

	@Test
	public void testDelete()
	{
		userDAO.delete(4);
	}

	@Test
	public void testLoad()
	{
		User u = userDAO.load(3);
		System.out.println(u);
	}

	@Test
	public void testList()
	{
		String sql = "select t1.uid uid, t1.*, t2.* from t_user t1 left join t_group t2 on(t1.gid=t2.gid)";

		List<User> users = userDAO.list(sql, null);

		for (User u : users)
		{
			System.out.println(u);
		}
	}
}