[转] Spring MVC 4.1.3 + MyBatis 零基础搭建Web开发框架

首先感谢一下润和软件，指引我走上了Spring MVC Web开发的道路。
下面进入正题

搭建开发环境：

Netbeans8.0.2 + MySql5.6 + JDK1.7 + tomcat8.0.15

本次采用的Spring MVC Jar包如下：

spring-aop-4.1.3.RELEASE.jar
spring-beans-4.1.3.RELEASE.jar
spring-context-4.1.3.RELEASE.jar
spring-context-support-4.1.3.RELEASE.jar
spring-core-4.1.3.RELEASE.jar
spring-expression-4.1.3.RELEASE.jar
spring-jdbc-4.1.3.RELEASE.jar
spring-oxm-4.1.3.RELEASE.jar
spring-tx-4.1.3.RELEASE.jar
spring-web-4.1.3.RELEASE.jar
spring-webmvc-4.1.3.RELEASE.jar
当然还有其他的依赖jar，如有需要请留下邮箱~！

1.首先创建Web项目

web.mvc

2.引入所有的jar文件

3.配置web.xml

做web开发的都知道,web.xml是项目的入口，我们既然使用spring那么当然要添加Spring的支持啦！
spring默认加载的是applicationContext.xml，由于我们需要集成MyBatis
所以我把Spring的配置文件强制指定名称，并与MyBatis一起配置，减少配置文件数量

先指定spring配置文件名名称与路径

1. <!--  Spring 上下文参数 加载Spring配置文件 -->
2. <context-param>
3. <param-name>contextConfigLocation</param-name>
4. <param-value>classpath*:xmlconfig/springmvc-mybatis.xml</param-value>
5. </context-param>

再执行Spring上下文监听配置

1. <listener>
2. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
3. </listener>

添加支持Spring mvc 的配置

说明：添加支持目前有3种方式。

