`

Spring JDBC CRUD

 
阅读更多

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);
		}
	}
}

 

 

 

 

 

  • 大小: 16.4 KB
分享到：
| 高效Java摘要
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring JdbcTemplate调用Oracle存储过程实现CRUD

    使用 Spring JdbcTemplate 调用 Oracle 存储过程实现 CRUD 在本文中，我们将讨论如何使用 Spring JdbcTemplate 调用 Oracle 存储过程来实现 CRUD（Create、Read、Update、Delete）操作。我们将首先编写 Oracle 存储...

    SpringJDBC训练素材.zip

    在学习Spring JDBC的过程中，你将深入理解如何设置数据源、事务管理以及如何进行CRUD（创建、读取、更新和删除）操作。 首先，要了解Spring JDBC的基本架构，包括DataSource、JdbcTemplate、SimpleJdbcInsert、...

    maven-springMVC-springJDBC-Demo

    【标题】"maven-springMVC-springJDBC-Demo"是一个综合性的项目示例，它演示了如何使用Maven、Spring MVC和Spring JDBC在Java Web开发中构建一个简单的应用。这个Demo旨在帮助开发者理解这三大技术的集成与协同工作...

    SpringMVC3 + SpringJDBC整合 源码。

    SpringMVC3与SpringJDBC的整合是Java Web开发中常见的技术组合，它允许...通过学习和实践这个案例，开发者可以深入理解SpringMVC和SpringJDBC的整合应用，以及如何在实际项目中实现CRUD、权限过滤和分页查询功能。

    Spring进阶：Spring的CRUD

    **Spring进阶：Spring的CRUD** 在Java企业级开发中，Spring框架是不可或缺的一部分，它为应用程序提供了全面的控制反转（IoC）和面向切面编程（AOP）支持。Spring的CRUD操作，即创建（Create）、读取（Read）、更新...

    Spring JDBC 增删改查

    Spring JDBC是Spring框架的一部分，它提供了一种抽象层，使得我们能够更方便地使用Java数据库连接（JDBC）来处理数据库操作，如增删改查（CRUD）。在这个主题下，我们将深入探讨Spring JDBC的核心概念、配置、以及...

    spring JDBC

    下面是一个简单的示例，展示了如何使用Spring JDBC执行基本的CRUD操作： ```java package com.jiaozg.dao; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Iterator; import java....

    springCRUD.zip

    在这个名为 "springCRUD.zip" 的项目中，开发者已经整合了Spring、SpringMVC和SpringJDBC这三个核心组件，构建了一个小型的CRUD（创建、读取、更新、删除）应用程序。接下来，我们将深入探讨这些关键知识点。 **...

    spring jdbc 实例源码

    Spring JDBC是Spring框架的一部分，它提供了一种抽象层，使得开发者可以更方便地使用Java数据库连接（JDBC）来操作数据库。在这个实例源码中，我们看到的是一个基于`epet`宠物项目的完整实现，该项目可能包括了创建...

    springmvc+springjdbc 的jar包

    在给定的"springmvc+springjdbc 的jar包"中，包含了这两个框架所需的所有依赖，包括Spring的核心库、AOP支持、Web支持以及Spring JDBC的相关组件。使用这些jar包，开发者可以直接在项目中导入，无需手动下载和管理...

    springjdbc使用及mybatis-generator

    例如，对于简单的CRUD操作，可以使用Spring JDBC，而对于复杂的动态SQL，MyBatis的灵活性则更有优势。 7. **事务管理**：Spring框架提供了声明式事务管理，通过在方法上添加@Transactional注解，可以自动进行事务的...

    ifunsu封装基于springjdbc的dao层api

    标题"ifunsu封装基于springjdbc的dao层api"指的是一个特定的项目或库，名为ifunsu，它已经对Spring JDBC进行了封装，以创建更易用的数据访问对象（DAO）层API。DAO层是应用程序中负责与数据库进行交互的部分，通常...

    一个完整的Spring MVC的CRUD操作实例

    在`lib`文件夹中，可能包含的是项目所需的第三方库，例如Spring框架、JDBC驱动、ORM框架等。确保这些库被正确地引入并配置到项目中。 总之，通过理解Spring MVC的核心组件和CRUD操作的实现原理，我们可以创建出功能...

    Spring使用JDBC做的增删改查

    在Java开发中，Spring框架...无论是简单的CRUD操作，还是复杂的业务逻辑，Spring JDBC都能为我们提供强有力的支持。在实际项目中，根据需求选择合适的方式来使用Spring JDBC，可以大大提高开发效率，减少出错的可能性。

    spring + jdbc框架

    Spring框架同样提供了对MongoDB的支持，Spring Data MongoDB模块允许开发者通过简单的API与MongoDB进行交互，包括CRUD操作、查询构建等。 JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人...

    Spring jdbc的codesmith模版

    标题中的“Spring jdbc的codesmith模版”指的是使用Codesmith工具配合Spring JDBC模块来生成代码的一种方式。Codesmith是一款强大的代码生成工具，可以帮助开发者自动生成常见的CRUD操作代码，提高开发效率。它允许...

    ext3+struts2+hibernate+spring的CRUD+分页

    "ext3+struts2+hibernate+spring的CRUD+分页"是一个典型的Java Web开发组合，用于实现全面的数据管理功能。这个组合充分利用了各个框架的优势，提供了一个强大的后端数据处理和前端展示的解决方案。 首先，EXT3是一...

    基于Java 通用数据访问组件，基于mybatis、spring jdbc、hibernate.zip

    本压缩包文件"基于Java 通用数据访问组件，基于mybatis、spring jdbc、hibernate.zip"包含了一些关于如何使用Java中的三种主流数据访问技术——MyBatis、Spring JDBC和Hibernate的资源，这些技术都是Java开发者必备...

    spring整合jdbc的配置

    在上面的示例中，我们使用了Spring JDBC来实现CRUD操作，并将DAO层与业务逻辑分离，以便于提高系统的可维护性和可扩展性。 Spring整合JDBC的配置可以帮助我们更方便地进行企业级应用开发，并提高系统的可维护性和可...

    boot-crmSpring数据库开发--SpringJDBC的配置

    在Spring框架中，Spring JDBC是连接数据库的重要模块，它提供了对JDBC的抽象层，使得开发者可以更加方便、高效地进行数据库操作。本教程将详细讲解如何在Spring Boot项目中配置Spring JDBC，以便进行数据库开发。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics