文章内容输出来源：拉勾教育Java高薪训练营

Spring + SpringMvc + Spring Data Jpa框架整合

本篇博客，我们来说下spring 整合 spring mvc 和 spring data jpa的整个过程 先来看下项目结构 我把配置文件拆分为spring-mvc.xml 和spring-jpa.xml两个文件，使用 jdbc.properties来配置数据源

准备

数据库脚本

1CREATE TABLE `tb_resume` (
2  `id` int(11) NOT NULL AUTO_INCREMENT,
3  `name` varchar(255) CHARACTER SET utf8 DEFAULT NULL,
4  `address` varchar(255) CHARACTER SET utf8 DEFAULT NULL,
5  `phone` varchar(255) CHARACTER SET utf8 DEFAULT NULL,
6  PRIMARY KEY (`id`)
7) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
8
9-- ----------------------------
10-- Records of tb_resume
11-- ----------------------------
12BEGIN;
13INSERT INTO `tb_resume` VALUES (1, '成龙', '北京朝阳', '17611222456');
14INSERT INTO `tb_resume` VALUES (2, '甄子丹', '北京海淀', '10086');
15INSERT INTO `tb_resume` VALUES (3, '谢霆锋', '河南郑州', '10086');
16COMMIT;

整合需要的jar

1<?xml version="1.0" encoding="UTF-8"?>
2
3<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5    <modelVersion>4.0.0</modelVersion>
6
7    <groupId>org.example</groupId>
8    <artifactId>spring-data-jpa</artifactId>
9    <version>1.0-SNAPSHOT</version>
10    <packaging>war</packaging>
11
12    <name>spring-data-jpa Maven Webapp</name>
13
14    <properties>
15        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
16        <maven.compiler.source>1.8</maven.compiler.source>
17        <maven.compiler.target>1.8</maven.compiler.target>
18        <spring.version>5.2.8.RELEASE</spring.version>
19    </properties>
20
21    <dependencies>
22        <dependency>
23            <groupId>junit</groupId>
24            <artifactId>junit</artifactId>
25            <version>4.12</version>
26        </dependency>
27        <dependency>
28            <groupId>org.springframework.data</groupId>
29            <artifactId>spring-data-jpa</artifactId>
30            <version>2.3.4.RELEASE</version>
31        </dependency>
32        <!--hibernate对jpa的实现jar-->
33        <dependency>
34            <groupId>org.hibernate</groupId>
35            <artifactId>hibernate-entitymanager</artifactId>
36            <version>5.4.21.Final</version>
37        </dependency>
38        <dependency>
39            <groupId>org.hibernate</groupId>
40            <artifactId>hibernate-validator</artifactId>
41            <version>5.3.6.Final</version>
42        </dependency>
43        <!--hibernate相关jar包,end-->
44
45        <!--spring相关-->
46        <dependency>
47            <groupId>org.springframework</groupId>
48            <artifactId>spring-core</artifactId>
49            <version>${spring.version}</version>
50        </dependency>
51        <dependency>
52            <groupId>org.springframework</groupId>
53            <artifactId>spring-orm</artifactId>
54            <version>${spring.version}</version>
55        </dependency>
56        <dependency>
57            <groupId>org.springframework</groupId>
58            <artifactId>spring-context</artifactId>
59            <version>${spring.version}</version>
60        </dependency>
61        <dependency>
62            <groupId>org.springframework</groupId>
63            <artifactId>spring-context-support</artifactId>
64            <version>${spring.version}</version>
65        </dependency>
66        <dependency>
67            <groupId>org.springframework</groupId>
68            <artifactId>spring-tx</artifactId>
69            <version>${spring.version}</version>
70        </dependency>
71        <dependency>
72            <groupId>org.springframework</groupId>
73            <artifactId>spring-jdbc</artifactId>
74            <version>${spring.version}</version>
75        </dependency>
76        <dependency>
77            <groupId>org.springframework</groupId>
78            <artifactId>spring-test</artifactId>
79            <version>${spring.version}</version>
80        </dependency>
81        <dependency>
82            <groupId>org.aspectj</groupId>
83            <artifactId>aspectjweaver</artifactId>
84            <version>1.9.4</version>
85        </dependency>
86
87        <!--数据库驱动jar-->
88        <dependency>
89            <groupId>mysql</groupId>
90            <artifactId>mysql-connector-java</artifactId>
91            <version>5.1.46</version>
92        </dependency>
93        <!--druid连接池-->
94        <dependency>
95            <groupId>com.alibaba</groupId>
96            <artifactId>druid</artifactId>
97            <version>1.1.21</version>
98        </dependency>
99        <dependency>
100            <groupId>org.projectlombok</groupId>
101            <artifactId>lombok</artifactId>
102            <version>1.18.12</version>
103        </dependency>
104        <!--集成spring mvc-->
105        <dependency>
106            <groupId>org.springframework</groupId>
107            <artifactId>spring-webmvc</artifactId>
108            <version>${spring.version}</version>
109        </dependency>
110        <dependency>
111            <groupId>com.fasterxml.jackson.core</groupId>
112            <artifactId>jackson-databind</artifactId>
113            <version>2.11.1</version>
114        </dependency>
115        <!--jsp-api&servlet-api-->
116        <dependency>
117            <groupId>javax.servlet</groupId>
118            <artifactId>javax.servlet-api</artifactId>
119            <version>3.1.0</version>
120            <scope>provided</scope>
121        </dependency>
122    </dependencies>
123
124    <build>
125        <finalName>ssm</finalName>
126        <pluginManagement>
127            <plugins>
128                <plugin>
129                    <groupId>org.apache.maven.plugins</groupId>
130                    <artifactId>maven-compiler-plugin</artifactId>
131                    <version>3.8.1</version>
132                    <configuration>
133                        <target>8</target>
134                        <source>8</source>
135                        <encoding>UTF-8</encoding>
136                    </configuration>
137                </plugin>
138            </plugins>
139        </pluginManagement>
140    </build>
141</project>
142

