Spring+SpringMVC+Hibernate整合(封装CRUD操作)
前言:当前Web项目开发的框架主流应该非Spring+SpringMVC+Hibernate莫属,不管是工作还是学习中涉及框架技术,首先是要搭建一套运行环境,虽然网上框架整合的教程很多,但我还是输出此文,一是自己总结整理可巩固理解,二是可供有需要学习的同仁参考。本着负责人的态度,本文所有内容测试通过,运行环境为JDK8+Tomcat8,Spring4.3.9,Hibernate5.2.10.
本篇文章重点关注以下问题:
框架配置文件的编写
后台Controller、Service、Dao层编写
在Dao层封装基本CRUD操作
前台页面编写
备注:本文为简明扼要,只在代码中对关键之处进行说明,有关框架的具体使用细节,可查阅相关资料,当然,自认为代码中的说明已够详细。另外,所有配置都是基于注解的方式实现。
项目结构:
1. 配置文件
1.1 web.xml
web.xml为web项目的入口,因此首先配置web.xml. 文件中配置的编码格式和session并不是必须的,但又是很常用的,所以就一并附上了。
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
<!-- 配置Spring初始化参数(配置文件位置). -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<!-- 配置Spring监听器. -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置SpringMVC -->
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<!-- 配置编码格式. -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置session -->
<filter>
<filter-name>openSession</filter-name>
<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>openSession</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
</web-app>
1.2 SpringMVC配置文件
<?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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd">
<!-- 注解扫描包(SpringMVC只关注控制器类上的注解) -->
<context:component-scan base-package="com.wj.control" />
<!-- 开启注解 -->
<mvc:annotation-driven />
<!-- 静态资源(js/image)的访问 -->
<!-- 针对SpringMVC拦截所有请求的情况下才需要配置,以防对静态资源的访问也被拦截. -->
<!-- <mvc:resources location="/js/" mapping="/js/**"/> -->
<!-- 定义视图解析器(此处针对Jsp) -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 所有URI的前缀. -->
<property name="prefix" value="/jsp/"></property>
<!-- 所有URI的后缀. -->
<property name="suffix" value=".jsp"></property>
</bean>
</beans>
1.3 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:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 指定Spring需要扫描的包,需要Spring管理的Bean必须在此包里. -->
<!-- 当然,由SpringMVC已扫描的bean此处并不需要扫描.(可指明不需要哪些bean,此处未实现) -->
<context:component-scan base-package="com.wj" />
<!-- 使用annotation定义事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost/test?useUnicode=true&characterEncoding=utf-8"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 配置SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!--是否根据Hiberante映射创建数据表 -->
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
</props>
</property>
<!-- 指明与数据库表对应的实体类(这种特殊的类我更倾向在配置文件中指明,一目了然) -->
<property name="annotatedClasses">
<list>
<value>com.wj.entity.User</value>
</list>
</property>
</bean>
<!-- 配置一个事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
2. 后台Controller、Service、Dao层编写
2.1 首先定义实体类
package com.wj.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="T_USER")
public class User {
@Id
@GeneratedValue(generator="system-uuid")
@GenericGenerator(name = "system-uuid",strategy="uuid")
@Column(length=32)
private String id;
@Column(length=32)
private String userName;
@Column(length=32)
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return "User [id=" + id + ", userName=" + userName + ", age=" + age + "]";
}
}
2.2 Controller层
Spring提倡的主题之一就是面向接口编程,但是Controller层我并未定义接口,因为Controller层我仅写了几个测试方法,实现CRUD,定义接口并没有太大意义。
package com.wj.control;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.wj.entity.User;
import com.wj.service.IUserService;
@Controller // 指明当前类是控制器
@RequestMapping("/jsp/user") // 根路径
public class UserController {
@Autowired // 以类型的方式注入(Spring有多种方式实现自动注入,但按类型注入更简单清晰)
private IUserService userService;
@RequestMapping("/getAllUser.action")
public String getAllUser(HttpServletRequest request){
List<User> userList = userService.getAllUser();
request.setAttribute("userList", userList);
return "user/index";
}
@RequestMapping("/getUser.action")
public String getUser(String id,HttpServletRequest request){
User user = userService.getUser(id);
request.setAttribute("user", user);
return "user/editUser";
}
@RequestMapping("/toAddUser.action")
public String toAddUser(){
return "user/addUser";
}
@RequestMapping("/addUser.action")
public String addUser(User user,HttpServletRequest request){
userService.addUser(user);
return "redirect:/jsp/user/getAllUser.action";
}
@RequestMapping("/delUser.action")
public void delUser(String id,HttpServletResponse response){
String result = "{\"result\":\"error\"}";
if(userService.delUser(id)){
result = "{\"result\":\"success\"}";
}
response.setContentType("application/json");
try {
PrintWriter out = response.getWriter();
out.write(result);
} catch (IOException e) {
e.printStackTrace();
}
}
@RequestMapping("/updateUser")
public String updateUser(User user,HttpServletRequest request){
if(userService.updateUser(user)){
user = userService.getUser(user.getId());
request.setAttribute("user", user);
return "redirect:/jsp/user/getAllUser.action";
}else{
return "user/error";
}
}
}
2.3 Service层
先定义业务层的业务接口:
package com.wj.service;
import java.util.List;
import com.wj.entity.User;
public interface IUserService {
/**
* 根据id获取指定用户
* @param id
* @return
*/
public User getUser(String id);
/**
* 查询所有用户
* @return
*/
public List<User> getAllUser();
/**
* 新增用户
* @param user
*/
public void addUser(User user);
/**
* 根据id删除指定用户
* @param id
* @return
*/
public boolean delUser(String id);
/**
* 更新用户信息
* @param user
* @return
*/
public boolean updateUser(User user);
}
此样例中业务层并没有复杂业务,只是增删改查:
package com.wj.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wj.dao.IUserDao;
import com.wj.entity.User;
@Service
public class UserService implements IUserService {
@Autowired
private IUserDao userDao;
@Override
public User getUser(String id) {
return userDao.getUser(id);
}
@Override
public List<User> getAllUser() {
return userDao.getAllUser();
}
@Override
@Transactional
public void addUser(User user) {
userDao.addUser(user);
}
@Override
@Transactional
public boolean delUser(String id) {
return userDao.delUser(id);
}
@Override
@Transactional
public boolean updateUser(User user) {
return userDao.updateUser(user);
}
}
2.4 Dao层
首先定义接口:
package com.wj.dao;
import java.util.List;
import com.wj.entity.User;
public interface IUserDao {
public User getUser(String id);
public List<User> getAllUser();
public void addUser(User user);
public boolean delUser(String id);
public boolean updateUser(User user);
}
再贴上Dao层的实现:
package com.wj.dao;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.wj.entity.User;
@Repository
public class UserDao extends BaseDao<User> implements IUserDao {
@Override
public User getUser(String id) {
return get(User.class, id);
}
@Override
public List<User> getAllUser() {
return findAll(User.class);
}
@Override
public void addUser(User user) {
save(user);
}
@Override
public boolean delUser(String id) {
return delete(User.class, id);
}
@Override
public boolean updateUser(User user) {
update(user);
return true;
// String hql = "update User u set u.userName = ?0,u.age=?1 where u.id = ?2";
// Query<User> query = sessionFactory.getCurrentSession().createQuery(hql);
// query.setParameter(0, user.getUserName());
// query.setParameter(1, user.getAge());
// query.setParameter(2, user.getId());
//
// return (query.executeUpdate() > 0);
}
}
仔细观察Dao层,发现CRUD操作都是基于BaseDao提供的API进行的,显得相当简便,下面贴上BaseDao的实现。
3. 在Dao层封装基本CRUD操作
首先定义CRUD操作的接口,为适配各实体类,此处引入泛型:
package com.wj.dao;
import java.io.Serializable;
import java.util.List;
public interface IBaseDao<T> {
/**
* 根据ID加载实体
* @param entityClazz
* @param id
* @return
*/
T get(Class<T> entityClazz , Serializable id);
/**
* 保存实体
* @param entity
* @return
*/
Serializable save(T entity);
/**
* 更新实体
* @param entity
*/
void update(T entity);
/**
* 删除实体
* @param entity
*/
void delete(T entity);
/**
* 根据ID删除实体
* @param entityClazz
* @param id
*/
boolean delete(Class<T> entityClazz , Serializable id);
/**
* 获取所有实体
* @param entityClazz
* @return
*/
List<T> findAll(Class<T> entityClazz);
/**
* 获取实体总数
* @param entityClazz
* @return
*/
long findCount(Class<T> entityClazz);
}
CRUD的具体实现如下:
package com.wj.dao;
import java.io.Serializable;
import java.util.List;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
public class BaseDao<T> implements IBaseDao<T> {
@Autowired
protected SessionFactory sessionFactory;
@Override
public T get(Class<T> entityClazz, Serializable id) {
return sessionFactory.getCurrentSession().get(entityClazz, id);
}
@Override
public Serializable save(T entity) {
return sessionFactory.getCurrentSession().save(entity);
}
@Override
public void update(T entity) {
sessionFactory.getCurrentSession().saveOrUpdate(entity);
}
@Override
public void delete(T entity) {
sessionFactory.getCurrentSession().delete(entity);
}
@Override
@SuppressWarnings("unchecked")
public boolean delete(Class<T> entityClazz, Serializable id) {
String hql = "delete " + entityClazz.getSimpleName() + " en where en.id = ?0";
Query<T> query = sessionFactory.getCurrentSession()
.createQuery(hql)
.setParameter("0", id);
return (query.executeUpdate() > 0);
}
@Override
public List<T> findAll(Class<T> entityClazz) {
String hql = "select en from " + entityClazz.getSimpleName() + " en";
return find(hql);
}
@Override
public long findCount(Class<T> entityClazz) {
String hql = "select count(*) from " + entityClazz.getSimpleName();
List<T> list = find(hql);
if (list != null && list.size() == 1) {
return (Long) list.get(0);
}
return 0;
}
/**
* 根据HQL语句查询实体
* @param hql 待查询的HQL语句
* @return
*/
@SuppressWarnings("unchecked")
protected List<T> find(String hql) {
return sessionFactory.getCurrentSession()
.createQuery(hql)
.list();
}
/**
* 根据带占位符参数HQL语句查询实体
* @param hql 待查询的HQL语句
* @param params 参数
* @return
*/
@SuppressWarnings("unchecked")
protected List<T> find(String hql, Object... params) {
Query<T> query = sessionFactory.getCurrentSession().createQuery(hql);
for (int i=0, len=params.length; i<len; i++) {
query.setParameter(i + "", params[i]);
}
return query.list();
}
/**
* 使用hql 语句进行分页查询操作
* @param hql 需要查询的hql语句
* @param pageNo 查询第pageNo页的记录
* @param pageSize 每页需要显示的记录数
* @return 当前页的所有记录
*/
@SuppressWarnings("unchecked")
protected List<T> findByPage(String hql, int pageNo, int pageSize) {
Query<T> query = sessionFactory.getCurrentSession().createQuery(hql);
return query.setFirstResult((pageNo-1) * pageSize)
.setMaxResults(pageSize)
.list();
}
/**
* 使用hql 语句进行分页查询操作
* @param hql 需要查询的hql语句
* @param pageNo 查询第pageNo页的记录
* @param pageSize 每页需要显示的记录数
* @param params 如果hql带占位符参数,params用于传入占位符参数
* @return 当前页的所有记录
*/
@SuppressWarnings("unchecked")
protected List<T> findByPage(String hql , int pageNo, int pageSize, Object... params) {
Query<T> query = sessionFactory.getCurrentSession().createQuery(hql);
for (int i=0, len=params.length; i<len; i++) {
query.setParameter(i + "", params[i]);
}
return query.setFirstResult((pageNo - 1) + pageSize)
.setMaxResults(pageSize)
.list();
}
}
4. 前台页面编写
本文重在展示框架的整合,前台测试代码此处就不贴了,有兴趣的可下载附件中的zip包。
完整项目下载链接:http://pan.baidu.com/s/1qY8vWTI 密码:grx7
————————————————
版权声明:本文为CSDN博主「孤独的水手」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/u014240769/article/details/84903075
Spring+SpringMVC+Hibernate整合(封装CRUD操作)相关推荐
- Spring+SpringMVC+Hibernate整合操作数据库 概述
概述 Hibernate是一款优秀的ORM框架,能够连接并操作数据库,包括保存和修改数据.Spring MVC是Java的web框架,能够将Hibernate集成进去,完成数据的CRUD.Hibern ...
- spring+springmvc+hibernate 整合
三大框架反反复复搭了很多次,虽然每次都能搭起来,但是效率不高.最近重新搭了一次,理顺了思路,整理了需要注意的地方,分享出来. 工具:Eclipse(jdk 1.7) spring和hibernate版 ...
- Spring MVC + Hibernate + Maven:CRUD操作示例
在本文中,我想研究一个Spring MVC + Hibernate + Maven用法的示例. 这套技术暗含领域领域的基础知识. 因此,我将尝试详细解释所有重要时刻. 其他没有主题的内容将提供指向更多 ...
- Spring+SpringMvc+Hibernate(SSH)+bootstrap/Jsp整合
文章目录 前言: 准备工作: 最终项目的目录结构: 源码 一.使用idea创建web app项目 二.导包 三.SpringMVC配置 第一步:配置spring-mvc.xml 第二步:配置 web. ...
- java spring hiberate_Spring+SpringMVC+Hibernate整合实例讲解
使用Maven构建项目,用pom.xml引入相应jar,配置以下文件 创建spring.xml: xmlns="http://www.springframework.org/schema/b ...
- Spring+SpringMvc+Hibernate 框架搭建
2019独角兽企业重金招聘Python工程师标准>>> 框架篇:Spring+SpringMVC+hibernate整合开发 一.建立项目 1.新建一个空项目project 相当于e ...
- spring入门(11)-spring与hibernate整合完成增删改查的操作(封装HibernateTemplate模版类对象)
今天是spring的最后一节课,这节课老师讲了spring与hibernate整合完成增删改查的操作,这是很重要的一节课,这也是第一次真正的实现spring结合Hibernate和数据库连接上,下面是 ...
- Spring MVC Hibernate MySQL集成CRUD示例教程
Spring MVC Hibernate MySQL集成CRUD示例教程 我们在上一篇教程中学习了如何集成Spring和Hibernate.今天,我们将继续前进,并将Spring MVC和Hibern ...
- Spring+SpringMVC+Hibernate实现投票/调查问卷网站
使用SSH架构(Spring+SpringMVC+Hibernate)实现了简单的调查问卷网站.最终效果如图: 下面整理实现流程. 前言 1.SSH架构 SSH是MVC架构的一种实现. Spring. ...
最新文章
- java.lang.NoSuchMethodError: org.springframework.core.io.ResourceEditor错误
- 用JavaScript实现函数重载
- AndroidStudio自动补完包的快捷键
- Web服务(Apache、Nginx、Tomcat、Jetty)与应用(LAMP、CMS-WordPressGhost、Jenkins、Gitlab)
- python爬取所有数据_入门用Python进行Web爬取数据:为数据科学项目提取数据的有效方法...
- LINUX修改网卡MAC地址
- csdn代码区的代码不变颜色?
- php调用数据库字段代码,php读取数据库_php读取mysql所有数据库及表中字段的代码...
- cdrx7拼版工具在哪里_Coreldraw x7/x8/2017/2018高版本保存为CDR 8.0低版本插件
- 2021广州城市信息模型(CIM)白皮书发布
- 交换机与路由器技术:静态路由配置和路由器上配置DHCP、虚拟局域网VLAN
- untiy 重置动画
- 有两台电脑,一台电脑有线上网,另一台不能上网,如何通过飞秋或者其他软件,使得两台电脑间能互传文件
- 华为交换机批量加入 Vlan 方法
- 判断计算机硬件和网络故障,计算机硬件故障的识别与处理
- 微软.net精简框架最常见问题
- formatDate
- 云栖渐进:一个科技论坛的变迁与互联网历史
- [HDU4628]解题报告,状态压缩dp
- 利用Keras开发用于分类问题的双向LSTM及与LSTM性能的比较