SpringMVC+SpringDataJPA+Hibernate

最新推荐文章于 2021-10-06 19:30:27 发布
最新推荐文章于 2021-10-06 19:30:27 发布
阅读量446 收藏 2
点赞数

手把手教你从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate(含源码下载)

标签： SpringDataJPA SpringMVC Hibernate JPA
2016年05月15日 02:54:55 31825人阅读 评论(21) 收藏 举报
分类：
编程语言—————Java———（43）

版权声明：http://blog.csdn.net/anxpp https://blog.csdn.net/anxpp/article/details/51415366

目录(?)[+]

转载请注明出处：http://blog.csdn.net/anxpp/article/details/51415366，谢谢！

    本文会介绍从一个最基本的java工程，到Web工程，到集成Spring、SpringMVC、SpringDataJPA+Hibernate。

    平时我们可能是通过一个模板搭建一个工程，或者是直接导入一个项目，而本文选择从最基本的java工程开始，目的是为了展示更多原理。

    当然，我们还是从一个最基本的Maven工程开始，其实普通的非Maven工程，搭建过程几乎是一模一样的，只是Jar包需要我们手动的添加到工程中，而Maven工程就只是修改配置文件即可。推荐几篇相关文章：

  1.     Maven介绍及安装和在eclipse中的配置
  2.     Eclipse中使用Maven创建基本的web项目
  3.     Eclipse搭建Maven工程集成Spring4MVC
  4.     Eclipse搭建Maven工程集成Spring4+MVC+Hibernate5
  5.     JPA规范介绍及实例(Java数据持久化解决方案)

    对 Spring Data JPA 更详细的介绍，请戳->Spring ORM+Hibernate？Out！换 Spring Data JPA 吧！

    下面就正式开始。

1、基于Maven（如果不使用Maven也可以用传统的工程）创建最基本的Java工程

    新建工程，选择Maven Project，Next：

    001

    勾选为简单的工程（Create a simple project），Next：

    002

    Group id为你的域名反序，通常跟工程源码的包名对应，Artifact id为这个Group id中工程的唯一名，根据你的爱好，怎么填都行，然后Finish：

    003

    这是得到的工程目录结构是这样的：

    004

    pom.xml就是Maven的核心文件。

2、将工程设置为动态网页模式

    接下来就将工程转换为Web工程，右键打开工程属性，如图，点击左边菜单中的Project Facets，然后点击Convert to faceted from...：

    005

    在右边，我们勾选Dynamic Web Module（动态网页），然后点OK：

    006

    这时会多出一个WebContent目录：

    007

    在WEB-INF目录下，添加web.xml文件，内如如下：

 
  
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.  xmlns="http://java.sun.com/xml/ns/javaee"
  4.  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.  version="3.0">
  6.  <display-name>SpringDataJPA</display-name>
  7.  <welcome-file-list>
  8.  <welcome-file>index.html</welcome-file>
  9.  </welcome-file-list>
  10. </web-app>
 
  
    然后添加一个欢迎页index.html：
 
  
 
  
  1. <html>
  2. <head>
  3. </head>
  4. <body>
  5. <h1>Hello Word!</h1>
  6. </body>
  7. </html>
 
  
    这时目录结构如下：
 
  
    008
 
  
    这时，就可以右键工程，Run On Server了，可以看下效果：
 
  
    10
 
  