第一种：拦截 /*.do

1. <!-- spring mvc 拦截器配置 -->
2. <servlet>
3. <servlet-name>springmvc</servlet-name>
4. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
5. <init-param>
6. <param-name>contextConfigLocation</param-name>
7. <param-value>classpath*:/xmlconfig/springmvc-servlet.xml</param-value>
8. </init-param>
9. <load-on-startup>1</load-on-startup>
10. </servlet>
11. <servlet-mapping>
12. <servlet-name>springmvc</servlet-name>
13. <url-pattern>/*.do</url-pattern>
14. </servlet-mapping>

优势：拦截明确，不会和其他的拦截冲突

缺点：URL不美观

第二种：拦截 /*

1. <!-- spring mvc 拦截器配置 -->
2. <servlet>
3. <servlet-name>springmvc</servlet-name>
4. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
5. <init-param>
6. <param-name>contextConfigLocation</param-name>
7. <param-value>classpath*:/xmlconfig/springmvc-servlet.xml</param-value>
8. </init-param>
9. <load-on-startup>1</load-on-startup>
10. </servlet>
11. <servlet-mapping>
12. <servlet-name>springmvc</servlet-name>
13. <url-pattern>/*</url-pattern>
14. </servlet-mapping>

优点：支持rest风格，Url美观
缺点：会拦截静态资源

第三种，也是我推荐的一种：拦截 /

1. <!-- spring mvc 拦截器配置 -->
2. <servlet>
3. <servlet-name>springmvc</servlet-name>
4. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
5. <init-param>
6. <param-name>contextConfigLocation</param-name>
7. <param-value>classpath*:/xmlconfig/springmvc-servlet.xml</param-value>
8. </init-param>
9. <load-on-startup>1</load-on-startup>
10. </servlet>
11. <servlet-mapping>
12. <servlet-name>springmvc</servlet-name>
13. <url-pattern>/</url-pattern>
14. </servlet-mapping>

优点：支持rest风格，URL美观，不拦截静态资源
我们采用第三种做为我们的拦截方案，将配置添加到web.xml中。

大家都知道，web项目最怕的就是乱码，而spring为我们提供了字符编码的过滤器，我们也给配置到web.xml中

1. <!-- 字符编码配置 -->
2. <filter>
3. <filter-name>characterEncodingFilter</filter-name>
4. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
5. <init-param>
6. <param-name>encoding</param-name>
7. <param-value>UTF-8</param-value>
8. </init-param>
9. <init-param>
10. <param-name>forceEncoding</param-name>
11. <param-value>true</param-value>
12. </init-param>
13. </filter>
14. <filter-mapping>
15. <filter-name>characterEncodingFilter</filter-name>
16. <url-pattern>/*</url-pattern>
17. </filter-mapping>

我们采用的是tomcat服务器，为了让静态的资源直接交给tomcat处理，所以我们在web.xml中配置了以下配置

1. <!-- 激活Tomcat的defaultServlet来处理静态文件 -->
2. <servlet-mapping>
3. <servlet-name>default</servlet-name>
4. <url-pattern>*.jpg</url-pattern>
5. </servlet-mapping>
6. <servlet-mapping>
7. <servlet-name>default</servlet-name>
8. <url-pattern>*.gif</url-pattern>
9. </servlet-mapping>
10. <servlet-mapping>
11. <servlet-name>default</servlet-name>
12. <url-pattern>*.png</url-pattern>
13. </servlet-mapping>
14. <servlet-mapping>
15. <servlet-name>default</servlet-name>
16. <url-pattern>*.js</url-pattern>
17. </servlet-mapping>
18. <servlet-mapping>
19. <servlet-name>default</servlet-name>
20. <url-pattern>*.css</url-pattern>
21. </servlet-mapping>

4.配置springmvc-mybatis.xml和springmvc-servlet.xml

相信很多人都在这里卡主了，因为配置实在是太多了，各种方式都有

为了不妨碍大家，我决定直接将完整的配置直接贴出来

springmvc-mybatis.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"
4. xmlns:p="http://www.springframework.org/schema/p"
5. xmlns:mvc="http://www.springframework.org/schema/mvc"
6. xmlns:context="http://www.springframework.org/schema/context"
7. xmlns:util="http://www.springframework.org/schema/util"
8. xsi:schemaLocation="http://www.springframework.org/schema/beans
9. http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
10. http://www.springframework.org/schema/context
11. http://www.springframework.org/schema/context/spring-context-4.1.xsd
12. http://www.springframework.org/schema/mvc
13. http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
14. http://www.springframework.org/schema/util
15. http://www.springframework.org/schema/util/spring-util-4.1.xsd">
16. <!-- 数据源定义-->
17. <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource">
18. <property name="driverClass" value="jdbc:mysql://127.0.0.1:3306/web" />
19. <property name="jdbcUrl" value="root" />
20. <property name="username" value="123456" />
21. <property name="password" value="com.mysql.jdbc.Driver" />
22. </bean>
23. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
24. <property name="dataSource" ref="dataSource" />
25. <property name="mapperLocations" value="classpath*:dbmap/*Mapper.xml" />
26. </bean>
27. <!-- 配置事务管理器 -->
28. <bean id="transactionManager"
29. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
30. <property name="dataSource" ref="dataSource" />
31. </bean>
32. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
33. <property name="dataSource">
34. <ref bean="dataSource" />
35. </property>
36. </bean>
37. <bean id="defaultLobHandler"
38. class="org.springframework.jdbc.support.lob.DefaultLobHandler"
39. lazy-init="true"/>
40. <!-- 查 找 类 路 径 下 的 映 射 器 并 自 动 将 它 们 创 建 成 MapperFactoryBean-->
41. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
42. <property name="basePackage" value="com.ansitech.web.orm.mapper" />
43. </bean>
44. </beans>

spring-servlet.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"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:mvc="http://www.springframework.org/schema/mvc"
6. xsi:schemaLocation="http://www.springframework.org/schema/mvc
7. http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
8. http://www.springframework.org/schema/beans
9. http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
10. http://www.springframework.org/schema/context
11. http://www.springframework.org/schema/context/spring-context-4.1.xsd">
12. <description>Spring MVC Configuration</description>
13. <!-- 对静态资源文件的访问，交给default servlet handler处理 -->
14. <mvc:default-servlet-handler/>
15. <!-- 启用spring mvc 注解 -->
16. <context:annotation-config />
17. <!-- 默认的注解映射的支持 -->
18. <mvc:annotation-driven />
19. <!-- 设置使用注解的类所在的jar包 -->
20. <context:component-scan base-package="com.ansitech.web"></context:component-scan>
21. <!-- 完成请求和注解POJO的映射 -->
22. <bean class=
23. "org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
24. <!-- JSP视图文件解析配置 -->
25. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
26. <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
27. <property name="prefix" value="/WEB-INF/view/"/>
28. <property name="suffix" value=".jsp"/>
29. <property name="viewNames" value="jsp/*"/>
30. <property name="order" value="1"/>
31. </bean>
32. <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">
33. <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
34. <property name="prefix" value="/WEB-INF/view/"/>
35. <property name="suffix" value=".jsp"/>
36. <property name="order" value="2"/>
37. </bean>
38. <!-- 上传文件拦截，设置最大上传文件大小 10M=10*1024*1024(B)=10485760 bytes -->
39. <bean id="multipartResolver"
40. class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
41. <!-- one of the properties available; the maximum file size in bytes -->
42. <property name="maxUploadSize">
43. <value>5242880</value>
44. </property>
45. </bean>
46. </beans>

web.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns="http://java.sun.com/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
6. version="3.0">
7. <!-- 程序Session配置 -->
8. <session-config>
9. <!-- Session过期时间(单位：分) -->
10. <session-timeout>30</session-timeout>
11. </session-config>
12. <!-- 激活Tomcat的defaultServlet来处理静态文件 -->
13. <servlet-mapping>
14. <servlet-name>default</servlet-name>
15. <url-pattern>*.jpg</url-pattern>
16. </servlet-mapping>
17. <servlet-mapping>
18. <servlet-name>default</servlet-name>
19. <url-pattern>*.gif</url-pattern>
20. </servlet-mapping>
21. <servlet-mapping>
22. <servlet-name>default</servlet-name>
23. <url-pattern>*.png</url-pattern>
24. </servlet-mapping>
25. <servlet-mapping>
26. <servlet-name>default</servlet-name>
27. <url-pattern>*.js</url-pattern>
28. </servlet-mapping>
29. <servlet-mapping>
30. <servlet-name>default</servlet-name>
31. <url-pattern>*.css</url-pattern>
32. </servlet-mapping>
33. <!--  Spring 上下文参数 加载Spring配置文件 -->
34. <context-param>
35. <param-name>contextConfigLocation</param-name>
36. <param-value>classpath*:xmlconfig/springmvc-mybatis.xml</param-value>
37. </context-param>
38. <listener>
39. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
40. </listener>
41. <!-- spring mvc 拦截器配置 -->
42. <servlet>
43. <servlet-name>springmvc</servlet-name>
44. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
45. <init-param>
46. <param-name>contextConfigLocation</param-name>
47. <param-value>classpath*:/xmlconfig/springmvc-servlet.xml</param-value>
48. </init-param>
49. <load-on-startup>1</load-on-startup>
50. </servlet>
51. <servlet-mapping>
52. <servlet-name>springmvc</servlet-name>
53. <url-pattern>/</url-pattern>
54. </servlet-mapping>
55. <!-- 字符编码配置 -->
56. <filter>
57. <filter-name>characterEncodingFilter</filter-name>
58. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
59. <init-param>
60. <param-name>encoding</param-name>
61. <param-value>UTF-8</param-value>
62. </init-param>
63. <init-param>
64. <param-name>forceEncoding</param-name>
65. <param-value>true</param-value>
66. </init-param>
67. </filter>
68. <filter-mapping>
69. <filter-name>characterEncodingFilter</filter-name>
70. <url-pattern>/*</url-pattern>
71. </filter-mapping>
72. <!-- 欢迎页 -->
73. <welcome-file-list>
74. <welcome-file>/index.html</welcome-file>
75. </welcome-file-list>
76. </web-app>

接下来就是包的结构了

前缀大家可以自己定义自己喜欢的，但是后边的结构，是整个框架的核心，所以请大家按照我的格式去建

前缀com.ansitech

com.ansitech.orm
com.ansitech.orm.base
com.ansitech.orm.mapper
com.ansitech.service
com.ansitech.service.po
com.ansitech.service.impl
com.ansitech.web
com.ansitech.web.controller

大家可能不理解，为什么要这么建呢？
那么我们来以用户管理模块来解释，用户对象为User
那么我们需要建立基础对象：

com.ansitech.orm.base.User.java

1. package com.ansitech.orm.base;
2. /**
3. * 用户对象
4. *
5. * @author qsyang
6. */
7. public class User {
8. private int id;
9. private String loginName;
10. private String loginPwd;
11. /**
12. * 用户类型 1 管理员 2 普通用户
13. */
14. private int typeId;
15. public int getId() {
16. return id;
17. }
18. public void setId(int id) {
19. this.id = id;
20. }
21. public String getLoginName() {
22. return loginName;
23. }
24. public void setLoginName(String loginName) {
25. this.loginName = loginName;
26. }
27. public String getLoginPwd() {
28. return loginPwd;
29. }
30. public void setLoginPwd(String loginPwd) {
31. this.loginPwd = loginPwd;
32. }
33. public int getTypeId() {
34. return typeId;
35. }
36. public void setTypeId(int typeId) {
37. this.typeId = typeId;
38. }
39. }

