http://mark-yang.github.io/blog/2015/04/24/spring-springmvc-hibernate/
本篇主要介绍的是JavaEE中的框架SpringMVC
,在以前上JavaEE课程时,课程项目里使用的是比较“古老”的SSH(Struts2+Spring+Hibernate)
框架,最近受某小朋友的影响着手了解SpringMVC
,一种更轻量级,更方便使用的框架。老规矩,附Wikipedia链接——Spring,其中Model-view-controller framework
部分的介绍就是我们常说的SpringMVC
。
受以前项目的影响,感觉框架的合理使用可以省去不少的麻烦。所以此次介绍的是另一种多框架的混合使用,即,Spring + SpringMVC + Hibernate
框架在InteliJ
和Maven
的环境下的搭建,并采用注释的写法。后续还会有在此框架的基框之上的demo,敬请期待。
搭建环境
操作系统:Mac OSX Yosemite Version 10.10.3
集成开发环境(IDE):IntelliJ IDEA 14.1
本地服务器:Tomcat 8.0.21
Maven版本:Maven3 3.0.5
目录
一、SpringMVC框架的使用
二、SpringMVC与Spring结合
三、Hibernate框架的加入
四、总结
一、SpringMVC框架的使用
1.建立工程
首先我们在IntelliJ
中建立一个JavaEE Project,选择Maven工程
,选择org.apache.marmotta:marmotta-archetype-webapp
,然后输入GroupId
与ArtifactId
,这里就不做详细的介绍了。
2.项目结构
工程建好了之后,如果想先看一下本文所展示的demo的工程目录,用来为后面的步骤过程中路径配置时作为参考,其次还有项目的源码都请戳:structure:https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/structure.png
源码:https://github.com/MarK-YANG/Spring-SpringMVC-Hibernate
3.pom.xml
正如开始的时候介绍的一样,我们使用Maven
来管理我们在项目使用到的各种包,而所有包的配置信息都在pom.xml
文件中,所以我们首要的工作就是通过pom.xml
文件来找并管理到我们想要的包。在pom.xml
文件中加入我们所需要的dependence
和properties
,具体如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
4.0.4.RELEASE
org.springframework
spring-webmvc
${spring.version}
javax.servlet.jsp.jstl
javax.servlet.jsp.jstl-api
1.2.1
taglibs
standard
1.1.2
tomcat
servlet-api
5.5.23
provided
tomcat
jsp-api
5.5.23
provided
commons-fileupload
commons-fileupload
1.3.1
org.hibernate
hibernate-validator
5.1.2.Final
org.codehaus.jackson
jackson-mapper-asl
1.9.13
|
然后,简单的介绍一下这些我们导入的包, spring-webmvc
是我们SpringMVC
框架的核心包,spring-core
,spring-web
都是其依赖包。
其次,jstl
、taglibs
等包是为了在jsp页面中使用JSTL标签。
然后,jackson-mapper
包是使springMVC可以返回json值,json和xml方法是我们常用的两种网络传值方式。在springMVC中仅提供了json的接口,并未提供其实现,所以我们要导入它的实现包json-mapper。
再之,commons-fileupload
包是为了文件上传所需要的,在本文中的demo中并未涉及到文件的上传,可以选择不添加。
然后,hibernate-validator
是为了正常的使用springMVC中的valid,这是因为springMVC中的valid只提供了接口的实现,如果想使用这个接口,就必须要导入它的实现——hibernate-validator,但这项在本文中也未涉及,可以选择不添加。
4.修改web.xml
springMVC中只有一个核心的Servlet,所以我们要在web.xml
中注册这个springMVC的Servlet,web.xml文件如下,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
metadata-complete="true" version="3.0">
spring-dispatcher
org.springframework.web.servlet.DispatcherServlet
spring-dispatcher
/
|
这只是我们配置springMVC的开始,springMVC还有许多其他的配置项,但其他的配置项在另一个文件中,这个配置文件就是默认位置为web.xml
同路径下的——-servlet.xml
。如,我的web.xml中配置的是spring-dispatcher
,对应的xml文件的名字应为:spring-dispatcher-servlet.xml
。
5.开始配置spring-dispatcher-servlet.xml
我们在与web.xml
同路径下创建spring-dispatcher-servlet.xml
如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
base-package="com.mark.java.controller"/>
/>
id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
name="prefix" value="/pages/"/>
name="suffix" value=".jsp"/>
id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
name="defaultEncoding" value="UTF-8"/>
name="maxUploadSize" value="2000000"/>
mapping="/static/**" location="/"/>
/>
|
简单的解释一下,springMVC中的虚拟路径与处理函数的映射,是通过annotation(注释)来设置的,而这些类都在哪个包下面,就是通过component-scan
属性配置的,并设置支持annotation支持。
springMVC的每一个处理函数都会返回一个String类型的变量(有的函数返回值就是 String,有的返回值是一个对象,对象里有一个viewResolver
需要的字符串),我们这里设置了一个前缀和后缀,举个例子来说,对于函数返回的这个String,比如是fowafolo
,那么需要的文件就是/pages/fowafolo.jsp
。
multipartResolver
是上传文件需要的配置,本文中并未涉及到。
最后是对静态资源
的映射,经过这个映射之后,要访问/static/fowafolo.png
时,实际访问的就是/resources/fowafolo.png
。
6.MainController
下面我们开始写我们springMVC中的第一个controller, MainController
,这个controller的位置就应该是我们刚才配置的spring-dispatcher-servlet.xml
中component-scan
配置的路径下,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
@Controller
@RequestMapping("/")
public class MainController {
@RequestMapping("")
public String index(){
return "index";
}
@RequestMapping("/json")
@ResponseBody
public Map<String, String> json(){
Map<String, String> result = new HashMap<String, String>();
result.put("MarK", "hello");
result.put("Ken", "Hehe");
result.put("Fowafolo", "fool");
return result;
}
}
|
简单的解释一下,这个controller的RequestMapping是"/"
,index()的RequestMapping也是"/"
,而方法json的RequestMapping是"/json"
,也就是说,当访问的URL是”/“时,我们会调用index()方法处理,它返回的字符串是index,再根据我们配置文件中的路径,它指向的就是我们/webapp/pages下的index.jsp,所以别忘了去在这个目当下新建一个index.jsp,给一个简单的例子。
1
2
3
4
5
6
7
8
9
10
11
12
|
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
Hello, Fowafolo
Fowafolo is a foolish !
|
部署工程,我们给这个工程加一个前缀,如/spring,那么我们访问:http://localhost:8080/spring/
得到的就是我们新建的index.jsp,如果我们访问http://localhost:8080/spring/json
得到的就是我们json的返回值:{"MarK":"hello","Ken":"Hehe","Fowafolo":"fool"}
。
最后,我们再多说几句,因为我们想在/webapp/pages下管理我们所有jsp,所以/webapp下的index.jsp可以不保留,其次,在部署项目时,不建议勾选此项,手动的在browser中输入url更好。
二、SpringMVC与Spring结合
Spring
是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java
开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design
中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构
,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean
来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC
)和面向切面(AOP)
。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级
开源框架。
1. 再次配置web.xml
Spring
要在程序调用某个对象的时候,就要首先把这个对象的实例注入进去。Spring自己对实例、程序运行的管理构成了Spring自己的容器,第一步就是要在web.xml
中注册初始化这个容器。在此之前我们先在/resources
文件夹下,创建子路径META-INF
,然后在这个文件夹下,创建我们后面要用到的applicationContext.xml
文件,如果用过spring框架的人对这个文件都不会陌生,这是spring的配置文件。最后web.xml文件如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
metadata-complete="true" version="3.0">
spring-dispatcher
org.springframework.web.servlet.DispatcherServlet
spring-dispatcher
/
contextConfigLocation
classpath:/META-INF/applicationContext.xml
org.springframework.web.context.ContextLoaderListener
|
2. 配置applicationContext.xml文件
在spring4
之后,spring配置的bean不是在xml文件中配置了,而是采用固定扫描annotation
的类,根据对象的类型或者名字自动加载,但此前提是我们仍然要在配置文件中配置好这些类所在包的路径。最后applicationContext.xml文件如下,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">
base-package="com.mark.java.service"/>
|
3. 创建一个Service类,UserService.java
Service的创建我们还是比较推荐具体的service实现相应的接口的方式,下面我们写一个服务类,用来获取注册的用户,在包com.mark.java.service下创建接口UserService
。
1
2
3
|
public interface UserService {
public List<String> getAllUsernames();
}
|
然后再创建一个UserServiceImpl
来实现此接口,
1
2
3
4
5
6
7
8
9
10
11
12
|
@Service
public class UserServiceImpl implements UserService {
public List<String> getAllUsernames() {
List<String> users = new ArrayList<String>();
users.add("MarK");
users.add("Ken");
users.add("Fowafolo");
return users;
}
}
|
注意!!!,我们要对个实现加上注释@Service
,这是在告诉spring,我需要你来管理我。
4. 修改MainController
在上一节中,我们通过json来返回一个json对象,现在我们修改这个方法,通过刚刚创建的service来返回用户列表给客户端。
首先,我们得先定义一个全局变量,usrService
,
1
2
|
@Autowired
private UserService userService;
|
这里要注意的是Autowire
这个annotation,它是为了告诉spring,这个对象没有实例化,需要注入一个UserService
的实例,可是问题是,UserSerivce是一个接口
,如果不指定就不知道你想用哪个实现类,Spring会首先看自己的容器里有没有一个叫做userService
的对象(刚才创建的UserServiceImpl的对象名字就叫做userServiceImpl
),如果找不到就在配置文件里配置的路径下面寻找UserService的实现类,找到了就把它的对象拿过来.除此之外刚才Service那个annotation还可以指 定一个value:@Service("userService")
。这样一来,对于UserServiceImpl这个类的实例,Spring给它起的名字就不是userServiceImpl了,而是userService
,如果某个接口的实现类有多个,就可以使用这种方法来指定用哪个实现类,个人认为,如果每个接口都只有一个实现类,那么这么做确实很方便,但如果有多个实现类并且可能会更换的话,就不如配置文件明了了。
说了半天,最后修改json方法,
1
2
3
4
5
|
@RequestMapping("/json")
@ResponseBody
public List<String> json(){
return userService.getAllUsernames();
}
|
Spring在这里的作用就是把MainController需要的userService引入进来
,然后访问http://localhost:8080/spring/json
会得到以下结果:
["MarK","Ken","Fawofolo"]
三、Hibernate框架的加入
Hibernate
是一个开放源代码的对象关系映射框架,它对JDBC
进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合
,既可以在Java的客户端程序使用,也可以在Servlet/JSP
的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化
的重任。
1. 导入Hibernate所需要的包
在pom.xml
中,在properties
标签下面定义一个版本,
1
2
3
4
|
4.0.4.RELEASE
4.3.5.Final
|
然后加入hibernate的核心包,因为要让Spring管理一些对象,还要引入spring-orm
的包:
1
2
3
4
5
6
7
8
9
10
|
org.springframework
spring-orm
${spring.version}
org.hibernate
hibernate-core
${hibernate.version}
|
除此之外,因为我们要用mysql
数据库,并使用c3p0
连接池,因此需要引入这两个对应的包:
1
2
3
4
5
6
7
8
9
10
|
c3p0
c3p0
0.9.1.2
mysql
mysql-connector-java
5.1.31
|
2. 再次修改web.xml
Hibernate通过SessionFactory
来获取Session
,我们要在spring的配置文件中配置一个我们所需的SessionFactory,为了便于修改,我们新建一个配置文件,路径与spring的配置文件相同,我们新建一个infrastructure.xml
, 最后我们的web.xml文件如下,其他的不做具体的介绍了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
metadata-complete="true" version="3.0">
spring-dispatcher
org.springframework.web.servlet.DispatcherServlet
spring-dispatcher
/
hibernateFilter
org.springframework.orm.hibernate4.support.OpenSessionInViewFilter
hibernateFilter
/*
SpringEncodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
UTF-8
forceEncoding
true
SpringEncodingFilter
/*
contextConfigLocation
classpath:/META-INF/applicationContext.xml,
classpath:/META-INF/infrastructure.xml
org.springframework.web.context.ContextLoaderListener
|
3. 配置hibernate.properties, infrastructure.xml
infrastructure.xml
之前,我们要在/META-INF下新建properties文件夹,在里在新建hibernate.properties
文件用来加入我们数据库的参数,hibernate.properties
的配置如下,
1
2
3
4
5
6
7
8
9
10
|
hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
username=root
password=yang
hibernate.hbm2ddl.auto=none
hibernate.show_sql=true
hibernate.format_sql=true
|
注意以下几点,
driverClassName
是你所连数据库的驱动的jar包的名称,这里我用的MySQL,所以是com.mysql.jdbc.Driver
,
url
是连接数据库的url,这里是jdbc:mysql://localhost:3306/
本机本地数据库,后面是数据库的名称,为test
,然后后面的一串,是JDBC对数据库进行CRUD时的编码,我们采用UTF-8以支持中文。
username
和password
是本地数据库的用户名和密码。
其他项可无视。infrastructure.xml
的配置如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
">
location="classpath:/META-INF/properties/hibernate.properties" />
id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
name="driverClass" value="${driverClassName}">
name="jdbcUrl" value="${url}">
name="user" value="${username}">
name="password" value="${password}">
name="maxPoolSize" value="40">
name="minPoolSize" value="1">
name="initialPoolSize" value="1">
name="maxIdleTime" value="20">
id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
name="dataSource" ref="dataSource" />
name="packagesToScan" value="com.mark.java.entity" />
name="hibernateProperties">
key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}
key="hibernate.dialect">${hibernate.dialect}
key="hibernate.show_sql">${hibernate.show_sql}
key="hibernate.format_sql">${hibernate.format_sql}
id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
name="sessionFactory" ref="sessionFactory">
transaction-manager="transactionManager" />
|
其所需的参数信息都是从刚才配置好的properties文件中读取。
4. 再次修改applicationContext.xml
我们还需要对这个配置文件做一点点小的修改,加入两行,
1
2
3
|
base-package="com.mark.java.entity"/>
base-package="com.mark.java.DAO"/>
|
解释一下,其中com.mark.java.entity则是我们MVC模式中model
或称为JavaBean的文件夹目录,其格式应与数据库中字段相同;com.mark.java.DAO是访问数据库要使用DAO,即数据访问对象的目录。我们把这些同service都交给spring管理。最后applicationContext.xml
文件如下,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">
base-package="com.mark.java.service"/>
base-package="com.mark.java.entity"/>
base-package="com.mark.java.DAO"/>
|
5. 建立表User
我们在我们的本地数据库中建立一个表,名为User
, 其有两个字段,一个为id
,主键
,int类型
,自增
,另一个为usrname
, varchar
。
具体请戳:https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/table.png
6. 创建JavaBean
在entity目录下创建User.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
@Entity
@Table
public class User implements Serializable {
@Id
@GeneratedValue
private int id;
private String username;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
|
注:这里的annotation用的都是JPA的接口。
7. 创建UserDAO
首先创建UserDAO接口,
1
2
3
4
|
public interface UserDAO {
public int save(User u);
public List<User> findAll();
}
|
创建UserDAOImpl实现此接口,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
@Repository
public class UserDAOImpl implements UserDAO {
@Autowired
private SessionFactory sessionFactory;
public int save(User u) {
return (Integer) sessionFactory.getCurrentSession().save(u);
}
public List<User> findAll() {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(User.class);
return criteria.list();
}
}
|
注:第一个annotation注明这是一个repository,需要被Spring管理,然后自动装载之前在配置文件中配置的 SessionFactory,获取当前session后获取所有的用户,下面修改之前的UserService代码,service封装业务逻辑层代 码,我把每个service方法封装为一个事务。(PS:上面的SessionFactory获取当前Session是依赖于事务的,如果不在某个事务之内, 会报错:No Session found for current thread。)
8.更新UserService
修改UserService接口,
1
2
3
4
|
public interface UserService {
public void saveUsers(List<User> us);
public List<User> getAllUsernames();
}
|
修改UserServiceImpl,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
@Service("userService")
@Transactional
public class UserServiceImpl implements UserService {
@Autowired
private UserDAO userDao;
public void saveUsers(List<User> us) {
for (User u : us) {
userDao.save(u);
}
}
public List<User> getAllUsernames() {
return userDao.findAll();
}
}
|
注:这个annotation为Transactional,就是指明每个方法是一个事务。
9. 修改MainController
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
@Controller
@RequestMapping("/")
public class MainController {
@Autowired
private UserService userService;
@RequestMapping("")
public String home(){
List<User> us = new ArrayList<User>();
User u = new User();
u.setUsername("MarK");
us.add(u);
u = new User();
u.setUsername("Fawofolo");
us.add(u);
userService.saveUsers(us);
return "index";
}
@RequestMapping("/json")
@ResponseBody
public List<User> json(){
return userService.getAllUsernames();
}
}
|
部署项目,访问http://localhost:8080/spring
加入两条新的数据,
访问http://localhost:8080/spring/json
查看这两条数据,
结果如下:[{"id":1,"username":"MarK"},{"id":2,"username":"Fawofolo"}]
注:如果发现数据插入两遍,请回头看第一节关于项目部署的介绍。
至此,环境搭建完毕,后面还会有一篇在此环境基础之上做的springMVC的简单实例,敬请期待…
完。