3、集成Spring+SpringMVC
 
  
    新建包，并添加一些接口和类（具体代码后面会列出来），包结构如图：
 
  
    11
 
  
    需要添加jar包，直接修改pom文件即可，如果为普通工程，按pom.xml中的jar包，添加到工程中即可。
 
  
    首先添加使用的spring版本，方便统一管理，然后再添加所有需要的jar包，下面把此处需要的所有jar包添加进来，完成后的pom.xml如下：
 
  
 
  
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.  <modelVersion>4.0.0</modelVersion>
  4.  <groupId>com.anxpp</groupId>
  5.  <artifactId>SpringDataJPA</artifactId>
  6.  <version>0.0.1-SNAPSHOT</version>
  7.  <properties>
  8.  <!-- spring版本号 -->
  9.  <spring.version>4.2.5.RELEASE</spring.version>
  10.  </properties>
  11.  <dependencies>
  12.  <!-- spring核心包 -->
  13.  <dependency>
  14.  <groupId>org.springframework</groupId>
  15.  <artifactId>spring-core</artifactId>
  16.  <version>${spring.version}</version>
  17.  </dependency>
  18.  <dependency>
  19.  <groupId>org.springframework</groupId>
  20.  <artifactId>spring-web</artifactId>
  21.  <version>${spring.version}</version>
  22.  </dependency>
  23.  <dependency>
  24.  <groupId>org.springframework</groupId>
  25.  <artifactId>spring-orm</artifactId>
  26.  <version>${spring.version}</version>
  27.  </dependency>
  28.  <dependency>
  29.  <groupId>org.springframework</groupId>
  30.  <artifactId>spring-tx</artifactId>
  31.  <version>${spring.version}</version>
  32.  </dependency>
  33.  <dependency>
  34.  <groupId>org.springframework</groupId>
  35.  <artifactId>spring-jdbc</artifactId>
  36.  <version>${spring.version}</version>
  37.  </dependency>
  38.  <dependency>
  39.  <groupId>org.springframework</groupId>
  40.  <artifactId>spring-webmvc</artifactId>
  41.  <version>${spring.version}</version>
  42.  </dependency>
  43.  <dependency>
  44.  <groupId>org.springframework</groupId>
  45.  <artifactId>spring-aop</artifactId>
  46.  <version>${spring.version}</version>
  47.  </dependency>
  48.  <dependency>
  49.  <groupId>org.springframework</groupId>
  50.  <artifactId>spring-context-support</artifactId>
  51.  <version>${spring.version}</version>
  52.  </dependency>
  53.  <dependency>
  54.  <groupId>org.springframework</groupId>
  55.  <artifactId>spring-test</artifactId>
  56.  <version>${spring.version}</version>
  57.  </dependency>
  58.  <dependency>
  59.  <groupId>org.springframework</groupId>
  60.  <artifactId>spring-orm</artifactId>
  61.  <version>${spring.version}</version>
  62.  </dependency>
  63.  <dependency>
  64.  <groupId>org.springframework.data</groupId>
  65.  <artifactId>spring-data-jpa</artifactId>
  66.  <version>1.10.1.RELEASE</version>
  67.  </dependency>
  68.  </dependencies>
  69. </project>
 
  
    在WEB-INF目录下添加Spring配置文件applicationContext.xml，并添加如下内容：
 
  
 
  
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p"
  5.  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.  http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
  8.  http://www.springframework.org/schema/context
  9.  http://www.springframework.org/schema/context/spring-context-4.2.xsd
  10.  http://www.springframework.org/schema/tx
  11.  http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
  12.  http://www.springframework.org/schema/aop 
  13.  http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
  14.  http://www.springframework.org/schema/mvc 
  15.  http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
  16.  <!-- 开启IOC注解扫描 -->
  17.  <context:component-scan base-package="com.anxpp.demo" />
  18.  <!-- 开启MVC注解扫描 -->
  19.  <mvc:annotation-driven />
  20. </beans>
 
  
    修改web.xml，将spring添加进去：
 
  
 
  
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.  xmlns="http://java.sun.com/xml/ns/javaee"
  4.  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.  version="3.0">
  6.  <display-name>SpringDataJPA</display-name>
  7.  <listener>
  8.  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  9.  </listener>
  10.  <context-param>
  11.  <param-name>contextConfigLocation</param-name>
  12.  <param-value>WEB-INF/applicationContext.xml</param-value>
  13.  </context-param>
  14.  <servlet>
  15.  <servlet-name>springmvc</servlet-name>
  16.  <servlet-class>org.springframework.web.servlet.DispatcherServlet
  17.  </servlet-class>
  18.  <init-param>
  19.  <param-name>contextConfigLocation</param-name>
  20.  <param-value>classpath*:springmvc-servlet.xml</param-value>
  21.  </init-param>
  22.  <load-on-startup>1</load-on-startup>
  23.  </servlet>
  24.  <servlet-mapping>
  25.  <servlet-name>springmvc</servlet-name>
  26.  <url-pattern>/*</url-pattern>
  27.  </servlet-mapping>
  28.  <welcome-file-list>
  29.  <welcome-file>index.html</welcome-file>
  30.  </welcome-file-list>
  31. </web-app>
 
  
    下面开始编写代码，注意注解不要忘记写，在本小节开始部分已经给出了包的层次结构。
 
  
    实体User：
 
  
 
  
  1. package com.anxpp.demo.core.entity;
  2. public class User {
  3.  private Integer id;
  4.  private String name;
  5.  public User(Integer id, String name) {
  6.  this.id = id;
  7.  this.name = name;
  8.  }
  9.  public Integer getId() {
  10.  return id;
  11.  }
  12.  public void setId(Integer id) {
  13.  this.id = id;
  14.  }
  15.  public String getName() {
  16.  return name;
  17.  }
  18.  public void setName(String name) {
  19.  this.name = name;
  20.  }
  21.  @Override
  22.  public String toString() {
  23.  return "id:"+id+",name:"+name;
  24.  }
  25. }
 
  
    dao层接口UserDao：
 
  
 
  
  1. package com.anxpp.demo.core.dao;
  2. import com.anxpp.demo.core.entity.User;
  3. public interface UserDao {
  4.  User getUser(Integer id,String name);
  5. }
 
  
    dao层实现UserDaoImpl：
 
  
 
  
  1. package com.anxpp.demo.core.dao.impl;
  2. import org.springframework.stereotype.Repository;
  3. import com.anxpp.demo.core.dao.UserDao;
  4. import com.anxpp.demo.core.entity.User;
  5. @Repository
  6. public class UserDaoImpl implements UserDao{
  7.  @Override
  8.  public User getUser(Integer id, String name) {
  9.  return new User(id, name);
  10.  }
  11. }
 
  
    service层接口UserService：
 
  
 
  
  1. package com.anxpp.demo.core.service;
  2. import com.anxpp.demo.core.entity.User;
  3. public interface UserService {
  4.  User getUser(Integer id, String name);
  5. }
 
  
    service层实现：
 
  
 
  
  1. package com.anxpp.demo.core.service.impl;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Service;
  4. import com.anxpp.demo.core.dao.UserDao;
  5. import com.anxpp.demo.core.entity.User;
  6. import com.anxpp.demo.core.service.UserService;
  7. @Service
  8. public class UserServiceImpl implements UserService{
  9.  @Autowired
  10.  UserDao userDao;
  11.  @Override
  12.  public User getUser(Integer id, String name) {
  13.  return userDao.getUser(id, name);
  14.  }
  15. }
 
  
    controller层DemoController：
 
  
 
  
  1. package com.anxpp.demo.controller;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6. import com.anxpp.demo.core.service.UserService;
  7. @Controller
  8. @RequestMapping("/")
  9. public class demoController {
  10.  @Autowired
  11.  UserService userService;
  12.  @RequestMapping("/")
  13.  @ResponseBody
  14.  public String index(){
  15.  return "index";
  16.  }
  17.  @RequestMapping("/getuser")
  18.  @ResponseBody
  19.  public String getUser(Integer id, String name){
  20.  return userService.getUser(id, name).toString();
  21.  }
  22. }
 
  
    这是还不能直接Run On Server，因为jar包不会被一同发布，我们需要如下配置：
 
  
    右键工程选择属性，按下图配置：009
 
  
    这时候就可以运行测试了，效果如下：
 
  
    12
 
  
    13
 
  
    到这里，我们还没有操作数据库的。
 
  
4、添加返回Json格式数据支持
 
  
    现在，我们常使用json作为数据传输的格式，下面就为SpringMVC添加返回json的支持
 
  
    首先添加jar包：
 
  
 
  
  1.  <dependency>
  2.  <groupId>com.fasterxml.jackson.core</groupId>
  3.  <artifactId>jackson-databind</artifactId>
  4.  <version>2.5.0</version>
  5.  </dependency>
  6.  <dependency>
  7.  <groupId>com.fasterxml.jackson.core</groupId>
  8.  <artifactId>jackson-core</artifactId>
  9.  <version>2.5.0</version>
  10.  </dependency>
  11.  <dependency>
  12.  <groupId>com.fasterxml.jackson.core</groupId>
  13.  <artifactId>jackson-annotations</artifactId>
  14.  <version>2.5.0</version>
  15.  </dependency>
 
  
    然后改写getUser()方法如下：
 
  
 
  
  1.  @RequestMapping("/getuser")
  2.  @ResponseBody
  3.  public Map<String, Object> getUser(Integer id, String name){
  4.  Map<String, Object> map = new HashMap<String, Object>();
  5.  map.put("state", "success");
  6.  map.put("data", userService.getUser(id, name));
  7.  return map;
  8.  }
 
  
    重新运行后访问效果如下：
 
  
    14
 
  
    此时，就可以返回json数据了。
 
  
5、配置静态资源访问
 
  
    通常情况下，WEB-INF目录下的资源，我们是无法直接访问的，如果我们的网站是html+ajax构成的，那么就可以在WEB-INF之外新建html的目录，并为web.xml配置默认的过滤器，不过注意要放到SpingMVC过滤器之前：
 
  
 
  
  1.  <servlet-mapping>
  2.  <servlet-name>default</servlet-name>
  3.  <url-pattern>*.html</url-pattern>
  4.  </servlet-mapping>
 
  
    如果一定要访问WEB-INF目录内的资源，通过查阅Spring官方文档，发现有两种方式：
 
  
    1、手写一个资源映射器：
 
  
 
  
  1. @Configuration
  2. @EnableWebMvc
  3. public class WebConfig extends WebMvcConfigurerAdapter {
  4.  @Override
  5.  public void addResourceHandlers(ResourceHandlerRegistry registry) {
  6.  registry.addResourceHandler("/resources/**")
  7.  .addResourceLocations("/public-resources/")
  8.  .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS).cachePublic());
  9.  }
  10. }
 
  
    可以看到，还可以设置缓存时间的，而更简单的方式，就是xml配置：
 
  
 
  
  1. <mvc:resources mapping="/resources/**" location="/public-resources/">
  2.  <mvc:cache-control max-age="3600" cache-public="true"/>
  3. </mvc:resources>
 
  
    也可以加上下面的这个：
 
  
 
  
  1. <!-- 对静态资源文件的访问，将无法mapping到Controller的path交给default servlet handler处理-->
  2. <mvc:default-servlet-handler /> 
 
  
6、乱码解决
 
  
    我们通常使用ajax提交请求，但也常用地址栏直接测试。请求提交分get和post。
 
  
    使用post提交请求是，一般是不会出现中文乱码的，但是如果确实出现了乱码，可以通过在web.xml添加一个编码过滤器解决：
 
  
 
  
  1. <filter>
  2.  <filter-name>CharacterEncoding</filter-name>
  3.  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  4.  <init-param>
  5.  <param-name>encoding</param-name>
  6.  <param-value>UTF-8</param-value>
  7.  </init-param>
  8.  <init-param>
  9.  <param-name>forceEncoding</param-name>
  10.  <param-value>true</param-value>
  11.  </init-param>
  12.  </filter>
  13.  <filter-mapping>
  14.  <filter-name>CharacterEncoding</filter-name>
  15.  <url-pattern>/*</url-pattern>
  16.  </filter-mapping>
 
  
    上面只能解决post的中文乱码，对于get（含浏览器地址栏直接提交方式），我们需要修改tomcat配置，在conf目录下的server.xml中找到并如下修改：
 
  
 
  
  1.  <Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443" URIEncoding="UTF-8"/>
 
  
    如果我们只是测试，项目并没有部署，可以直接在eclipse中的server下，找到server.xml，做出上面一样的改动即可：
 
  
18
 
  
7、整合SpringDataJPA+Hibernate
 
  
    你可以通过这篇文字了解JPA：JPA规范介绍及实例(Java数据持久化解决方案)
 
  
    SpringDataJPA也正是这样一种轻量级的解决方案，而首选的Hibernate就实现了JPA。
 
  
    首先还是jar包，SpringDataJPA的jar包，在之前整合Spring时已经一并加入，下面是Hibernate(和mysql驱动)的jar包：
 
  
 
  
  1.  <!-- hibernate -->
  2.  <dependency>
  3.  <groupId>org.hibernate</groupId>
  4.  <artifactId>hibernate-core</artifactId>
  5.  <version>${hibernate.version}</version>
  6.  </dependency>
  7.  <dependency>
  8.  <groupId>org.hibernate</groupId>
  9.  <artifactId>hibernate-ehcache</artifactId>
  10.  <version>${hibernate.version}</version>
  11.  </dependency>
  12.  <dependency>
  13.  <groupId>org.hibernate</groupId>
  14.  <artifactId>hibernate-entitymanager</artifactId>
  15.  <version>${hibernate.version}</version>
  16.  </dependency>
  17.  <dependency>
  18.  <groupId>org.hibernate</groupId>
  19.  <artifactId>hibernate-c3p0</artifactId>
  20.  <version>${hibernate.version}</version>
  21.  </dependency>
  22.  <dependency>
  23.  <groupId>mysql</groupId>
  24.  <artifactId>mysql-connector-java</artifactId>
  25.  <version>5.1.9</version>
  26.  </dependency>
 
  
    统一管理的版本为：
 
  
 
  
  1.  <!-- hibernate 版本号 -->
  2.  <hibernate.version>5.1.0.Final</hibernate.version>
 
  
    添加Jpa的配置文件persistence.xml到META-INF目录下，本文介绍时数据库使用MySQL。并添加如下内容：
 
  
 
  
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <persistence version="1.0"
  3.  xmlns="http://java.sun.com/xml/ns/persistence"
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  5.  xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  6.  <persistence-unit name="demo" transaction-type="RESOURCE_LOCAL">
  7.  <!-- provider>org.eclipse.persistence.jpa.PersistenceProvider</provider -->
  8.  <provider>org.hibernate.ejb.HibernatePersistence</provider>
  9.  <class>com.ninelephas.meerkat.pojo.User</class>
  10.  <!-- MYSql 的连接 -->
  11.  <properties>
  12.  <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
  13.  <property name="hibernate.connection.url" value="jdbc:mysql://127.0.0.1:3306/demo?createDatabaseIfNotExist=true" />
  14.  <property name="hibernate.connection.username" value="root" />
  15.  <property name="hibernate.connection.password" value="root" />
  16.  <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
  17.  </properties>
  18.  </persistence-unit>
  19. </persistence>
 
  
    Spring配置文件applicationContext.xml中增加JPA支持后的完整内容：
 
  
 
  
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p"
  5.  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.  xmlns:jpa="http://www.springframework.org/schema/data/jpa"
  7.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.  http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
  9.  http://www.springframework.org/schema/context
  10.  http://www.springframework.org/schema/context/spring-context-4.2.xsd
  11.  http://www.springframework.org/schema/tx
  12.  http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
  13.  http://www.springframework.org/schema/aop 
  14.  http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
  15.  http://www.springframework.org/schema/mvc 
  16.  http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
  17.  http://www.springframework.org/schema/data/jpa 
  18.  http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
  19.  <!-- 开启IOC注解扫描 -->
  20.  <context:component-scan base-package="com.anxpp.demo" />
  21.  <bean id="entityManagerFactory"
  22.  class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
  23.  <property name="jpaVendorAdapter">
  24.  <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
  25.  <property name="generateDdl" value="true" />
  26.  <property name="database" value="MYSQL" />
  27.  </bean>
  28.  </property>
  29.  <property name="persistenceUnitName" value="demo" />
  30.  </bean>
  31.  <!-- 开启MVC注解扫描 -->
  32.  <mvc:annotation-driven />
  33.  <bean
  34.  class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
  35.  <property name="viewResolvers">
  36.  <list>
  37.  <bean
  38.  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  39.  <property name="prefix" value="/WEB-INF/view/" />
  40.  <property name="suffix" value=".html" />
  41.  </bean>
  42.  </list>
  43.  </property>
  44.  <!-- 用于将对象转换为 JSON -->
  45.  <property name="defaultViews">
  46.  <list>
  47.  <bean
  48.  class="org.springframework.web.servlet.view.json.MappingJackson2JsonView" />
  49.  </list>
  50.  </property>
  51.  </bean>
  52.  <!-- 对静态资源文件的访问，将无法mapping到Controller的path交给default servlet handler处理 -->
  53.  <mvc:default-servlet-handler />
  54.  <!-- 配置事务管理器 -->
  55.  <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
  56.  <property name="entityManagerFactory" ref="entityManagerFactory" />
  57.  </bean>
  58.  <!-- 启用 annotation事务 -->
  59.  <tx:annotation-driven transaction-manager="transactionManager" />
  60.  <!-- 配置Spring Data JPA扫描目录 -->
  61.  <jpa:repositories base-package="com.anxpp.demo" />
  62. </beans>
 
  
    修改实体：
 
  
 
  
  1. package com.anxpp.demo.core.entity;
  2. import javax.persistence.Entity;
  3. import javax.persistence.GeneratedValue;
  4. import javax.persistence.GenerationType;
  5. import javax.persistence.Id;
  6. import javax.persistence.Table;
  7. @Entity
  8. @Table
  9. public class User {
  10.  @Id
  11.  @GeneratedValue(strategy = GenerationType.AUTO)
  12.  private Integer id;
  13.  private String name;
  14.  public User() {
  15.  }
  16.  public User(String name) {
  17.  this.name = name;
  18.  }
  19.  public Integer getId() {
  20.  return id;
  21.  }
  22.  public void setId(Integer id) {
  23.  this.id = id;
  24.  }
  25.  public String getName() {
  26.  return name;
  27.  }
  28.  public void setName(String name) {
  29.  this.name = name;
  30.  }
  31.  @Override
  32.  public String toString() {
  33.  return "id:"+id+",name:"+name;
  34.  }
  35. }
 
  
    可以删掉dao层实现了，我们记住将dao层接口继承自强大的JpaRepository：
 
  
 
  
  1. public interface UserDao extends JpaRepository<User, Serializable>{
  2.  User findById(Integer id);
  3. }
 
  
    是不是看上去特别简洁，而且都不需要写实现的，SpringDataJPA会自动帮我们完成。
 
  
    修改service层接口：
 
  
 
  
  1. package com.anxpp.demo.core.service;
  2. import java.util.List;
  3. import com.anxpp.demo.core.entity.User;
  4. public interface UserService {
  5.  User findById(Integer id);
  6.  User save(String name);
  7.  List<User> findAll();
  8. }
 
  
    修改service层实现：
 
  
 
  
  1. package com.anxpp.demo.core.service.impl;
  2. import java.util.List;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Service;
  5. import com.anxpp.demo.core.dao.UserDao;
  6. import com.anxpp.demo.core.entity.User;
  7. import com.anxpp.demo.core.service.UserService;
  8. @Service
  9. public class UserServiceImpl implements UserService{
  10.  @Autowired
  11.  UserDao userDao;
  12.  @Override
  13.  public User findById(Integer id) {
  14.  return userDao.findById(id);
  15.  }
  16.  @Override
  17.  public User save(String name) {
  18.  return userDao.save(new User(name));
  19.  }
  20.  @Override
  21.  public List<User> findAll() {
  22.  return userDao.findAll();
  23.  }
  24. }
 
  
    修改controller，提供多个测试接口：
 
  
 
  
  1. package com.anxpp.demo.controller;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  8. import com.anxpp.demo.core.service.UserService;
  9. @Controller
  10. @RequestMapping("/")
  11. public class demoController {
  12.  @Autowired
  13.  UserService userService;
  14.  @RequestMapping("/")
  15.  @ResponseBody
  16.  public String index(){
  17.  return "index";
  18.  }
  19.  @RequestMapping("/info")
  20.  public String info(){
  21.  return "info";
  22.  }
  23.  @RequestMapping("/findall")
  24.  @ResponseBody
  25.  public Map<String, Object> getUser(){
  26.  Map<String, Object> map = new HashMap<String, Object>();
  27.  map.put("state", "success");
  28.  map.put("data", userService.findAll());
  29.  return map;
  30.  }
  31.  @RequestMapping("/findbyid")
  32.  @ResponseBody
  33.  public Map<String, Object> findById(Integer id){
  34.  Map<String, Object> map = new HashMap<String, Object>();
  35.  map.put("state", "success");
  36.  map.put("data", userService.findById(id));
  37.  return map;
  38.  }
  39.  @RequestMapping("/add")
  40.  @ResponseBody
  41.  public Map<String, Object> save(String name){
  42.  Map<String, Object> map = new HashMap<String, Object>();
  43.  map.put("state", "success");
  44.  map.put("data", userService.save(name));
  45.  return map;
  46.  }
  47. }
 
  
    运行效果：
 
  
    15
 
  
    16
 
  
17
 
  
    那么，如果需要添加一个查找id大于指定值的指定姓氏的数据呢？
 
  
    如果是SQL，我们会这样写（？表示参数）：
 
  
 
  
  1. SELECT * FROM user WHERE id>? AND name like '?%';
 
  
    但是这里，我们连SQL（或者HQL）都可以不用写，直接在dao层接口添加一个方法即可：
 
  
 
  
  1.  List<User> findByIdGreaterThanAndNameLike(Integer id,String name);
 
  
    你不需要怀疑，上面的方法执行偏偏就是能成功（注意：service实现的使用，调用该方法记得name+"%"）！
 
  
 
  
源码：
 
  
    github地址：https://github.com/anxpp/SpringMVC-SpringDataJpa-Hibernate-Demo
 
  
    本地下载：SpringMVC + Spring Data JPA + Hibernate
 
  
    CSDN下载（不需要积分）：http://download.csdn.net/download/anxpp/9520498
 
 
 


                

        

        

    




    

      

        

            

              
                
                  Ztt_3278050779
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
springmvc框架源码.zip

				
			

			

				

					12-18
				

			

		

		

			
				
springmvc框架源码（自己用的）

			
		

	



                

              
                



	

		

			

				
					
手把手教你从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate(含源码下载)

				
			

			

				

					anxpp的博客
				

				

					05-15
					
					3万+
					
				

			

		

		

			
				
转载请注明出处：http://blog.csdn.net/anxpp/article/details/51415366，谢谢！

    本文会介绍从一个最基本的java工程，到Web工程，到集成Spring、SpringMVC、SpringDataJPA+Hibernate。

    平时我们可能是通过一个模板，或者是直接导入一个项目，而本文选择从最基本的java工程开始，也是为了展示

			
		

	



                


  
              

                


	

		

			

				
					
Spring-data-jpa详解

				
			

			

				

					heijunwei的博客
				

				

					02-15
					
					6058
					
				

			

		

		

			
				
本篇进行Spring-data-jpa的介绍，几乎涵盖该框架的所有方面，在日常的开发当中，基本上能满足所有需求。这里不讲解JPA和Spring-data-jpa单独使用，所有的内容都是在和Spring整合的环境中实现。如果需要了解该框架的入门，百度一下，很多入门的介绍。在这篇文章的接下来一篇，会有一个系列来讲解mybatis，这个系列从mybatis的入门开始，到基本使用，和spring整合，和第三方插件整合，缓存，插件，最后会持续到mybatis的架构，源码解释，重点会介绍几个重要的设计模式，这样一个体系

			
		

	





	

		

			

				
					
最详细的Spring-data-jpa入门（一）

					
热门推荐

				
			

			

				

					此成非彼诚博客
				

				

					08-13
					
					9万+
					
				

			

		

		

			
				
刚进公司，人生地不熟，偷偷藏着本《mybatis入土为安》，以为可以靠mybatis混的轻松点，谁知天有不测风云，大家用的是JPA。我这个小白没有听说过，全英文名叫，就是java持久化api，是SUN公司推出的一套基于的规范。持久化想必如雷贯耳，都0202年了，谁还不用个持久化框架啊，举起mybatis。ORM呢？全英文名为：对象关系映射，简单来说为了不用JDBC那一套原始方法来操作数据库，ORM框架横空出世（mybatis、hibernate等等）。...

			
		

	



		

			
		



	

		

			

				
					
Maven项目-集成SSJ(Spring+SpringMVC+SpringDataJpa)

				
			

			

				

					Lonely Programmer
				

				

					11-21
					
					377
					
				

			

		

		

			
				
Maven项目-集成SSJ（Spring+SpringMVC+SpringDataJpa）一.什么是SpringDataJpa二.项目导包三 集成SpringDataJpa3.1.1 准备db.propeties3.2.2 准备applicationContext.xml3.2 集成SpringDataJpa3.2.1 准备domain(父类)3.2.2 准备Repository接口3.2.3 扫...

			
		

	





	

		

			

				
					
手动创建 SpringMvc +SpringDataJpa+Hibernate+ freemarker   mavenProject+ 环境切换 webDemo

				
			

			

				

					09-14
				

			

		

		

			
				
基础框架，可满足开发需要

			
		

	





	

		

			

				
					
从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate

				
			

			

				

					09-02
				

			

		

		

			
				
本文会介绍从一个最基本的java工程，到Web工程，到集成Spring、SpringMVC、SpringDataJPA+Hibernate，本文介绍的非常详细，具有参考借鉴价值，感兴趣的朋友一起学习吧

			
		

	





	

		

			

				
					
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA

				
			

			

				

					06-10
				

			

		

		

			
				
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA

			
		

	





	

		

			

				
					
Spring+SpringMVC+SpringDataJPA+Hibernate

				
			

			

				

					05-15
				

			

		

		

			
				
手把手教你从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate。 http://blog.csdn.net/anxpp中有详细搭建教程

			
		

	





	

		

			

				
					
SpringMVC+Spring+SpringDataJPA+Hibernate整合登录的效果

				
			

			

				

					07-13
				

			

		

		

			
				
这是整合SpringMVC+Spring+SpringDataJPA+Hibernate简单的实现登录的功能，用的是mysql数据库，这是一个web Project 如果你用的是JavaEE6那么你要注意bean-validator.jar和weld-osgi-bundle.jar与slf4j的jar包冲突。...

			
		

	





	

		

			

				
					
spring+springmvc+jpa(hibernate)框架整合

				
			

			

				

					02-23
				

			

		

		

			
				
包含构建spring+springmvc+jpa(hibernate)架构框架的所需文件

			
		

	





	

		

			

				
					
springmvc+jpa(hibernate实现)+spring整合实例

				
			

			

				

					04-29
				

			

		

		

			
				
工作用了springmvc+jpa+spring这么长时间，这段时间正好有点时间就想整合一下，但在整合过程中遇到了各种问题，上网查了很多资料但讲的都很模糊或者是没有注释，在我一步一步的试验中终于整合成功了，做为我自已以后复习用的资料我注释写的很全，其中项目里面的配置文件或是代码每行都有注释，网上这种整合实例很少，就奉献出来大家一起学习吧，在整合过程中遇到一个很奇怪的问题，就是spring的事务我配置成@Transactional(readOnly = true)只读事务，但是还可以对数据库进行操作，大家如果知道原因的就一起交流下吧

			
		

	





	

		

			

				
					
Spring+SpringMVC+SpingDataJPA（基于Hibernate）框架搭建

				
			

			

				

					09-05
				

			

		

		

			
				
本文会使用IDEA工具来搭建Spring+SpirngMVC+SpringDataJPA企业常用框架，本文会使用IDEA工具来搭建Spring+SpirngMVC+SpringDataJPA企业常用框架

			
		

	





	

		

			

				
					
Spring MVC+Spring+Spring data JPA

				
			

			

				

					10-23
				

			

		

		

			
				
使用Spring MVC3.0+Spring+Spring data JPA
参照springside的一个小Demo

			
		

	





	

		

			

				
					
从简单的JPA到Spring Data JPA

				
			

			

				

					yunshixin的专栏
				

				

					10-28
					
					951
					
				

			

		

		

			
				
本文代码是基于 Hibernate EntityManager，读者几乎不用修改任何代码，便可以非常容易地切换到其他 JPA 框架，因为代码中使用到的都是 JPA 规范提供的接口 / 类，并没有使用到框架本身的私有特性。示例主要涉及七个文件，但是很清晰：业务层包含一个接口和一个实现；持久层包含一个接口、一个实现、一个实体类；另外加上一个
 JPA 配置文件和一个测试类。相关类 / 接口代码如下：

			
		

	





	

		

			

				
					
Spring Data Jpa的源码探究

				
			

			

				

					jamenu的博客
				

				

					10-06
					
					911
					
				

			

		

		

			
				
Spring Data Jpa的源码探究
Spring Data Jpa的自动配置
Spring Data JPA的自动配置类，在一定的条件下开启
1.JpaRepositoriesAutoConfiguration
@Configuration(proxyBeanMethods = false)   
@ConditionalOnBean(DataSource.class)           //判断是否配置了数据源
@ConditionalOnClass(JpaRepository.class)   

			
		

	





	

		

			

				
					
SpringMVC 源码下载

				
			

			

				

					一路向前
				

				

					03-11
					
					1642
					
				

			

		

		

			
				
SpringMVC 源码下载

目录

1，进行官网

2，进入SpringFramework

3，点击Spring MVC

4，点击下载：

总结：

 在学习中阅读源码是成长途径中很好的一种方式。 Spring源码非常棒，代码里使用了各种设计模式、事件机制、Java8语法，用到的都应该去阅读一下。无论是设计思想，代码规范，还是设计模式，接口设计，类加载，都是非常优秀的源码。而spring-mvc是MVC模式的最佳实践，玩设计模式的癫狂之作，扩展性极强。

 那对应的源码怎么下载呢？ Sp...

			
		

	





	

		

			

				
					
java mvc框架实例下载_SpringMVC4 Hello World源码案例下载

				
			

			

				

					weixin_33435783的博客
				

				

					02-24
					
					142
					
				

			

		

		

			
				
Spring专题SpringMVC4 Hello World源码案例下载Spring的web模型 - 视图 - 控制器(MVC)框架提供了一个模型 - 视图 - 控制器架构，可用于开发灵活的，松散耦合的Web应用程序。框架是围绕DispatcherServlet为核心处理http，处理步骤如下：DispatcherServlet接受一个请求DispatcherServlet使用HandlerM...

			
		

	





	

		

			

				
					
SpringMVC Spring Hibernate框架整合视频

				
			

			

				

					10-12
				

			

		

		

			
				
SpringMVC Spring Hibernate框架整合

			
		

	





	

		

			

				
					
springmvc+spring+spring date jpa jar包下载

					
最新发布

				
			

			

				

					01-02
				

			

		

		

			
				
一旦我们获得了这些jar包，我们就可以将它们添加到我们的项目的依赖中，这样我们就可以在项目中使用SpringMVC、Spring和Spring Data JPA相关的功能了。  总之，SpringMVC、Spring和Spring Data JPA是非常强大并且...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值