接下来我来说下如何进行集成

1. spring 集成 spring data jpa

1.1 数据源配置文件jdbc.properties

这里我们使用的数据库是MySQL

1jdbc.driver=com.mysql.jdbc.Driver
2jdbc.url=jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8
3jdbc.username=root
4jdbc.password=root

1.1 Jpa配置文件 spring-jpa.xml

我们先来配置一下数据源，因为我们用properties文件来进行配置的，所以我们需要引入下配置文件，然后引入数据源，这里数据源我们使用的是阿里的Druid

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3       xmlns:context="http://www.springframework.org/schema/context"
4       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
5       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6       xsi:schemaLocation="
7        http://www.springframework.org/schema/beans
8        http://www.springframework.org/schema/beans/spring-beans.xsd
9        http://www.springframework.org/schema/context
10        http://www.springframework.org/schema/context/spring-context.xsd
11        http://www.springframework.org/schema/data/jpa
12        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
13        ">
14        
15    <context:property-placeholder location="classpath:jdbc.properties"/>
16
17    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
18        <property name="driverClassName" value="${jdbc.driver}"/>
19        <property name="url" value="${jdbc.url}"/>
20        <property name="username" value="${jdbc.username}"/>
21        <property name="password" value="${jdbc.password}"/>
22    </bean>
23</beans>

接下来配置spring 的包扫描

    <context:component-scan base-package="com.lagou"/>

接下来就配置jpa的EntityManagerFactory以及jpa的事务管理器还有jpa dao层的一些细节，比如配置dao层所在的包，指定EntityManagerFactory以及事务管理器

1<!--配置EntityManagerFactory-->
2    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
3        <!--数据源-->
4        <property name="dataSource" ref="dataSource"/>
5        <!--配置包扫描（实体所在包）-->
6        <property name="packagesToScan" value="com.lagou.pojo"/>
7        <!--指定jpa的具体实现，这里用的hibernate-->
8        <property name="persistenceProvider">
9            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
10        </property>
11        <!--指定方言-->
12        <property name="jpaDialect">
13            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
14        </property>
15        <!--配置具体的provider hibernate框架执行细节-->
16        <property name="jpaVendorAdapter" >
17            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
18                <!--指定数据库类型-->
19                <property name="database" value="MYSQL"/>
20                <!--程序启动之后是否需要给数据库创建映射表-->
21                <property name="generateDdl" value="false"/>
22                <!--是否打印sql-->
23                <property name="showSql" value="true"/>
24                <!--配置数据库方言，根据不同数据库执行各自的语法-->
25                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
26            </bean>
27        </property>
28    </bean>
29
30    <!--配置jpa事务管理器-->
31    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
32        <property name="entityManagerFactory" ref="entityManagerFactory"/>
33    </bean>
34
35    <!--配置jpa dao层细节-->
36    <jpa:repositories base-package="com.lagou.dao" entity-manager-factory-ref="entityManagerFactory"
37                      transaction-manager-ref="transactionManager"/>

