开发环境
- 开发工具: eclipse Mars4.5
- 数据库: mysql5.0
- JDK: 1.7
- spring: 4.0
- mybatis: 3.2
- maven: 3.3
maven集成配置
新版的eclipse都已经集成了maven插件，但由于天朝的原因，很多时候下载jar包的时候都会很慢，所以建议到maven官网下载，然后更改eclipse里面的maven配置，替换默认的settings.xml文件为下载后的maven(这个文件在maven的conf目录下)
接着我们更改下这个settings.xml文件的配置，主要是配置国内镜像地址以及仓库的地址，第53行附近设置自己的仓库地址
第152行附近设置国内镜像地址，这里我使用的是开源中国的镜像地址
1 | <mirror> |
到这里我们的maven配置就已经完成了，有点麻烦，但真的是很值得的^^
创建maven项目
依次选择file/new/other，搜索栏输入maven，然后选择里面的Maven Project，点击next
选中里面的create a simple project选项（这里我没有去搜索一些官网提供的项目模板，一来是加载速度慢，而来不利于我们的理解），点击next
这里开始设置一些maven相关的配置了，首先Group Id 设置公司组织的名称，这个就随便了，Artifact Id 这是项目的名称，同时这个也是在eclipse里面的项目名称，Packaging 里面选择war类型(作为一个web项目打包)，点击finish则完成了maven项目的创建
maven项目架构
接下来让我们一起看看我们创建的maven项目的架构组成
- src/main/java: 存放java源代码文件
- src/main/resources: 存放生产环境的配置文件，如jdbc文件
- src/test/java: 存放java测试文件，如单元测试代码
- src/test/resources: 存放测试环境的配置文件
- src: 项目根路径
- target: 项目运行生成的目标文件，比如打包项目
- pom.xml: maven的配置文件，主要用于jar包管理以及常用的插件配置(比如tomcat插件)
maven pom.xml配置文件
首先我们来看看pom.xml这个文件，里面只有一些简单的介绍信息，
2
3
4
5
6
7
8
9
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>distinct.com</groupId>
<artifactId>spring-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
</project>我们先来设置我们的JDK版本(这里我用的是1.7)，在跟元素下面创建build元素，然后里面创建plugins元素，接着在里面创建一个plugin元素(可以理解为一个maven插件)，这个插件用于设置项目的JDK版本
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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>distinct.com</groupId>
<artifactId>spring-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<build>
<plugins>
<!-- JDK level -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>我们再来创建一个tomcat的插件，这样好处在于我们不再需要配置tomcat的服务器，而直接使用maven的插件来运行我们的项目
2
3
4
5
6
7
8
9
10
11
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.1</version>
<configuration>
<port>8080</port>
<uriEncoding>UTF-8</uriEncoding>
<server>tomcat7</server>
</configuration>
</plugin>插件讲到这里，我们再来说说maven是怎么管理jar包的(这也是maven最优秀的地方了)，maven主要通过3个元素管理jar包
- properties: 设置一些版本号，统一引用，比如spring版本号
- dependencies: jar包依赖表
dependency: 某个依赖jar包
举个引入spring-core这个jar包的例子：
1 | <properties> |
到这里pom.xml文件的内容就讲完了，最后我先把spring整合mybatis的所需要的jar包先写出来
1 | <project xmlns="http://maven.apache.org/POM/4.0.0" |
spring，mybatis配置
接着我们来说说spring如何整合mybatis的，首先我们先来看看需要用到的配置文件(config文件夹)有那些
- jdbc.properties: 数据库配置文件
- log4j.properties: 日志配置文件
- spring-context.xml: spring应用上下文文件，主要用于引入properties文件以及包含其他xml配置文件
- spring-mvc.xml: springMVC配置文件
- spring-mybatis.xml: mybatis配置文件
jdbc文件,主要配置数据库地址、账号、密码
2
3
4
jdbc_url=jdbc:mysql://127.0.0.1:3306/db_test?useUnicode=true&characterEncoding=utf8
jdbc_username=root
jdbc_password=123456log4j文件，配置日志打印信息，其中12行配置DEBUG模式日志文件路径，19行配置ERROR模式日志文件路径
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#log4j.rootLogger = debug , stdout , D , E
log4j.rootLogger = debug , stdout , D
### output to the console ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
#log4j.appender.stdout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c{ 1 }:%L - %m%n
log4j.appender.stdout.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
### Output to the log file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ${spring-mybatis.root}/WEB-INF/logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
### Save exception information to separate file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ${spring-mybatis.root}/WEB-INF/logs/error.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = ERROR
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%nspring-context文件，主要用于引入jdbc、springMVC、mybatis文件，其中第11行的包名用于注入spring的bean
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
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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">
<context:component-scan base-package="com.spring.mybatis"/>
<!-- 自动注入properties属性文件 -->
<bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>classpath:conf/jdbc.properties</value>
</list>
</property>
</bean>
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
<property name="properties" ref="configProperties" />
</bean>
<import resource="spring-mvc.xml"/>
<import resource="spring-mybatis.xml"/>
</beans>spring-mvc文件，17行的bean用于配置json数据编码，41行用于启用mvc注解，44行的bean用于配置项目jsp的前缀、后缀路径
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
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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.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">
<!-- handle the json -->
<bean
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean
class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/plain;charset=UTF-8</value>
</list>
</property>
</bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>application/json;charset=UTF-8</value>
</list>
</property>
</bean>
</list>
</property>
</bean>
<!-- the HandlerAdapter must before the mvc driven -->
<mvc:annotation-driven />
<!-- match the jsp view -->
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix="/jsp/" p:suffix=".jsp" />
</beans>spring-mybatis文件，12行的bean用于配置数据库的数据源，也就是配置数据库的地址、账号、密码，它们的值引用于jdbc.properties文件；61行的bean用于扫描mybatis的mapper文件(也就是我们写sql的xml文件)，64行的bean扫描mybatis的接口文件，也就是说这两个bean将我们定义的接口文件跟xml文件联系起来，其中需要注意他们的路径的定义；67行的bean用于配置事务管理器
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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">
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
<property name="driverClassName">
<value>${jdbc_driverClassName}</value>
</property>
<property name="url">
<value>${jdbc_url}</value>
</property>
<property name="username">
<value>${jdbc_username}</value>
</property>
<property name="password">
<value>${jdbc_password}</value>
</property>
<!-- 连接池最大使用连接数 -->
<property name="maxActive">
<value>20</value>
</property>
<!-- 初始化连接大小 -->
<property name="initialSize">
<value>1</value>
</property>
<!-- 获取连接最大等待时间 -->
<property name="maxWait">
<value>60000</value>
</property>
<!-- 连接池最大空闲 -->
<property name="maxIdle">
<value>20</value>
</property>
<!-- 连接池最小空闲 -->
<property name="minIdle">
<value>3</value>
</property>
<!-- 自动清除无用连接 -->
<property name="removeAbandoned">
<value>true</value>
</property>
<!-- 清除无用连接的等待时间 -->
<property name="removeAbandonedTimeout">
<value>180</value>
</property>
<!-- 连接属性 -->
<property name="connectionProperties">
<value>clientEncoding=UTF-8</value>
</property>
</bean>
<!-- mybatis文件配置，扫描所有mapper文件 -->
<!-- configLocation为mybatis属性 mapperLocations为所有mapper -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
p:dataSource-ref="dataSource" p:mapperLocations="classpath:mapper/*.xml" />
<!-- spring与mybatis整合配置，扫描所有dao -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
p:basePackage="com.spring.mybatis.dao" p:sqlSessionFactoryBeanName="sqlSessionFactory" />
<!-- 对数据源进行事务管理 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource" />
</beans>上面几个都是跟spring整个相关的配置文件，接着我们说下web.xml这个配置文件，首先我们创建的这个maven项目默认是没有创建web.xml这个文件的，我们需要在根目录src中的webapp目录下创建WEB-INF文件夹，然后需要在这个文件下创建web.xml
其中web.xml代码如下，16行引入spring的配置文件，20行引入日志配置文件，26行的过滤器用于设置请求的编码，42行设置spring监听器，用于启动spring容器，46行的servlet设置springMVC的前端拦截器DispatcherServlet，59行设置springMVC拦截请求的形式(以.do结尾的请求)，70行设置jsp的配置信息
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:jsp="http://java.sun.com/xml/ns/javaee/jsp"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>spring-mybatis</display-name>
<context-param>
<param-name>webAppRootKey</param-name>
<param-value>spring-mybatis.root</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:conf/spring-context.xml</param-value>
</context-param>
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:conf/log4j.properties</param-value>
</context-param>
<context-param>
<param-name>log4jRefreshInterval</param-name>
<param-value>6000</param-value>
</context-param>
<filter>
<filter-name>SpringEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>SpringEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value></param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/index</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>60</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index</welcome-file>
</welcome-file-list>
<jsp-config>
<jsp-property-group>
<description>every jsp page use the jstl tag</description>
<url-pattern>*.jsp</url-pattern>
<include-prelude>/common/lib.jsp</include-prelude>
</jsp-property-group>
</jsp-config>
</web-app>lib.jsp代码为，主要是用来设置统一的el函数标签，项目的上下文路径ctx
2
3
4
5
6
7
<%@ page trimDirectiveWhitespaces="true"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<c:set var="ctx" value="<%=request.getContextPath() %>" />接着再说下另外两个文件UserMapper.xml、generateUser.xml，其中后者是通过使用mybatis生成器插件为我们生成一套常用的文件的，这里展开来说一下，mybatis生成器的使用情景是这样的: 我们先在数据库中建好相关的表，然后通过配置生成器直接生成我们需要的POJO实体类、常用的查询语句接口以及其对应的xml文件
也就是说通过使用generateUser.xml这个文件，可以帮我们去生成dao、model、mapper里面的文件，这样很大程度上减少了我们的工作量，那么让我们来研究一下这个mybatis生成器是怎么工作的，首先需要配置生成器的maven插件，需要在pom.xml配置(前面贴出的代码已经含有)，其中7行用于配置需要用到的生成文件，也就是generateUser.xml
2
3
4
5
6
7
8
9
10
11
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.1</version>
<configuration>
<configurationFile>${basedir}/src/main/resources/mybatis/generateUser.xml</configurationFile>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>接着还需要在properties元素用添加一些信息，包括MySQL的jar包(注意要改成你自己的路径)、数据库地址、账号、密码，以及生成文件所存放的路径
2
3
4
5
6
7
8
9
<classPathEntry.location>C:/Users/admin/.m2/repository/mysql/mysql-connector-java/5.1.30/mysql-connector-java-5.1.30.jar</classPathEntry.location>
<jdbc.driverClass>com.mysql.jdbc.Driver</jdbc.driverClass>
<jdbc.connectionURL>jdbc:mysql://127.0.0.1:3306/db_test</jdbc.connectionURL>
<jdbc.user>root</jdbc.user>
<jdbc.password>123456</jdbc.password>
<model.target.dir>${basedir}/src/main/java</model.target.dir>
<mapper.target.dir>${basedir}/src/main/resources</mapper.target.dir>
<dao.target.dir>${basedir}/src/main/java</dao.target.dir>然后在让我们来看一下generateUser.xml这个文件，请注意里面所引用的值，这些值都是我们在pom.xml中的properties元素中定义好的，29行用于配置我们需要的数据库表，这里我已经在数据库中新建了一张t_user的表，里面含有3个字段id、useranme、userpwd，
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
<generatorConfiguration>
<classPathEntry location="${classPathEntry.location}" />
<context id="context">
<commentGenerator>
<property name="suppressAllComments" value="true" />
<property name="suppressDate" value="true" />
</commentGenerator>
<!-- jdbc连接信息 -->
<jdbcConnection driverClass="${jdbc.driverClass}"
connectionURL="${jdbc.connectionURL}" userId="${jdbc.user}" password="${jdbc.password}" />
<!-- 生成对象 -->
<javaModelGenerator targetProject="${model.target.dir}" targetPackage="com.spring.mybatis.model">
<property name="enableSubPackages" value="true" />
</javaModelGenerator>
<!-- 生成用于查询的Example对象 -->
<sqlMapGenerator targetProject="${mapper.target.dir}" targetPackage="mapper">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- 生成DAO的类文件以及配置文件 -->
<javaClientGenerator targetProject="${dao.target.dir}" targetPackage="com.spring.mybatis.dao"
type="XMLMAPPER">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 想要生成的数据库表,自动化工具会根据该表的结构生成相应的vo对象 -->
<table tableName="t_user" domainObjectName="User">
<generatedKey column="id" sqlStatement="MySql" identity="true" />
</table>
</context>
</generatorConfiguration>到这里生成器的配置已经完成了，接着我们需要调用maven的命令，选中项目->右键点击->选中Run As->选中Maven build…(记着是有…的)
在Goals框中输入 mybatis-generator:generate 命令，点击Run运行，接着eclipse会自动去下载所需要的插件跟jar包(这个过程可能需要几分钟，如果报错，可能是你eclipse本身的JDK没有设置好)，成功后就会生成上面提到的那几个文件，到这里spring-mybatis的整合就已经完成^^
验证
最后我们需要去验证我们的框架是否已经搭建成功，首先我们需要建立一个常规的三层架构也就是controller、service、dao(请参考上图的项目路径)，其中UserController代码如下
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
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import com.spring.mybatis.model.User;
import com.spring.mybatis.service.UserService;
public class UserController {
private static final Logger logger = LoggerFactory.getLogger(UserController.class);
private UserService userService;
("/userTest")
public String userTest(Model model){
User user = new User();
user.setUsername("coderhuang");
user.setUserpwd("123456");
userService.addUser(user);
logger.info("插入用户id:" + user.getId());
user = userService.getUser(user.getId());
model.addAttribute("user", user);
return "user";
}
}UserService接口代码为：
2
3
4
5
6
7
8
9
10
11
import com.spring.mybatis.model.User;
public interface UserService {
User getUser(int userId);
void addUser(User user);
void deleteUser(int userId);
void updateUser(User user);
}其实现类UserServiceImpl代码为
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
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.spring.mybatis.dao.UserMapper;
import com.spring.mybatis.model.User;
import com.spring.mybatis.service.UserService;
public class UserServiceImpl implements UserService {
private UserMapper userMapper;
public User getUser(int userId) {
return userMapper.selectByPrimaryKey(userId);
}
public void addUser(User user) {
userMapper.insert(user);
}
public void deleteUser(int userId) {
userMapper.deleteByPrimaryKey(userId);
}
public void updateUser(User user) {
userMapper.updateByPrimaryKeySelective(user);
}
}其实他们之间关系就是controller层调用service层的接口，而service层则去调用dao层的接口，而接口对应的实现类则是通过spring框架注入，接着我们需要启动我们的项目，这里用到前面所说到的tomcat插件去运行我们的项目，选中项目->右键点击->选中Run As->选中Maven build…(记着是有…的)，在Goals框中输入 tomcat7:run 命令启动我们的项目(虽然是这样，但是这个过程肯定会出现各种问题的，而这些问题则是需要你们自己去解决了^^)，成功后，在浏览器(这里建议用chrome)地址栏输入: localhost:8080/spring-mybatis/userTest.do 后台有打印出相关数据的话就说明成功了
总结
这个项目的源代码已经共享在GitHub上面了，请自行下载，概括起来说，使用maven搭建spring-mybatis的项目，先抛开spring框架，一个maven项目其实只有一个src文件夹跟一个pom.xml文件，然后对应spring跟mybatis的整合，流程大概就是：配置jdbc、log4j文件->配置spring-MVC文件->配置spring-mybatis文件->配置spring-context文件，将前面的文件都整合进来，然后放在web.xml文件中。