基础对象建好了，我们需要做一个Mapper来实现用户对象的增删改查

com.ansitech.orm.mapper.UserMapper.java

1. package com.ansitech.orm.mapper;
2. import com.ansitech.orm.base.User;
3. import org.apache.ibatis.annotations.Param;
4. /**
5. * 用户数据接口
6. *
7. * @author qsyang
8. */
9. public interface UserMapper {
10. void add(User user);
11. User get(@Param("id") int id);
12. void update(User user);
13. int delete(@Param("id") int id);
14. }

使用ORM模式，我们需要创建一个抽象的用户对象来解决额外属性查询的问题

com.ansitech.orm.AbstractUser.java

1. package com.ansitech.orm;
2. import com.ansitech.orm.base.User;
3. /**
4. * 抽象用户对象
5. *
6. * 提供其他属性获取
7. *
8. * @author qsyang
9. */
10. public abstract class AbstractUser extends User{
11. //获取当前用户所属分类名称
12. public abstract String findTypeName();
13. }

有了数据接口了，我们需要对外提供服务

com.ansitech.service.IUserService.java

1. package com.ansitech.service;
2. import com.ansitech.orm.AbstractUser;
3. import com.ansitech.orm.base.User;
4. /**
5. * 用户服务接口
6. *
7. * @author qsyang
8. */
9. public interface IUserService {
10. //添加系统管理员
11. void addSystemUser(String loginName, String loginPwd);
12. //添加普通用户
13. void addNormalUser(String loginName, String loginPwd);
14. //根据用户Id查询抽象用户
15. AbstractUser getAbstractUserById(int userId);
16. //根据用户Id查询用户
17. User getUserById(int userId);
18. //修改用户信息
19. void updateUser(int userId, String loginName, String loginPwd);
20. //根据用户Id删除用户
21. int deleteUser(int userId);
22. }

