基于持久层框架hibernate用SpringMVC增删功能

最新推荐文章于 2023-07-13 08:13:54 发布
最新推荐文章于 2023-07-13 08:13:54 发布
阅读量356 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： SSM框架 互联网@IT 文章标签： hibernate SpringMVC java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30225725/article/details/86684157
本文介绍了如何在SpringMVC框架下结合Hibernate持久层框架实现数据库的增删功能。首先讲解了Hibernate作为全自动化的ORM框架，以及其与mybatis的比较。接着，详细阐述了配置数据库连接、编写实体类、 Dao层接口以及配置SpringMVC的步骤，强调了JPA的使用，特别是通过继承JpaRepository接口实现无需编写实现类即可完成基本的CRUD操作。文章还涉及了JPA的优势，如标准化、简单方便、强大的查询能力以及高级特性，并提及了JPA的供应商，如Hibernate、Spring和OpenJPA。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

接Spring MVC框架（1）的方法

Hibernate:持久层全自动化的框架
hibernate 用的少了 因为现在mybatis用的多
接下来 hibernate框架要链接数据库blog

/*
Navicat MySQL Data Transfer

Source Server         : springdemo
Source Server Version : 50713
Source Host           : localhost:3306
Source Database       : blog

Target Server Type    : MYSQL
Target Server Version : 50713
File Encoding         : 65001

Date: 2019-01-02 10:40:09
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for blog
-- ----------------------------
DROP TABLE IF EXISTS `blog`;
CREATE TABLE `blog` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(100) NOT NULL,
  `content` varchar(255) DEFAULT NULL,
  `user_id` int(11) NOT NULL,
  `pub_date` date NOT NULL,
  PRIMARY KEY (`id`),
  KEY `user_id_idx` (`user_id`),
  CONSTRAINT `FKpxk2jtysqn41oop7lvxcp6dqq` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`),
  CONSTRAINT `user_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4;

-- ----------------------------
-- Records of blog
-- ----------------------------
INSERT INTO `blog` VALUES ('1', 'SpringMVC', '这是SpringMVC的真的很简单。TEST TEST TEST', '2', '2015-03-18');
INSERT INTO `blog` VALUES ('5', 'zjjlive', 'asdf', '2', '2017-08-13');

数据库user

/*
Navicat MySQL Data Transfer

Source Server         : springdemo
Source Server Version : 50713
Source Host           : localhost:3306
Source Database       : blog

Target Server Type    : MYSQL
Target Server Version : 50713
File Encoding         : 65001

Date: 2019-01-02 10:40:19
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nickname` varchar(45) NOT NULL,
  `password` varchar(45) NOT NULL,
  `first_name` varchar(45) DEFAULT NULL,
  `last_name` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'Steve1234', 'gaussic2', 'Steve', 'NoJob');
INSERT INTO `user` VALUES ('2', 'Bill', '111111', 'Bill', 'Gates');
INSERT INTO `user` VALUES ('3', 'Mark', '22222', 'Mark', 'Zuckerberg');
INSERT INTO `user` VALUES ('4', 'gauss', '11111111', 'Gaussic', 'D');
INSERT INTO `user` VALUES ('6', '全民编程123', '111111', 'asdf123', 'fff123');
INSERT INTO `user` VALUES ('7', 'zjjlive_test', '123456', 'zjj123', 'live');

2.然后写bean
BlogEntity.java

package com.foreknow.model;



import javax.persistence.*;
import java.sql.Date;

@Entity
@Table(name = "blog", schema = "blog", catalog = "")
public class BlogEntity {
    private int id;
    private String title;
    private String content;
    private Date pubDate;
    private UserEntity userByUserId;

    @Id
    @Column(name = "id", nullable = false)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Basic
    @Column(name = "title", nullable = false, length = 100)
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Basic
    @Column(name = "content", nullable = true, length = 255)
    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Basic
    @Column(name = "pub_date", nullable = false)
    public Date getPubDate() {
        return pubDate;
    }

    public void setPubDate(Date pubDate) {
        this.pubDate = pubDate;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        BlogEntity that = (BlogEntity) o;

        if (id != that.id) return false;
        if (title != null ? !title.equals(that.title) : that.title != null) return false;
        if (content != null ? !content.equals(that.content) : that.content != null) return false;
        if (pubDate != null ? !pubDate.equals(that.pubDate) : that.pubDate != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (title != null ? title.hashCode() : 0);
        result = 31 * result + (content != null ? content.hashCode() : 0);
        result = 31 * result + (pubDate != null ? pubDate.hashCode() : 0);
        return result;
    }

    @ManyToOne
    @JoinColumn(name = "user_id", referencedColumnName = "id", nullable = false)
    public UserEntity getUserByUserId() {
        return userByUserId;
    }

    public void setUserByUserId(UserEntity userByUserId) {
        this.userByUserId = userByUserId;
    }
}

UserEntity.java

package com.foreknow.model;




import javax.persistence.*;
import java.util.Collection;

@Entity
@Table(name = "user", schema = "blog", catalog = "")
public class UserEntity {
    private int id;
    private String nickname;
    private String password;
    private String firstName;
    private String lastName;
    private Collection<BlogEntity> blogsById;

    @Id
    @Column(name = "id", nullable = false)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Basic
    @Column(name = "nickname", nullable = false, length = 45)
    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    @Basic
    @Column(name = "password", nullable = false, length = 45)
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Basic
    @Column(name = "first_name", nullable = true, length = 45)
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    @Basic
    @Column(name = "last_name", nullable = true, length = 45)
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        UserEntity that = (UserEntity) o;

        if (id != that.id) return false;
        if (nickname != null ? !nickname.equals(that.nickname) : that.nickname != null) return false;
        if (password != null ? !password.equals(that.password) : that.password != null) return false;
        if (firstName != null ? !firstName.equals(that.firstName) : that.firstName != null) return false;
        if (lastName != null ? !lastName.equals(that.lastName) : that.lastName != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (nickname != null ? nickname.hashCode() : 0);
        result = 31 * result + (password != null ? password.hashCode() : 0);
        result = 31 * result + (firstName != null ? firstName.hashCode() : 0);
        result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
        return result;
    }

    @OneToMany(mappedBy = "userByUserId")
    public Collection<BlogEntity> getBlogsById() {
        return blogsById;
    }

    public void setBlogsById(Collection<BlogEntity> blogsById) {
        this.blogsById = blogsById;
    }
}

导入之后的话 报错是因为没有hibernate 的库 需要导入库 pom.xml

<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>com.neusoft.maven_springmvchibernate</groupId>
  <artifactId>springmvc_hibernate</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
	<properties>
		<spring.version>4.2.6.RELEASE</spring.version>
		<hibernate.version>5.1.0.Final</hibernate.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>1.10.1.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-c3p0</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5.2</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.39</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
</project>

然后 写Dao层
1.BlogRepository.java

package com.foreknow.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.foreknow.model.BlogEntity;
@Repository
public interface BlogRepository extends JpaRepository<BlogEntity, Integer> {
	 
}

2.bean UserRepository.java

package com.foreknow.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.foreknow.model.UserEntity;
@Repository
public interface UserRepository extends JpaRepository<UserEntity, Integer> {
	 @Modifying      // 说明该方法是修改操作
	 @Transactional  // 说明该方法是事务性操作
	    //Hibernate是完全面向对象来操作数据库的
	    //所有的操作都是面向POJO来编程的
	    //:qNickname占位符
	    //定义查询
	    //@Param注解用于提取参数
	    //HQL ：Hibernate中的查询方式
	    @Query("update UserEntity us " +
	            "set us.nickname=:qNickname, us.firstName=:qFirstName, " +
	            "us.lastName=:qLastName, us.password=:qPassword where us.id=:qId")
	    public void updateUser
	            (@Param("qNickname") String nickname, @Param("qFirstName") String firstName,
	             @Param("qLastName") String qLastName, @Param("qPassword") String password, @Param("qId") Integer id);

}

配置spring-mvc-config.xml 加关联数据库的头 和bean

<?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"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--自动扫描  这个包下的所有-->
	<context:component-scan base-package="com.foreknow.controller"/>
	<!--指定静态的资源(视图解析器)  -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
		<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
		<property name="prefix" value="/WEB-INF/jsp/"></property>
			<!--视图解析器的后缀 返回的.jsp的格式  -->
		<property name="suffix" value=".jsp"></property>
	</bean>
	
	<!-- 开启注解映射的支持 -->
	<mvc:annotation-driven/>
	
	 <!-- 表示JPA dao所在的包 -->
    <jpa:repositories base-package="com.foreknow.repository"/>

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="defaultPersistenceUnit"/>
        <property name="packagesToScan" value="com.foreknow.model" />
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
        </property>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
<!--                 需要修改数据库名 -->
                <prop key="hibernate.connection.url">jdbc:mysql://localhost:3306/blog?useSSL=false</prop>
                <prop key="hibernate.connection.username">root</prop>
                <prop key="hibernate.connection.password">root</prop>
             <!--    打印SQL语音 在控制器 -->
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.connection.useUnicode">true</prop>
                <prop key="hibernate.connection.characterEncoding">UTF-8</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.use_sql_comments">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.connection.autoReconnect">true</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="connection.autoReconnectForPools">true</prop>
                <prop key="connection.is-connection-validation-required">true</prop>

                <prop key="hibernate.c3p0.validate">true</prop>
                <prop key="hibernate.connection.provider_class">org.hibernate.service.jdbc.connections.internal.C3P0ConnectionProvider</prop>
                <prop key="hibernate.c3p0.min_size">5</prop>
                <prop key="hibernate.c3p0.max_size">600</prop>
                <prop key="hibernate.c3p0.timeout">1800</prop>
                <prop key="hibernate.c3p0.max_statements">50</prop>
                <prop key="hibernate.c3p0.preferredTestQuery">SELECT 1;</prop>
                <prop key="hibernate.c3p0.testConnectionOnCheckout">true</prop>
                <prop key="hibernate.c3p0.idle_test_period">3000</prop>
            </props>
        </property>
    </bean>

    <!-- 事务管理 JpaTransactionManager开启注解管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
</beans>

其中 注解@Repository
直接继承于 JpaRepository<UserEntity, Integer> 的接口 指向JAVA bean的一张表 ，第二个参数是类型
实现类不用写 只要是继承 然后 你就不用写增删改查的方法 直接在接口用调用简单的SQL就可以
如果要是复杂的SQL 就要用到 HQL语音 编写SQL 没有mybatis中对于SQL语言原生的方便
所以现在公司用的mybatis多

####基于JPA
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 [1]

Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。

起源

JPA由EJB 3.0软件专家组开发，作为JSR-220实现的一部分。但它又不限于EJB 3.0，你可以在Web应用、甚至桌面应用中使用。JPA的宗旨是为POJO提供持久化标准规范，由此可见，经过这几年的实践探索，能够脱离容器独立运行，方便开发和测试的理念已经深入人心了。Hibernate3.2+、TopLink 10.1.3以及OpenJPA都提供了JPA的实现。

JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：

ORM映射元数据

JPA支持XML和JDK5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；

API

用来操作实体对象，执行CRUD操作，框架在后台替代我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。

查询语言

这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

优势

标准化

JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

容器级特性的支持

JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。

简单方便

JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易地掌握。JPA基于非侵入式原则设计，因此可以很容易地和其它框架或者容器集成。

查询能力

JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

高级特性

JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。

供应商

JPA 的目标之一是制定一个可以由很多供应商实现的API，并且开发人员可以编码来实现该API，而不是使用私有供应商特有的API。因此开发人员只需使用供应商特有的API来获得JPA规范没有解决但应用程序中需要的功能。尽可能地使用JPA API，但是当需要供应商公开但是规范中没有提供的功能时，则使用供应商特有的API。

Hibernate

JPA是需要Provider来实现其功能的，Hibernate就是JPA Provider中很强的一个，应该说无人能出其右。从功能上来说，JPA就是Hibernate功能的一个子集。Hibernate 从3.2开始，就开始兼容JPA。Hibernate3.2获得了Sun TCK的JPA(Java Persistence API) 兼容认证。

只要熟悉Hibernate或者其他ORM框架，在使用JPA时会发现其实非常容易上手。例如实体对象的状态，在Hibernate有自由、持久、游离三种，JPA里有new，managed，detached，removed，明眼人一看就知道，这些状态都是一一对应的。再如flush方法，都是对应的，而其他的再如说Query query = manager.createQuery(sql)，它在Hibernate里写法上是session，而在JPA中变成了manager，所以从Hibernate到JPA的代价应该是非常小的

同样，JDO，也开始兼容JPA。在ORM的领域中，看来JPA已经是王道，规范就是规范。在各大厂商的支持下，JPA的使用开始变得广泛。

Spring

Spring + Hibernate 常常被称为 Java Web 应用人气最旺的框架组合。而在 JCP 通过的 Web Beans JSR ，却欲将JSF + EJB + JPA 、来自 JBoss Seam（Spring 除外）的一些组件和EJB 3（能够提供有基本拦截和依赖注入功能的简化 Session Bean框架）的一个 Web 组合进行标准化。Spring 2.0 为 JPA 提供了完整的 EJB容器契约，允许 JPA在任何环境内可以在 Spring 管理的服务层使用（包括 Spring 的所有DI 和 AOP增强）。同时，关于下一个Web应用组合会是 EJB、Spring + Hibernate 还是 Spring + JPA 的论战，早已充斥于耳。

在Spring 2.0.1中，正式提供对JPA的支持，这也促成了JPA的发展，要知道JPA的好处在于可以分离于容器运行，变得更加的简洁。

OpenJPA

OpenJPA 是 Apache 组织提供的开源项目，它实现了 EJB 3.0 中的 JPA 标准，为开发者提供功能强大、使用简单的持久化数据管理框架。OpenJPA 封装了和关系型数据库交互的操作，让开发者把注意力集中在编写业务逻辑上。OpenJPA 可以作为独立的持久层框架发挥作用，也可以轻松的与其它 Java EE 应用框架或者符合 EJB 3.0 标准的容器集成。

支持的实现包括Toplink、Hibernate Entitymanager等。TopLink以前需要收费，如今开源了。OpenJPA虽然免费，但功能、性能、普及性等方面更加需要加大力度。

对于EJB来说，实体Bean一直是被批评的对象，由于其太复杂和庞大。JPA的出现，很大程度的分离了复杂性。这让EJB的推广也变得容易。

总而言之，JPA规范主要关注的仅是API的行为方面，而由各种实现完成大多数性能有关的调优。尽管如此，所有可靠的实现都应该拥有某种数据缓存，以作为选择。但愿不久的将来，JPA能成为真正的标准。

小结

EJB 3.0和JPA 毫无疑问将是Java EE 5的主要卖点。在某些领域中，它们给Java社区带来了竞争优势，并使Java 在其他领域与竞争对手不分伯仲（因为，不可否认，某些领域尚不存在基于标准的方法）。

过去数年来，Spring Framework一直是EJB在企业领域的主要竞争对手。EJB 3.0规范解决了很多促进Spring兴起的问题。随着它的出现，EJB3.0毫无疑问比Spring提供了更好的开发体验——最引人注目的优势是它不需要配置文件。

JPA提供一种标准的OR映射解决方案，该解决方案完全集成到EJB3.0兼容的容器中。JPA的前辈将会继续稳定发展，但是业务应用程序中的 raw 使用将可能会减少。实现 JPA 兼容的实体管理器似乎很可能是此类技术的发展方向。

Java EE系列规范的较大问题与JPA没有任何关系。Java EE 系列规范的问题涉及到 Web和EJB容器之间的集成。Spring在此领域仍然具有主要竞争优势。JBoss的Seam项目尝试使用自定义的方法来解决这一问题。Caucho Resin应用服务器试图扩展容器边界并支持在Web容器中使用@EJB注释。我们希望Java EE 5.1将解决层集成的问题，为我们提供一个全面而标准的依赖性注入方法。

在不久的将来，Oracle可能会将JPA作为一个单独的JSR对待，同时JPA还可能作为Java SE的一部分。不过这些都不太重要，重要的是，我们已经可以在脱离容器的情况下、在Java SE应用中使用JPA了。

JPA已经作为一项对象持久化的标准，不但可以获得Java EE应用服务器的支持，还可以直接在Java SE中使用。开发者将无需在现有多种ORM框架中艰难地选择，按照Sun的预想，现有ORM框架头顶的光环将渐渐暗淡，不再具有以往的吸引力。

##注意
1.bean 和 数据库中的表 的属性名 必须一样
2.jsp中表单的name 必须得跟bean一样 id可以不一样

##例子2

创建一个users.jsp

<%--
  Created by IntelliJ IDEA.
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>SpringMVC 用户管理</title>

    <!-- 新 Bootstrap 核心 CSS 文件 -->
    <link rel="stylesheet" href="//cdn.bootcss.com/bootstrap/3.3.5/css/bootstrap.min.css">

    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="//cdn.bootcss.com/html5shiv/3.7.2/html5shiv.min.js"></script>
    <script src="//cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
</head>
<body>
<div class="container">
    <h1>SpringMVC用户管理</h1>
    <hr/>

    <h3>所有用户 <a href="/foreknow_springmvc/admin/users/add" type="button" class="btn btn-primary btn-sm">添加</a></h3>

   <!--如果用户列表为空  -->
   <c:if test="${empty userList}">
	    <div class="alert alert-warning" role="alert">
	        <span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span>User表为空，请<a href="/admin/users/add" type="button" class="btn btn-primary btn-sm">添加</a>
	    </div>
    </c:if>

	<!--如果用户列表不为空  -->
 	<c:if test="${!empty userList}">
    <table class="table table-bordered table-striped">
        <tr>
            <th>ID</th>
            <th>昵称</th>
            <th>姓名</th>
            <th>密码</th>
            <th>操作</th>
        </tr>
            <c:forEach items="${userList}" var="user">
            <tr>
                <td>${user.id}</td>
                <td>${user.nickname}</td>
                <td>${user.firstName} ${user.lastName}</td>
                <td>${user.password}</td>
                <td>
                    <a href="#" type="button" class="btn btn-sm btn-success">详情</a>
                    <a href="#" type="button" class="btn btn-sm btn-warning">修改</a>
                    <a href="/foreknow_springmvc/admin/users/delete/${user.id}" type="button" class="btn btn-sm btn-danger">删除</a>
                </td>
            </tr>
        </c:forEach>
    </table>
    </c:if>
</div>

<!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
<script src="//cdn.bootcss.com/jquery/1.11.3/jquery.min.js"></script>

<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
<script src="//cdn.bootcss.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
</body>
</html>

创建一个MainController.java

package com.foreknow.controller;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.foreknow.model.UserEntity;
import com.foreknow.repository.UserRepository;

@Controller
public class MainController {
	@Autowired
	private UserRepository UserRepository;
	
	@RequestMapping(value="/",method=RequestMethod.GET)
	public String index() {
		return "index";
	}
	
	//查询所有用户信息
	@RequestMapping(value="/admin/users",method=RequestMethod.GET)
	public String getUsers(ModelMap modelMap) {
		List<UserEntity> userList = UserRepository.findAll();
		modelMap.addAttribute("userList", userList);
		return "admin/users";
	}
	
	@RequestMapping(value="/admin/users/add",method=RequestMethod.GET)
	public String addUser() {
		return "admin/addUser";
	}
	
	@RequestMapping(value="/admin/users/addP",method=RequestMethod.POST)
	public String addUserPost(@ModelAttribute("user") UserEntity userEntity) {
		//Post请求传递过来的是一个UserEntity对象，该 对象中包含了用户的信息
		//可以通过@ModelAttribute("user")获取从页面传递过来的用户的信息并创建这个对象（自动给对象的属性赋值）
		//向数据库添加一个用户的信息并刷新
		UserRepository.saveAndFlush(userEntity);
		return "redirect:/admin/users";
	}
	
	@RequestMapping(value="/admin/users/delete/{id}",method=RequestMethod.GET)
	public String deleteUser(@PathVariable("id") Integer userId) {
		UserRepository.delete(userId);
		return "redirect:/admin/users";
	}
	
	
	
}

显示结果
image.png

在创建一个添加的页面addUser.jsp


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>SpringMVC 添加用户</title>

    <!-- 新 Bootstrap 核心 CSS 文件 -->
    <link rel="stylesheet" href="//cdn.bootcss.com/bootstrap/3.3.5/css/bootstrap.min.css">

    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="//cdn.bootcss.com/html5shiv/3.7.2/html5shiv.min.js"></script>
    <script src="//cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
</head>
<body>
<div class="container">
    <h1>SpringMVC 添加用户</h1>
    <hr/>
    <form:form action="/foreknow_springmvc/admin/users/addP" method="post" commandName="user">
        <div class="form-group">
            <label for="firstName">Nickname:</label>
            <input type="text" class="form-control" id="nickname" name="nickname" placeholder="Enter Nickname:"/>
        </div>
        <div class="form-group">
            <label for="firstName">First Name:</label>
            <input type="text" class="form-control" id="firstName" name="firstName" placeholder="Enter FirstName:"/>
        </div>
        <div class="form-group">
            <label for="lastName">Last Name:</label>
            <input type="text" class="form-control" id="lastName" name="lastName" placeholder="Enter LastName:"/>
        </div>
        <div class="form-group">
            <label for="password">Password:</label>
            <input type="text" class="form-control" id="password" name="password" placeholder="Enter Password:"/>
        </div>
        <div class="form-group">
            <button type="submit" class="btn btn-sm btn-success">提交</button>
        </div>
    </form:form>
</div>

<!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
<script src="//cdn.bootcss.com/jquery/1.11.3/jquery.min.js"></script>

<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
<script src="//cdn.bootcss.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
</body>
</html>

image.png

关联超链接的的添加按钮 要包名.映射地址 跟MainController.java 映射对应上

##问题

hibernate这个是怎么自动生成的？

基于Hibernate和SpringMVC框架的小型书店管理网站S
09-29
【标题】：基于Hibernate和SpringMVC框架的小型书店管理网站S 【描述】：小型书店管理网站是一个常见的Web应用程序示例，它利用了Hibernate和SpringMVC这两个强大的开源框架。Hibernate是Java领域中广泛使用的对象...
springmvc增删改查
09-13
- **Repository/DAO 层**：数据库操作接口或实现，使用 JPA、Hibernate 或 MyBatis 等持久层框架进行数据库插入操作。 3. **删（Delete）**： - **@DeleteMapping**：处理 HTTP DELETE 请求，删除指定的资源。 -...
JPA
maguanghui_2012的专栏
01-11 452
PA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。 JPA由EJB 3.0软件专家组开发，作为JSR-220实现的一部分。但它又不限于EJ
JPA入门教程【转】
weixin_34205826的博客
12-04 476
JPA(Java Persistence API，Java持久化API)一、什么是JPA对象关系映射ORM（Object-RelationMapping）是用来将对象和对象之间的关系对应到数据库中表与表之间的关系的一种模式。ORM框架能够将Java对象映射到关系数据库，能够直接持久化复杂的Java对象。ORM框架的出现，使开发者从数据库编程中解脱出来，把更多的精力放在了业务模...
JPA（Java Persistence API）Java持久化API-介绍
ilovejava_2010的专栏
08-23 1629
JPA全称： Java Persistence API JPA的宗旨是为POJO提供持久化标准规范，能够脱离容器独立运行，很方便开发和测试。 JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 出现的原因： 简化现有Java EE和Java SE应用的对象持久化的开发工作； Sun希望整合对ORM技术，实现持久化领域的统一。 JPA的
jpa（Java Persistence API）
weixin_30636089的博客
08-05 239
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象-关系表的映射关系，并将运行期的实体对象持久化到数据库中。 Sun引入新的JPA ORM规范出于两个原因:其一，简化现有Java EE和Java SE应用开发工作;其二，Sun希望整合ORM技术，实现天下归一。 起源 JPA由EJB 3.0软件专家组...
【JPA】整体了解JPA
张姐姐聊编程
01-28 488
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
基于Java语言的Spring、SpringMVC和Hibernate整合SSH框架设计源码
最新发布
10-03
Java作为一门广泛应用的编程语言，在企业级开发中尤为突出，其中以Spring、SpringMVC和Hibernate技术为核心的SSH框架，成为了Java Web开发的经典组合。Spring是一个全面的企业级应用开发框架，提供了事务管理、安全...
springmvc+spring+hibernate4+easyui实现的增删改查
01-19
这个项目利用了Spring MVC作为MVC框架，Spring作为服务层管理，Hibernate 4作为持久层框架，以及EasyUI作为前端用户界面组件库。以下是这些技术的具体说明： **Spring MVC**： Spring MVC是Spring框架的一部分，...
springmvc+hibernate 实现的增删改查
09-02
本项目“springmvc+hibernate 实现的增删改查”旨在演示如何整合这两个框架，以实现对MySQL数据库的基本数据操作。 SpringMVC框架提供了一个模型-视图-控制器（MVC）架构，用于组织和处理Web应用中的业务逻辑、数据...
SSH(struts2+hibernate+spring)增删改查实例
04-16
struts2+hibernate+spring集成的简单的增删改查实例，只有一个user表，数据库可根据自己情况oracle或者mysql都可
持久层框架--hibernate（1）
weixin_30741653的博客
04-01 112
持久层框架--hibernate（1） 一.Hibernate hibernate是基于ORM映射的数据持久层框架，封装了DAO层 hibernate框架搭建步骤： 　　1.引入jar包 11个 　　2.添加hibernate的配置文件hibernate.cfg.xml 　　3.建表 tab_customer表 id,nam...
一、持久层框架（Hibernate）
dengbangtui3521的博客
03-05 204
一、Hibernate 　　使用JDBC做数据库相关功能开发会做很多重复性的工作，创建连接，关闭连接，把字段逐一映射到属性中等。Hibernate把这些进行封装起来，使得数据库访问变得轻松简单。 1、创建数据库，数据表 --创建数据库 create database test; --使用数据库 use test; --创建数据表 CREATE TABLE produc...
四、持久层框架（Hibernate）
dengbangtui3521的博客
03-06 184
一、一级缓存与二级缓存 　　1、一级缓存：Hibernate默认是开启一级缓存的，一级缓存存放在session里，一个Session做一次查询操作，会把这个操作的结果放在一级缓存中，如果短时间内这个session （同一个session）又做了同一个操作，那么hibernate直接从一级缓存中拿，而不用再去连接数据库，取数据。 一级缓存生命周期依赖于Session生命周期，Sessi...
二、持久层框架（Hibernate）
dengbangtui3521的博客
03-06 141
一、Hibernate对象的状态 　　实体类对象在Hibernate中有3中状态：瞬时，持久，脱管。 瞬时：没有和Hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，对象就消失了 持久：一个对象和Hibernate发生联系，有对应的Session，并且在数据库中有对应的一条记录 脱管：一个对象虽然在数据库中有对应的一条记录，但是它所对应的Session已经...
Hibernate持久层框架详解
superkeeper的博客
07-05 4282
一、hibernate框架的前世今生 1、前世：2001年，Gavin King开始开发hibernate框架。两年之后，Gavin King带领他的team完成了hibernate框架的开发，谁也没有想到两年前对SQL一概不知的小伙子，居然会成为全世界J2EE数据库解决方案的领导者。 2、今生：Hibernate版本更新速度很快，目前为止有两个阶段性的版本：Hibernate2，Hibe
【JPA】Java Persistence API 2.0 FINAL 官方文档 PDF 下载
后端研发工程师Marion的博客
08-06 287
一、参考资料 JPA整合Querydsl入门篇JPA criteria 查询:类型安全与面向对象
数据持久层框架Hibernate使用方法
Michael的博客
07-13 954
Hibernate是一个开源的对象关系映射（ORM）框架，它对JDBC进行了轻量级的对象封装
重量级ORM框架--持久化框架Hibernate【关系映射详解】
mmklo的博客
08-09 415
官方教程】：h目前hibernate已经更新到了6的版本，这里使用的5的版本5.2官方推荐使用JDK1.8以及JDBC4。
掌握SpringMVC与Hibernate的增删改查操作
增删改查（Create-Read-Update-Delete，CRUD）是最基本的数据库操作，下面将详细介绍如何在Spring MVC和Hibernate框架的配合下实现这些操作。 ### Spring MVC基础 Spring MVC是一个基于Java的实现了MVC设计模式的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值