SpringMVC+Hibernate4+Spring3整合开发实现CRUD

·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题；

一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可；

FileàInportàSVNà从SVN检出项目

 

我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，

 

 

选择项目文件夹finish即可；

 

·我们首先要生成简单Java类，也称POJO类，既然有添加hibernate的开发支持，当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本，其中包括最常用的字段即可，就编写一个雇员表吧；

USE mysql ;

DROP TABLE emp ;

CREATE TABLE emp(

empno INT AUTO_INCREMENT ,

ename VARCHAR(30) NOT NULL ,

hiredate DATE ,

sal VARCHAR(50) NOT NULL ,

CONSTRAINT pk_nid PRIMARY KEY(empno)

) ;

·用hibernate生成一个表的对应的简单java类，打开DB Browser视图à找到对应的表右键àhibernate Reverse Engineering……

 

这个界面就按照下图的设置，下图中没显示的部分，取消勾选，不做设置；

 

 

 

·配置完成之后，会生成一个以表名称为类名的一个简单java类，不过首字母大写，采用的annotation注解的方式和数据表配置了映射关系，生成的类会有一些警告，压制一些就OK了，生成的构造方法没有任何用处，删掉即可，一些注释也可以删掉了，另外增加一个toString()方法，这样在做一些异常调试的时候很方便，此类我做了一点简单的注释，可以一看；

Emp.java

package cn.oracle.pojo;

 

import java.util.Date;

 

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

import javax.persistence.Temporal;

import javax.persistence.TemporalType;

@SuppressWarnings("serial")è压制警告用的

@Entityè代表这一个实体，与数据表映射对应；

@Table(name = "emp", catalog = "mysql")è此设置了这个实体对应的数据库名称和表名称；

name 属性是表名称，catalog 是你用到数据库的名字；

public class Emp implements java.io.Serializable {

private Integer empno;è对应的字段名称；

private String ename; è对应的字段名称；

private Date hiredate; è对应的字段名称；

private String sal; è对应的字段名称；

@Idè表示这个字段值主键，唯一的

@GeneratedValueè表示此字段自动增长，

@Column(name = "empno", unique = true, nullable = false)è对应表中的列的属性，name 表示列名称，unique表示唯一性,nullable表示是否为空；

public Integer getEmpno() {

return this.empno;

}

 

public void setEmpno(Integer empno) {

this.empno = empno;

}

 

@Column(name = "ename", nullable = false, length = 30)èlength表示长度

public String getEname() {

return this.ename;

}

 

public void setEname(String ename) {

this.ename = ename;

}

 

@Temporal(TemporalType.DATE)è专门标注日期的；

@Column(name = "hiredate", length = 10)

public Date getHiredate() {

return this.hiredate;

}

 

public void setHiredate(Date hiredate) {

this.hiredate = hiredate;

}

 

@Column(name = "sal", nullable = false, length = 50)

public String getSal() {

return this.sal;

}

 

public void setSal(String sal) {

this.sal = sal;

}

 

@Override

public String toString() {

return "Emp [empno=" + empno + ", ename=" + ename + ", hiredate="

+ hiredate + ", sal=" + sal + "]";

}

}

·简单java类完成是第一步，然后我们需要配置数据库连接了，这是正常的思维模式，也就是最基本的JDBC开发思维模式，但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池，只要得到对应的bean就可以得到数据库连接了，也就能操作数据库了；数据库连接类也就相当于spring给我们提供好了，那接下来就是编写接口了，首先编写DAO层接口，DAO(data access Object) 叫做数据访问对象，首先，我们利用泛型编写一个公共的DAO接口，实现基本的CRUD ，当数据表非常多的时候编写此公共的接口很节省代码的；

IDAO.java

package cn.oracle.dao;

 

import java.util.List;

 

public interface IDAO<K,V> {

/**

 * 增加一条数据；

 * @param vo 简单Java类对象；

 * @return 返回一个boolean对象，增加成功返回true,增加失败返回false;

 * @throws Exception

 */

public boolean doCreate(V vo)throws Exception;

/**

 * 更新一条数据；

 * @param vo 简单Java类对象；

 * @return 返回一个boolean对象，更新成功返回true,更新失败返回false;

 * @throws Exception

 */

public boolean doUpdate(V vo)throws Exception;

/**

 * 删除一条数据；

 * @param id 简单Java类对象的id；

 * @return 返回一个boolean对象，删除成功返回true,删除失败返回false;

 * @throws Exception

 */

public boolean doRemove(int id)throws Exception;

/**

 * 查询出一条数据，

 * @param id 数据对应的id

 * @return 返回一个简单java类对象；

 * @throws Exception

 */

public K findById(int id)throws Exception;

/**

 * 查询所有的数据；

 * @return 返回一个简单Java类对象；

 * @throws Exception

 */

public List<V> findAll()throws Exception;

/**

 * 模糊查询，也是分页要用的一个方法；

 * @param column 列名称

 * @param keyWord 关键字

 * @param currentPage 当前页

 * @param lineSize 每页现实的数据条目

 * @return 返回一个List集合；

 * @throws Exception

 */

public List<V> findAll(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;

/**

 * 统计模糊查询的条目

 * @param column 列名称

 * @param keyWord 关键字

 * @return 返回一个整数

 * @throws Exception

 */

public int getAllCount(String column,String keyWord)throws Exception;

}

 

·公共的接口开发完成了，我们接下来就开发IEmpDAO接口，这个接口直接继承IDAO接口即可，是不是很方便，直接继承即可，如果你需要扩充什么方法的话，直接编写方法即可，

package cn.oracle.dao;

import cn.oracle.pojo.Emp;

 

public interface IEmpDAO extends IDAO<Integer, Emp> {

}

·然后当然是编写接口的实现类了，也就是编写方法的具体实现，

EmpDAOImpl.java

package cn.oracle.dao.impl;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.SessionFactory;

import org.springframework.stereotype.Component;

import cn.oracle.dao.IEmpDAO;

import cn.oracle.pojo.Emp;

@Componentè这个就是Annotation注解，其实你可以理解为在applicationContext.xml文件之中配置了一个bean

<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>èComponent