有了服务接口，就要有实现接口

com.ansitech.service.impl.UserService.java

1. package com.ansitech.service.impl;
2. import com.ansitech.orm.AbstractUser;
3. import com.ansitech.orm.base.User;
4. import com.ansitech.orm.mapper.UserMapper;
5. import com.ansitech.service.IUserService;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.stereotype.Service;
8. /**
9. * 用户接口实现类
10. *
11. * @author qsyang
12. */
13. @Service
14. public class UserService implements IUserService {
15. @Autowired
16. private UserMapper userMapper;
17. @Override
18. public void addSystemUser(String loginName, String loginPwd) {
19. User user = new User();
20. user.setLoginName(loginName);
21. user.setLoginPwd(loginPwd);
22. //用户类型 1 管理员 2 普通用户
23. user.setTypeId(1);
24. userMapper.add(null);
25. }
26. @Override
27. public void addNormalUser(String loginName, String loginPwd) {
28. User user = new User();
29. user.setLoginName(loginName);
30. user.setLoginPwd(loginPwd);
31. //用户类型 1 管理员 2 普通用户
32. user.setTypeId(2);
33. userMapper.add(null);
34. }
35. @Override
36. public AbstractUser getAbstractUserById(int userId) {
37. throw new UnsupportedOperationException("Not supported yet.");
38. }
39. @Override
40. public User getUserById(int userId) {
41. return userMapper.get(userId);
42. }
43. @Override
44. public void updateUser(int userId, String loginName, String loginPwd) {
45. //先根据用户Id查询用户对象
46. User user = userMapper.get(userId);
47. if (user != null) {
48. user.setLoginName(loginName);
49. user.setLoginPwd(loginPwd);
50. //修改用户
51. userMapper.update(user);
52. }
53. }
54. @Override
55. public int deleteUser(int userId) {
56. return userMapper.delete(userId);
57. }
58. }