到这里，我们关于jpa的配置以及完全结束。

1.3 Jpa 实体对象配置Resume.java

配置一个Jpa对象需要使用到一下注解

• @Entity 告诉Jpa，这是我们配置的一个实体类

• @Table 指定类和数据库表映射关系

• @Id 标记主键ID

• @GeneratedValue 主键生成策略，根据不同的数据库可以配置不同的策略

• @Column 指定实体属性和数据库表中属性的对应关系

  @Entity @Table(name = "tb_resume") @Data @ToString public class Resume { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id;

  1@Column(name = "name")
  2private String name;
  3
  4@Column(name = "address")
  5private String address;
  6
  7@Column(name = "phone")
  8private String phone;
  

  }

1.4 配置Jpa dao层接口ResumeDao.java

想要使用jpa提供的数据库操作方法，我们需要继承JpaRepository 和JpaSpecificationExecutor两个接口，这里可能有同学会问了，java不是单继承吗？ 注意，这里的ResumeDao是接口，接口是可以多继承的。 JpaRepository 和JpaSpecificationExecutor这两个接口提供了我们常用的一些增删改查操作，继承之后就不需要我们自己写这些SQL操作了。

1public interface ResumeDao extends JpaRepository<Resume, Integer>, JpaSpecificationExecutor<Resume> {
2}

1.5 整合测试

以上我们所有jpa相关的配置都以及完成了，接下来我们来测试下，我们的配置有没有问题 测试类ResumeDaoTest.java 这里我们使用junit4来进行测试，里面有两个测试用例，查询所有和添加，我们分别来测试下

1@RunWith(SpringJUnit4ClassRunner.class)
2@ContextConfiguration(locations = {"classpath*:spring-*.xml"})
3public class ResumeDaoTest {
4
5    @Autowired
6    private ResumeDao resumeDao;
7
8    @Test
9    public void findAll() {
10        List<Resume> all = resumeDao.findAll();
11        System.out.println(all);
12    }
13
14    @Test
15    public void add() {
16        Resume resume = new Resume();
17        resume.setName("王五");
18        resume.setAddress("Henan");
19        resume.setPhone("17611222722");
20        System.out.println(resumeDao.save(resume));
21    }
22    
23}

findAll()

add() 可以看到，查询和添加都正常，接下来我们看下和springmvc的集成

2. spring 集成springMvc

2.1 配置文件spring-mvc.xml

相较于jpa的整合，spring mvc的整合就简单了一点，都比较简单，我们就不解释了

1<?xml version="1.0" encoding="UTF-8"?>
2<beans xmlns="http://www.springframework.org/schema/beans"
3       xmlns:context="http://www.springframework.org/schema/context"
4       xmlns:mvc="http://www.springframework.org/schema/mvc"
5       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6       xsi:schemaLocation="
7        http://www.springframework.org/schema/beans
8        http://www.springframework.org/schema/beans/spring-beans.xsd
9        http://www.springframework.org/schema/context
10        http://www.springframework.org/schema/context/spring-context.xsd
11        http://www.springframework.org/schema/mvc
12        http://www.springframework.org/schema/mvc/spring-mvc.xsd
13        ">
14
15    <context:component-scan base-package="com.lagou.controller"/>
16
17    <mvc:annotation-driven/>
18
19    <!--配置spring mvc的视图解析器-->
20    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
21        <property name="prefix" value="/jsp/"/>
22        <property name="suffix" value=".jsp"/>
23    </bean>
24
25    <mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>
26    <mvc:resources location="/layer/" mapping="/layer/**"/>
27</beans>

2.2 Servlet配置文件web.xml

主要是配置spring mvc的监听类DispatcherServlet，配置一下拦截路径，这里我们直接拦截出了jsp之外的所有文件。另外为了防止字符乱码，这里我们配置了字符过滤器

