`

Spring_MVC(4)持久层处理

SpringMVCSQLMySQLJDBC
阅读更多

这里将用到以下几个包：

引用

aopalliance-1.0.jar
commons-collections.jar
commons-dbcp.jar
commons-logging-1.1.1.jar
commons-pool.jar
jstl.jar
log4j-1.2.15.jar
mysql-connector-java-5.1.6-bin.jar
spring-beans-2.5.6.jar
spring-context-2.5.6.jar
spring-context-support-2.5.6.jar
spring-core-2.5.6.jar
spring-jdbc-2.5.6.jar
spring-tx-2.5.6.jar
spring-web-2.5.6.jar
spring-webmvc-2.5.6.jar
standard.jar


主要增加了commons-collections.jar、commons-dbcp.jar、commons-pool.jar、mysql-connector-java-5.1.6-bin.jar和spring-jdbc-2.5.6.jar
先弄个数据库，这里使用MySQL，我的最爱！ 可惜前途未卜！
建库：

Sql代码 复制代码
  1. CREATE DATABASE `spring` /*!40100 DEFAULT CHARACTER SET utf8 */;  
CREATE DATABASE `spring` /*!40100 DEFAULT CHARACTER SET utf8 */;


建表：

Sql代码 复制代码
  1. DROP TABLE IF EXISTS `spring`.`account`;   
  2. CREATE TABLE  `spring`.`account` (   
  3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,   
  4.   `username` varchar(45) NOT NULL,   
  5.   `password` varchar(45) NOT NULL,   
  6.   `birthday` datetime NOT NULL,   
  7.   `email` varchar(45) NOT NULL,   
  8.   PRIMARY KEY (`id`)   
  9. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;   
DROP TABLE IF EXISTS `spring`.`account`;
CREATE TABLE  `spring`.`account` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(45) NOT NULL,
  `password` varchar(45) NOT NULL,
  `birthday` datetime NOT NULL,
  `email` varchar(45) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;


插入默认数据：

Sql代码 复制代码
  1. INSERT INTO `spring`.`account`(   
  2.  `username`,   
  3.  `password`,   
  4.  `birthday`,   
  5.  `email`)   
  6. VALUES(   
  7.  'snowolf',   
  8.  'zlex',   
  9.  '2010-01-01',   
  10.  'snowolf@zlex.org');   
INSERT INTO `spring`.`account`(
 `username`,
 `password`,
 `birthday`,
 `email`)
VALUES(
 'snowolf',
 'zlex',
 '2010-01-01',
 'snowolf@zlex.org');


给出一个数据库查询的结果：

很不巧，为了能让数据查询更有意义，我又要改动Account类：
Account.java

Java代码 复制代码
  1. public class Account implements Serializable {   
  2.   
  3.     /**  
  4.      * 主键  
  5.      */  
  6.     private int id;   
  7.        
  8.     /**  
  9.      * 用户名  
  10.      */  
  11.     private String username;   
  12.        
  13.     /**  
  14.      * 密码  
  15.      */  
  16.     private String password;   
  17.   
  18.     /**  
  19.      * 生日  
  20.      */  
  21.     private Date birthday;   
  22.   
  23.     /**  
  24.      * Email  
  25.      */  
  26.     private String email;   
  27.        
  28.         // get方法set方法省略   
  29. }  
public class Account implements Serializable {

	/**
	 * 主键
	 */
	private int id;
	
	/**
	 * 用户名
	 */
	private String username;
	
	/**
	 * 密码
	 */
	private String password;

	/**
	 * 生日
	 */
	private Date birthday;

	/**
	 * Email
	 */
	private String email;
    
        // get方法set方法省略
}


这样，域对象与数据库表将完成一一对应绑定关系。
再建立一个用于构建数据源配置的文件database.properties
database.properties：

Properties代码 复制代码
  1. dataSource.driverClassName=com.mysql.jdbc.Driver   
  2. dataSource.url=jdbc:mysql://localhost:3306/spring   
  3. dataSource.username=root   
  4. dataSource.password=admin   
  5. dataSource.maxActive=200  
  6. dataSource.maxIdle=50  
  7. dataSource.maxWait=10000   
dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/spring
dataSource.username=root
dataSource.password=admin
dataSource.maxActive=200
dataSource.maxIdle=50
dataSource.maxWait=10000


该文件位于/WEB-INF/目录下。
接下来，我们需要把它引入spring容器，修改applicationContext.xml：
applicationContext.xml

Xml代码 复制代码
  1. <context:property-placeholder  
  2.     location="/WEB-INF/database.properties" />   
	<context:property-placeholder
		location="/WEB-INF/database.properties" />


如果需要引入多个properties文件，可以用逗号分隔。
这时，我们已经引入了数据源配置，我们可以通过修改dao.xml构建基于DBCP的数据源：
dao.xml中dataSource配置

Xml代码 复制代码
  1. <bean  
  2.         id="dataSource"  
  3.         class="org.apache.commons.dbcp.BasicDataSource"  
  4.         destroy-method="close"  
  5.         lazy-init="false"  
  6.         p:driverClassName="${dataSource.driverClassName}"  
  7.         p:url="${dataSource.url}"  
  8.         p:username="${dataSource.username}"  
  9.         p:password="${dataSource.password}"  
  10.         p:maxActive="${dataSource.maxActive}"  
  11.         p:maxIdle="${dataSource.maxIdle}"  
  12.         p:maxWait="${dataSource.maxWait}" />   
<bean
		id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close"
		lazy-init="false"
		p:driverClassName="${dataSource.driverClassName}"
		p:url="${dataSource.url}"
		p:username="${dataSource.username}"
		p:password="${dataSource.password}"
		p:maxActive="${dataSource.maxActive}"
		p:maxIdle="${dataSource.maxIdle}"
		p:maxWait="${dataSource.maxWait}" />


上述配置稀松平常，没有什么好阐述的内容，这与一般spring配置无异样。
需要注意的是这个jdbcTemplate配置！
dao.xml中jdbcTemplate配置

Xml代码 复制代码
  1. <bean  
  2.     class="org.springframework.jdbc.core.JdbcTemplate"  
  3.     p:dataSource-ref="dataSource" />   
	<bean
		class="org.springframework.jdbc.core.JdbcTemplate"
		p:dataSource-ref="dataSource" />


这个配置很关键，如果你要使用其他的ORM框架，同样需要配置这样的模板类，在Dao实现中无需继承JdbcDaoSupport类。
不需要明确JdbcTemplate的id（id="jdbcTemplate"）吗？不再需要了！
AccountDao.java

Java代码 复制代码
  1. public interface AccountDao {   
  2.   
  3.     /**  
  4.      * 读取账户信息  
  5.      *   
  6.      * @param username  
  7.      * @return  
  8.      */  
  9.     Account read(String username);   
  10.   
  11.     /**  
  12.      * 读取账户信息  
  13.      *   
  14.      * @param id  
  15.      * @return  
  16.      */  
  17.     Account read(int id);   
  18. }  
public interface AccountDao {

	/**
	 * 读取账户信息
	 * 
	 * @param username
	 * @return
	 */
	Account read(String username);

	/**
	 * 读取账户信息
	 * 
	 * @param id
	 * @return
	 */
	Account read(int id);
}


AccountDaoImpl.java

Java代码 复制代码
  1. /**  
  2.  * 2010-1-23  
  3.  */  
  4. package org.zlex.spring.dao.impl;   
  5.   
  6. import java.sql.ResultSet;   
  7. import java.sql.SQLException;   
  8.   
  9. import org.springframework.beans.factory.annotation.Autowired;   
  10. import org.springframework.jdbc.core.JdbcTemplate;   
  11. import org.springframework.jdbc.core.RowMapper;   
  12. import org.springframework.stereotype.Repository;   
  13. import org.zlex.spring.dao.AccountDao;   
  14. import org.zlex.spring.domain.Account;   
  15.   
  16. /**  
  17.  * 账户数据库实现  
  18.  *   
  19.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>  
  20.  * @version 1.0  
  21.  * @since 1.0  
  22.  */  
  23. @Repository  
  24. public class AccountDaoImpl implements AccountDao {   
  25.   
  26.     @Autowired  
  27.     private JdbcTemplate jdbcTemplate;   
  28.   
  29.     @Override  
  30.     public Account read(String username) {   
  31.         String sql = "SELECT * From account WHERE username = ?";   
  32.         return (Account) jdbcTemplate.queryForObject(sql,   
  33.                 new Object[] { username }, accountRowMap);   
  34.     }   
  35.   
  36.     @Override  
  37.     public Account read(int id) {   
  38.         String sql = "SELECT * From account WHERE id = ?";   
  39.         return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },   
  40.                 accountRowMap);   
  41.     }   
  42.   
  43.     protected RowMapper accountRowMap = new RowMapper() {   
  44.         @Override  
  45.         public Object mapRow(ResultSet rs, int rowNum) throws SQLException {   
  46.             Account account = new Account();   
  47.             account.setId(rs.getInt("id"));   
  48.             account.setUsername(rs.getString("username"));   
  49.             account.setPassword(rs.getString("password"));   
  50.             account.setBirthday(rs.getDate("birthday"));   
  51.             account.setEmail(rs.getString("email"));   
  52.             return account;   
  53.         }   
  54.     };   
  55. }  
/**
 * 2010-1-23
 */
package org.zlex.spring.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import org.zlex.spring.dao.AccountDao;
import org.zlex.spring.domain.Account;

/**
 * 账户数据库实现
 * 
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
 * @version 1.0
 * @since 1.0
 */
@Repository
public class AccountDaoImpl implements AccountDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Override
	public Account read(String username) {
		String sql = "SELECT * From account WHERE username = ?";
		return (Account) jdbcTemplate.queryForObject(sql,
				new Object[] { username }, accountRowMap);
	}

	@Override
	public Account read(int id) {
		String sql = "SELECT * From account WHERE id = ?";
		return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },
				accountRowMap);
	}

	protected RowMapper accountRowMap = new RowMapper() {
		@Override
		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			Account account = new Account();
			account.setId(rs.getInt("id"));
			account.setUsername(rs.getString("username"));
			account.setPassword(rs.getString("password"));
			account.setBirthday(rs.getDate("birthday"));
			account.setEmail(rs.getString("email"));
			return account;
		}
	};
}


分段详述：
注解@Repository明确这个类是用于持久层的实现类，注意这样的注解不能用于接口，仅适用于实现类！
同时，不再需要继承JdbcDaoSupport类，其而代之的是直接注入JdbcTemplate类！
再看声明JdbcTemplate类：

Java代码 复制代码
  1. @Autowired  
  2. private JdbcTemplate jdbcTemplate;   
	@Autowired
	private JdbcTemplate jdbcTemplate;


需要说明一下，这里的JdbcTemplate对象jdbcTemplate名称可以自定，没有任何限制！
这里使用 RowMapper 定义了一个用于绑定Account域对象的内部映射类：
RowMapper

Java代码 复制代码
  1. protected RowMapper accountRowMap = new RowMapper() {   
  2.     @Override  
  3.     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {   
  4.         Account account = new Account();   
  5.         account.setId(rs.getInt("id"));   
  6.         account.setUsername(rs.getString("username"));   
  7.         account.setPassword(rs.getString("password"));   
  8.         account.setBirthday(rs.getDate("birthday"));   
  9.         account.setEmail(rs.getString("email"));   
  10.         return account;   
  11.     }   
  12. };  
	protected RowMapper accountRowMap = new RowMapper() {
		@Override
		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			Account account = new Account();
			account.setId(rs.getInt("id"));
			account.setUsername(rs.getString("username"));
			account.setPassword(rs.getString("password"));
			account.setBirthday(rs.getDate("birthday"));
			account.setEmail(rs.getString("email"));
			return account;
		}
	};


语句级的内容，十分简单，如下所示：

Java代码 复制代码
  1. @Override  
  2. public Account read(String username) {   
  3.     String sql = "SELECT * From account WHERE username = ?";   
  4.     return (Account) jdbcTemplate.queryForObject(sql,   
  5.             new Object[] { username }, accountRowMap);   
  6. }   
  7.   
  8. @Override  
  9. public Account read(int id) {   
  10.     String sql = "SELECT * From account WHERE id = ?";   
  11.     return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },   
  12.             accountRowMap);   
  13. }  
	@Override
	public Account read(String username) {
		String sql = "SELECT * From account WHERE username = ?";
		return (Account) jdbcTemplate.queryForObject(sql,
				new Object[] { username }, accountRowMap);
	}

	@Override
	public Account read(int id) {
		String sql = "SELECT * From account WHERE id = ?";
		return (Account) jdbcTemplate.queryForObject(sql, new Object[] { id },
				accountRowMap);
	}


写完这两段代码不由感慨，我曾经就这么噼里啪啦的敲了一年多这样的代码。不断的做绑定、映射、写SQL，直到可以有机会将持久层JDBC实现替换Hibernate、iBatis，我才得以解放！
接着，再调整一下Service实现类
AccountServiceImpl.java

Java代码 复制代码
  1. public class AccountServiceImpl implements AccountService {   
  2.   
  3.     @Autowired  
  4.     private AccountDao accountDao;   
  5.   
  6.     @Override  
  7.     public Account read(String username, String password) {   
  8.         Account account = accountDao.read(username);   
  9.   
  10.         if (!password.equals(account.getPassword())) {   
  11.             account = null;   
  12.         }   
  13.         return account;   
  14.     }   
  15.   
  16.     @Override  
  17.     public Account read(int id) {   
  18.         return accountDao.read(id);   
  19.     }   
  20. }  
public class AccountServiceImpl implements AccountService {

	@Autowired
	private AccountDao accountDao;

	@Override
	public Account read(String username, String password) {
		Account account = accountDao.read(username);

		if (!password.equals(account.getPassword())) {
			account = null;
		}
		return account;
	}

	@Override
	public Account read(int id) {
		return accountDao.read(id);
	}
}


使用AccountDao接口来完成响应的操作，逻辑部分不做详述，根据业务逻辑而定！
稍稍修改一下profile.jsp，将用户的生日、邮件地址都输出出来！

Jsp代码 复制代码
  1. <fieldset><legend>用户信息</legend>   
  2. <ul>   
  3.     <li><label>用户名:</label><c:out value="${account.username}" /></li>   
  4.     <li><label>生日:</label><fmt:formatDate value="${account.birthday}"  
  5.         pattern="yyyy年MM月dd日" /></li>   
  6.     <li><label>Email:</label><c:out value="${account.email}" /></li>   
  7. </ul>   
  8. </fieldset>   
  9. 标签<fmt:formatDate />用于格式化输出，大家可以了解一下，很简单很好用的标签！ :D   
<fieldset><legend>用户信息</legend>
<ul>
	<li><label>用户名:</label><c:out value="${account.username}" /></li>
	<li><label>生日:</label><fmt:formatDate value="${account.birthday}"
		pattern="yyyy年MM月dd日" /></li>
	<li><label>Email:</label><c:out value="${account.email}" /></li>
</ul>
</fieldset>
标签<fmt:formatDate />用于格式化输出，大家可以了解一下，很简单很好用的标签！ :D


启动应用，登录，查看用户信息：
 

分享到：
| Spring_MVC(3)表单页面处理
评论
发表评论

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

相关推荐

    spring_mvc源码

    用的是spring mvc作为控制层,控制层和model采用注解,持久层采用的是hibernate3+spring整合框架,做的一个简单的用户管理源码,数据库采用的是sqlserver，sql源码在里面,采用的是hql语句,如果要改数据库,只用改model和...

    Spring的MVC Web应用中的持久层技术

    网上找的关于JDBCTEMPLATE比较好的资料.收藏

    spring，spring mvc，mybatis，maven，mySql 项目框架

    spring，spring mvc，mybatis，maven，mySql 项目框架

    maven-3.5.0多工程构建(spring4mvc分子项目)

    maven-3.5.0多工程构建(spring4mvc分子项目) 使用maven构建多模块项目。...持久层DAO层shuang-project-dao maven maven3.5.0 多工程构建 spring4mvc 子项目 maven构建项目 多模块项目 maven构建WEB项目

    Spring Boot + MVC 之service和持久化层的实现

    通过Idea创建Spring Boot java项目 基于Spring Boot + MVC 之控制器Controller实现 基于Spring Boot + MVC 之service和持久化层的实现 基于Spring Boot + JPA实现MVC三层框架

    Spring+MVC+Mybatis 书城项目

    MyBatis: MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解来配置和映射原生信息，将接口和...

    Spring + Spring MVC +Mybatis.zip

    而Mybatis框架作为持久层的框架，虽然需要自己编写SQL语句，但是其对高并发高响应的支持，以及对动态SQL和动态绑定的支持使其脱颖而出。 因此SSM框架（Spring + Spring MVC +Mybatis）逐渐取代了之前广泛使用的...

    Spring MVC MyBatis

    该案例采用目流行、规范的Java EE架构，整个应用分为DAO持久层、领域对象层、业务逻辑层、控制器层和视图层，各层之间分层清晰，层与层之间以松耦合的方法组织在一起。所有代码完全基于Eclipse IDE来完成，一步步...

    ssm(spring+spring mvc+mybatis)电子商城项目

    持久层框架：MyBatis 3.4.2 + Mybatis-plus 2.0.1 日志管理：SLF4J 1.7 + Log4j2 2.7 工具类：Apache Commons、Jackson 2.2、fastjson 1.2.20 前端技术 JS框架：Jquery 表格插件：Bootstrap Table 表单验证插件：...

    spring-mvc demo代码

    只包含了spring-mvc部分，而且使用maven搭建的，全空框架，没有集成持久层框架！

    ssm(spring+spring mvc+mybatis)高仿小米电子商城项目实例

    持久层框架：MyBatis 3.4.2 + Mybatis-plus 2.0.1 日志管理：SLF4J 1.7 + Log4j2 2.7 工具类：Apache Commons、Jackson 2.2、fastjson 1.2.20 前端技术 JS框架：Jquery 表格插件：Bootstrap Table 表单验证插件：...

    struts2，spring4，spring mvc，hibernate4，mybatis的三大框架（三套）

    struts2，spring4，spring mvc，hibernate4，mybatis的三大框架（三套）

    Spring 3.0MVC JDBC 单表操作示例.rar

    利用 注解 的形式定义 控制层 服务层 和持久层 采用MYSQL5.0数据库 自己建2张表 student 和teacher 字段 看实体类中的属性。 DAO 层采用2种方法连接proxool连接池。一种是 Spring 封装的JDBC和 操作 （teacher...

    SingleJDBCBase 基于Spring Framework基础上搭建的一个Java基础开发套件

    SingleJDBCBase 是基于Spring Framework基础上搭建的一个Java基础开发套件，...* 持久层框架：JDBC * 数据库连接池：c3p0 * 缓存框架： * 日志管理：SLF4J 1.7.25、Log4j2.8.2 * 工具类：fasterxml 2.8.7、junit 4.12、

    使用Spring MVC和JSP构建的全栈RSS阅读器Web应用程序（95分以上课程大作业）.zip

    3. MyBatis框架：MyBatis是一个持久层框架，用于与数据库进行交互。它提供了一种将数据库操作与Java对象映射起来的方式，避免了手动编写繁琐的SQL语句，并提供了事务管理和缓存等功能，简化了数据库访问的过程

    Spring开发指南

    数据持久层 事务管理 持久层封装 JDBC Hibernate in Spring ibatis in Spring Aspect Oriented Programming AOP 概念 AOP in Spring Dynamic Proxy 与Spring AOP CGLib 与 Spring AOP AOP 应用 DAO ...

    SSM框架原理 spring-mvc执行流程

    SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为controller层，service层，mapper层三层，通常称为三层架构 使用spring MVC负责请求的转发和视图管理 spring实现业务对象管理...

    Spring MVC 实例

    一个用Spring框架一站式实现的具有注册、登录功能的demo：表示层用Spring MVC，业务层用Spring，持久层用JdbcTemplate。

    基于SpringCloud开发的在线教育系统

    持久层：MySQL、MongoDB、Redis、ElasticSearch 数据访问层：使用Spring Data JPA 、Mybatis、Spring Data Mongodb等 业务层：Spring IOC、Aop事务控制、Spring Task任务调度、Feign、Ribbon、Spring AMQP、Spring ...

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