    <property name=”sessionFactory” ref=”sessionFactory”/>èResource

</bean>

public class EmpDAOImpl implements IEmpDAO {

@Resource

private SessionFactory sessionFactory;

@Override

public boolean doCreate(Emp vo) throws Exception {

return this.sessionFactory.getCurrentSession().save(vo) != null;

}è使用Session接口的save方法来保存数据；

 

@Override

public boolean doUpdate(Emp vo) throws Exception {

String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";

Query query=this.sessionFactory.getCurrentSession().createQuery(hql);

query.setString(0, vo.getEname());

query.setDate(1, vo.getHiredate());

query.setString(2, vo.getSal());

return query.executeUpdate()>0;

}è使用Query实现更新；

 

@Override

public boolean doRemove(int id) throws Exception {

String hql="DELETE FROM Emp As e WHERE e.empno=?";

Query query=this.sessionFactory.getCurrentSession().createQuery(hql);

query.setInteger(0, id);

return query.executeUpdate()>0;

}è使用Query接口实现删除；

@Override

public Emp findById(int id) throws Exception {

return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);

}è使用Session接口查询数据；

@SuppressWarnings("unchecked")

@Override

public List<Emp> findAll() throws Exception {

Criteria criteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);

List<Emp> all=criteria.list();

return all;

}  è使用criteria接口实现全部查询；

 

@SuppressWarnings("unchecked")

@Override

public List<Emp> findAll(String column, String keyWord,

Integer currentPage, Integer lineSize) throws Exception {

String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";

Query query=this.sessionFactory.getCurrentSession().createQuery(hql);

query.setString(0, "%"+keyWord+"%");

query.setFirstResult((currentPage-1)*lineSize);

query.setMaxResults(lineSize);

return (List<Emp>)query.list();

}è使用query接口实现分页模糊查询；

@Override

public int getAllCount(String column, String keyWord) throws Exception {

String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";

Query query=this.sessionFactory.getCurrentSession().createQuery(hql);

query.setString(0, "%"+keyWord+"%");

Integer count=((Long)query.uniqueResult()).intValue();

return count;

}  è使用query接口完成统计；

}

 

·编写完成DAO层之后，我们就要做的就是编写服务层了，也就是对DAO层接口的调用，

IEmpService.java

package cn.oracle.service;

import java.util.List;

import java.util.Map;

import cn.oracle.pojo.Emp;

 

public interface IEmpService {

public boolean insert(Emp vo)throws Exception;

public boolean update(Emp vo)throws Exception;

public boolean delete(int id)throws Exception;

public Emp get(int id)throws Exception;

public List<Emp> list()throws Exception;

public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;

}

·接口编写完成，之后我们就应该编写实现类了；

EmpServiceImpl.java

package cn.oracle.service.impl;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import cn.oracle.dao.IEmpDAO;

import cn.oracle.pojo.Emp;

import cn.oracle.service.IEmpService;

@ServiceèService层的专用Annotation注解；

public class EmpServiceImpl implements IEmpService {

@Resource

private IEmpDAO empDAO;

@Override

public boolean insert(Emp vo) throws Exception {

return this.empDAO.doCreate(vo);

}

 

@Override

public boolean update(Emp vo) throws Exception {

return this.empDAO.doUpdate(vo);

}

 

@Override

public boolean delete(int id) throws Exception {

return this.empDAO.doRemove(id);

}

 

@Override

public Emp get(int id) throws Exception {

return this.empDAO.findById(id);

}

 

@Override

public List<Emp> list() throws Exception {

return this.empDAO.findAll();

}

 

@Override

public Map<String, Object> list(String column, String keyWord,

Integer currentPage, Integer lineSize) throws Exception {

Map<String ,Object> map=new HashMap<String,Object>();

map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));

map.put("allCount", this.empDAO.getAllCount(column, keyWord));

return map;

}

 

}

 

·到此，后台业务层的增删改查就完成了，然后就是控制器的编写了，我们用的是springmvc的话，自然编写起来很方便的；

EmpAction.java

package cn.oracle.action;

import java.util.List;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.servlet.ModelAndView;

import cn.oracle.pojo.Emp;

import cn.oracle.service.IEmpService;

@Controllerèspring mvc的专用annotation注解，代表一个控制器；

@RequestMapping("/pages/front/emp/*")  è映射路径

public class EmpAction {

@Resource

private IEmpService empService;

@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)

public ModelAndView list(HttpServletRequest request,HttpServletResponse response){

List<Emp> allEmps=null;

try {

allEmps=this.empService.list();

} catch (Exception e) {

e.printStackTrace();

}

ModelAndView mav=new ModelAndView();

mav.setViewName("/pages/front/emp/emp_list.jsp");

mav.addObject("allEmps", allEmps);

System.out.println(allEmps);  è我们就用一个简单的连接做测试，如果后台输出了这些对象的话，说明我们就完成了页面的操作了；

return mav;

}

}

 

 

 

如果后台有输出这些信息，说明你的所有配置正常，开发CRUD没任何问题的；