细心的便宜，可能已经看到了，getAbstractUserById()这个方法我们还没有实现
因为AbstractUser还有具体的实现类，所以我们来新建实现类

1. package com.ansitech.service.po;
2. import com.ansitech.orm.AbstractUser;
3. import com.ansitech.orm.base.User;
4. import com.ansitech.service.impl.UserService;
5. /**
6. * 用户数据操作对象
7. *
8. * @author qsyang
9. */
10. public class UserPO extends AbstractUser {
11. private final UserService userService;
12. public UserPO(UserService userService) {
13. this.userService = userService;
14. }
15. public UserPO copyFrom(User obj) {
16. this.setId(obj.getId());
17. this.setLoginName(obj.getLoginName());
18. this.setLoginPwd(obj.getLoginPwd());
19. this.setTypeId(obj.getTypeId());
20. return this;
21. }
22. @Override
23. public String findTypeName() {
24. return userService.findTypeName(this.getTypeId());
25. }
26. }

对象已经创建好了，这个时候我们可以修改下service实现类的方法了，并且我们增加了一个方法
增加这个方法，只是因为我们有可能需要继续调用其他的Mapper去查询。
修改的实现方法

1. @Override
2. public AbstractUser getAbstractUserById(int userId) {
3. User user = userMapper.get(userId);
4. if (user != null) {
5. UserPO po = new UserPO(this);
6. po.copyFrom(user);
7. return po;
8. }
9. return null;
10. }

新增的方法：

1. public String findTypeName(int typeId) {
2. if (typeId == 1) {
3. return "系统管理员";
4. } else {
5. return "普通用户";
6. }
7. }

只有一来，Service架构和orm架构就已经完成了，下面只需要建立控制器就可以了

1. package com.ansitech.web.controller.user;
2. import com.ansitech.orm.base.User;
3. import com.ansitech.service.impl.UserService;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.stereotype.Controller;
6. import org.springframework.web.bind.annotation.RequestMapping;
7. /**
8. * 用户控制器
9. *
10. * @author qsyang
11. */
12. @Controller
13. public class UserController {
14. @Autowired
15. private UserService userService;
16. @RequestMapping("/user/user-index")
17. public String index() {
18. User user = userService.getUserById(1);
19. if (user != null) {
20. System.out.println("user name = " + user.getLoginName());
21. }
22. return "jsp/user/index";
23. }
24. }

大家到现在有没有理解这个架构呢？

如有疑问，请留言！
感谢您看完本篇文章，转载请注明出处。

版权声明：本文为博主原创文章，未经博主允许不得转载。