1<!DOCTYPE web-app PUBLIC
2        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
3        "http://java.sun.com/dtd/web-app_2_3.dtd" >
4
5<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6         xmlns="http://java.sun.com/xml/ns/javaee"
7         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
8         id="WebApp_ID" version="2.5">
9    <display-name>Archetype Created Web Application</display-name>
10    <welcome-file-list>
11        <welcome-file>/jsp/login.jsp</welcome-file>
12    </welcome-file-list>
13
14    <!--配置编码过滤器-->
15    <filter>
16        <filter-name>characterEncodingFilter</filter-name>
17        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
18        <init-param>
19            <param-name>encoding</param-name>
20            <param-value>UTF-8</param-value>
21        </init-param>
22        <init-param>
23            <param-name>forceEncoding</param-name>
24            <param-value>true</param-value>
25        </init-param>
26    </filter>
27
28    <filter-mapping>
29        <filter-name>characterEncodingFilter</filter-name>
30        <url-pattern>/*</url-pattern>
31    </filter-mapping>
32
33    <servlet>
34        <servlet-name>dispatcherServlet</servlet-name>
35        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
36        <init-param>
37            <param-name>contextConfigLocation</param-name>
38            <param-value>classpath*:spring-*.xml</param-value>
39        </init-param>
40    </servlet>
41
42    <servlet-mapping>
43        <servlet-name>dispatcherServlet</servlet-name>
44        <url-pattern>/</url-pattern>
45    </servlet-mapping>
46</web-app>

2.3 配置controller ResumeController.java

这里我们配置了针对resume的基本增删改查操作，以及一些跳转操作

1@Controller
2@RequestMapping("/resume")
3public class ResumeController {
4
5    @Resource
6    private ResumeService resumeService;
7
8    @RequestMapping(value = "/getAll", method = RequestMethod.GET)
9    @ResponseBody
10    public Result getAll() {
11        return resumeService.getResumeList();
12    }
13
14    @RequestMapping(value = "/toAdd")
15    public String addResume() {
16        return "addResume";
17    }
18
19    @RequestMapping(value = "/add", method = RequestMethod.POST)
20    @ResponseBody
21    public Result addResume(@RequestBody Resume resume) {
22        return resumeService.addResume(resume);
23    }
24
25    @RequestMapping("/update")
26    @ResponseBody
27    public Result toUpdate(@RequestBody Resume resume) {
28        return resumeService.updateResume(resume);
29    }
30
31    @RequestMapping("/toUpdate/{id}")
32    public String toUpdateResume(@PathVariable("id") Integer id, ModelMap modelMap) {
33        Result resume = resumeService.getResumeById(id);
34        modelMap.addAttribute("resume", resume.getResult());
35        return "editResume";
36    }
37
38    @RequestMapping("/delete/{id}")
39    @ResponseBody
40    public Result deleteResume(@PathVariable("id") Integer id) {
41        return resumeService.deleteResume(id);
42    }
43}

2.4 配置service接口ResumeService

1public interface ResumeService {
2
3    Result getResumeList();
4
5    Result getResumeById(Integer id);
6
7    Result addResume(Resume resume);
8
9    Result updateResume(Resume resume);
10
11    Result deleteResume(Integer id);
12}

2.5 配置service实现类ResumeServiceImpl.java

1@Service
2public class ResumeServiceImpl implements ResumeService {
3
4    @Resource
5    private ResumeDao resumeDao;
6
7    @Override
8    public Result getResumeList() {
9        return ResultUtils.success(resumeDao.findAll());
10    }
11
12    @Override
13    public Result getResumeById(Integer id) {
14        Optional<Resume> resume = resumeDao.findById(id);
15        return ResultUtils.success(resume.orElse(null));
16    }
17
18    @Override
19    public Result addResume(Resume resume) {
20        return ResultUtils.success(resumeDao.save(resume));
21    }
22
23    @Override
24    public Result updateResume(Resume resume) {
25        return ResultUtils.success(resumeDao.save(resume));
26    }
27
28    @Override
29    public Result deleteResume(Integer id) {
30        Optional<Resume> resume = resumeDao.findById(id);
31        if (!resume.isPresent()) {
32            return ResultUtils.error(500, "请求删除对象未找到");
33        }
34        resumeDao.delete(resume.get());
35        return ResultUtils.success();
36    }
37}

2.6 测试

其实项目中我们实现了一个简单的登录，以及针对resume的增删改查操作，因为这不是我们关注的重点，所以我就不贴代码了，想要完整项目的可以去我的码云上面下载完整代码 我们直接看测试情况

总结

以上就是我们整合的全部过程，希望对初学者有点帮助，想要完整代码的可以点下面链接获取完整代码 https://gitee.com/tengfei-wang/spring-data-jpa