`

Spring+SpringMVC+Hibernate整合(封装CRUD操作)

SpringSpringMVCHibernate框架整合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&amp;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

  • 大小: 27 KB
分享到：
| Memcached之java客户端开发
评论
发表评论

文章已被作者锁定，不允许评论。

相关推荐

    spring4+springmvc4+hibernate4 整合DEMO

    在"spring4+springmvc4+hibernate4 整合DEMO"中，我们通常会经历以下步骤： 1. **配置环境**：设置项目的pom.xml文件，引入这三个框架的依赖库，确保项目构建成功。 2. **初始化Spring**：创建Spring的配置文件...

    spring+springmvc+hibernate

    Spring、Spring MVC 和 Hibernate 的整合，通常被称为 SSH（Spring、SpringMVC、Hibernate）集成框架，是Java EE开发中的常见选择。这种整合使得开发者可以在同一项目中充分利用三个框架的优点，实现松散耦合的架构...

    利用IDEA搭建的hibernate+Spring+SpringMVC架构实现增删改查等功能

    本文将详细介绍如何利用IntelliJ IDEA（IDEA）搭建一个基于Hibernate、Spring和SpringMVC的架构，实现基本的增删改查（CRUD）功能。 首先，Hibernate是Java领域的一个对象关系映射（ORM）框架，它允许我们将数据库...

    spring+springMVC+hibernate集成

    Spring、SpringMVC和Hibernate是Java开发中三大核心框架，它们的集成是企业级Web应用开发的常见模式，被广泛用于构建复杂、可扩展的后端系统。SSH（Spring、SpringMVC、Hibernate）集成提供了从数据持久化到业务逻辑...

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

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

    新SSH（spring、spring mvc、hibernate）框架结构的java web案例实践

    5. **DAO层**：创建DAO接口和实现类，利用Hibernate提供的Session接口进行CRUD操作。 6. **Service层**：封装业务逻辑，通过DI注入DAO，实现业务功能。 7. **Controller层**：定义Spring MVC的控制器，处理HTTP请求...

    SSH（spring+springmvc+hibernate+mysql）入门实例

    SSH，即Spring、SpringMVC和Hibernate的组合，是Java Web开发中常见的一种技术栈，尤其适用于构建企业级应用。这个入门实例将带你逐步了解如何整合这三个框架，并使用MySQL作为数据库，实现一个全注解驱动的项目，...

    SpringMVC+hibernate+spring实现增删改查

    在实际项目中，kaoshi1可能包含了一系列的配置文件（如applicationContext.xml、hibernate.cfg.xml）、实体类（Entity）、DAO接口及实现、...文件共同构成了一个完整的SpringMVC+Hibernate+Spring的CRUD示例...

    2017最新SSH整合案例（注意：本案例使用框架是Spring+Springmvc+Hibernate）

    SSH整合是Java开发中一种常见的Web应用程序架构模式，它由三个强大的开源框架组合而成：Spring、SpringMVC和Hibernate。这个2017年的最新SSH整合案例提供了如何将这三个框架协同工作的实例，适用于构建复杂、可扩展...

    SpringBoot/SpringMVC/Hibernate整合源码（不用Maven也行）

    **SpringBoot/SpringMVC/Hibernate整合源码详解** 在Java Web开发中，Spring Boot、Spring MVC和Hibernate是三个非常重要的框架。Spring Boot简化了Spring应用程序的初始设置和配置，Spring MVC提供了处理HTTP请求...

    springmvc+springjpa+hibernate整合简例

    总结来说，"springmvc+springjpa+hibernate整合简例"涉及到的主要知识点包括： 1. SpringMVC的请求处理流程和配置。 2. SpringJPA的使用，包括实体和数据访问接口的定义。 3. Hibernate作为JPA提供者的配置和特性...

    SpringMVC4+Hibernate4 整合 带增删改查 和 文件的上传和下载

    在SpringMVC4和Hibernate4的整合项目中，我们可以创建一个Service层，该层封装了对DAO的操作，然后在Controller层中调用这些Service方法，实现对数据的CRUD操作。例如，对于“增加”操作，Controller接收前端提交的...

    easyui+springMVC+hibernate练习

    本项目名为“easyui+springMVC+hibernate练习”，旨在通过整合这三大技术，实现一个实用的课程表功能。下面将详细阐述这三个技术及其在项目中的作用。 1. EasyUI： EasyUI是一款基于jQuery的前端框架，它提供了丰富...

    Springmvc+hibernate整合Demo

    在这个“Springmvc+hibernate整合Demo”中，我们将会探讨如何将这两个框架结合在一起，以创建一个功能丰富的客户关系管理（CRM）系统。 **Spring MVC 框架** Spring MVC 是 Spring 框架的一部分，提供了一个用于...

    基于注解的springMVC+hibernate+oracle包含数据库查询

    在实际开发中，我们还需要编写DAO（Data Access Object）层，该层负责与数据库的交互，通常结合Hibernate的`Session`和`Transaction`进行CRUD（创建、读取、更新、删除）操作。例如，使用`@Transactional`注解标记...

    jqueryeasyui+springmvc+hibernate

    在本项目中，Hibernate 可能被用来连接到数据库，执行 CRUD（创建、读取、更新、删除）操作，以及处理数据实体与数据库表之间的映射。 结合这三个框架，我们可以创建一个高度集成的Web应用。Spring MVC 处理HTTP...

    springMvc+hibernate Demo

    4. **Model 类**：Hibernate 实体类通常也是 Spring MVC 中的 Model 对象，通过 Hibernate 的 CRUD 操作更新数据库，然后由 Controller 将数据传递给 View。 在 "Demo" 文件中，开发者可能已经创建了一个简单的示例...

    springMVC+spring+hibernate登录注册demo

    然后，使用Hibernate的Session接口，可以执行CRUD操作（创建、读取、更新和删除）。 在这个demo中，没有前端页面，意味着所有的交互可能都是通过RESTful API进行的。开发者可能定义了Controller方法，这些方法接收...

    基于Maven+SpringMVC+Hibernate在线考试系统设计源码案例设计.zip

    总的来说，这个在线考试系统通过整合Maven、SpringMVC和Hibernate，实现了模块化、组件化的开发模式，降低了系统复杂性，提高了代码的可维护性和可扩展性。开发者可以快速构建出功能完善的在线考试平台，包括用户...

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