不会，所以花了一段时间，学习了mybatis spring又进行了整合，后来又学习springmvc算是都看了看，今天就把整个搭建好的框架整理一下，和大家分享，如果错误希望指正……
2、整个项目的目录结构：
3、有了整体结构之后我们一步一步整合来实现，整合步骤：
（1）、配置前端控制器,web.xml配置
（2）、创建处理映射器 springmvc-server.xml 配置
（3）、创建控制层
（4）、业务逻辑层
（5）、dao层
（6）、sqlmapper 映射文件
（7）、spring+mybatis 整合配置文件即spring.xml 配置文件
4、具体实现
<?xmlversion="1.0" encoding="UTF-8"?>
<web-appxmlns:xsi=""
xmlns=""
xmlns:web=""
xsi:schemaLocation="://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"id="WebApp_ID" version="3.0">
<display-name>FinalTestO</display-name>
<!– 加载spring容器配置 –>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!– 设置Spring容器加载配置文件路径 –>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:config/springmvc-servlet.xml,
classpath:config/ApplicationContext.xml
</param-value>
</context-param>
<!– 过滤器就是请求到达web资源之前 获取请求信息并进行处理，之后继续向后执行 –>
<!– 字符编码过滤器 –>
<filter>
<filter-name>encodingFilter</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>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
<!– 前端控制器 –>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:config/springmvc-servlet.xml</param-value>
</init-param>
<!– 这个配置文件在容器启动的时候 就加载 –>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!– 拦截请求 –>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
（2）、创建映射处理器
<?xmlversion="1.0" encoding="UTF-8"?>
<beans
xmlns=""
xmlns:xsi=""
xmlns:aop=""
xmlns:context=""
xmlns:mvc=""
xmlns:util=""
xmlns:tx=""
xmlns:jdbc=""
xmlns:cache=""
xsi:schemaLocation="
://www.springframework.org/schema/beans/spring-beans-3.1.xsd
://www.springframework.org/schema/aop/spring-aop-3.1.xsd
://www.springframework.org/schema/context/spring-context-3.1.xsd
://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
://www.springframework.org/schema/util/spring-util-3.1.xsd
://www.springframework.org/schema/tx/spring-tx-3.1.xsd
://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
">
<!– 注解驱动–>
<mvc:annotation-driven/>
<!–<context:annotation-config/> –>
<!– 扫描 ，这里使用了注解方式实现，所以会扫描指定的路径下的文件–>
<context:component-scanbase-package="com.inspur.action"></context:component-scan>
<!–视图解析器 –>
<beanid="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix"value="/WEB-INF/view/"> </property>
<propertyname="suffix"value=".jsp"></property>
</bean>
</beans>
（3）、控制层，也就是映射处理器将请求映射到控制层的某个具体的方法上。
packagecom.inspur.action;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Controller;
importorg.springframework.web.bind.annotation.RequestMapping;
importcom.inspur.po.User;
importcom.inspur.service.UserService;
/**
*@author WHD
*2015-3-18
*/
/*
* 这里实现控制层的方式有多种，一般有extendsabstractController 以及implements Controller这个接口
* 但是在平时的项目中使用的都是这个注解方式实现，
*所以这里也就使用了注解的方式,使用Controller 就说明这就是控制器
*/
@Controller
/**
* 这里的RequestMapping 可以在类上也可以不再类上，如果在类上则完整的请求路劲就是类+方法
*/
@RequestMapping(value="/user")
public classUserController {
/**
* 自动注入业务逻辑层，注入方式使用了注解自动注入
*/
@Autowired
private UserServiceuserService;
/**
* 添加用户信息
*/
/* 增加 */
@RequestMapping(value="/save.do")
public Stringinsert(Integer id ,String name,String sex,User user){
Map<String,Object>map= new HashMap<String,Object>();
map.put("id",user.getId());
map.put("name",user.getName());
map.put("sex",user.getSex());
userService.saveUser(map);
System.out.println("ok");
return"index";
}
/**删除
*
*/
@RequestMapping(value="/delete.do")
public String delete(Integer id){
userService.delUser(id);
return"index";
}
/**
* 修改用户信息
*/
@RequestMapping(value="/update.do")
public Stringupdate(User user){
Map<String,Object>map= new HashMap<String,Object>();
map.put("id",user.getId());
map.put("name",user.getName());
map.put("sex",user.getSex());
userService.updateUser(map);
return"index";
}
/**
* 查询用户信息
*/
@RequestMapping(value="/select.do")
public Stringselect(Integer id,Map<String,Object> map){
List<Map<String,Object>>list= newArrayList<Map<String,Object>>();
list=userService.selectUser(id);
map.put("mylist",list);
return"list";
}
}
（4）、业务逻辑层
packagecom.inspur.service;
importjava.util.List;
importjava.util.Map;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Service;
importorg.springframework.transaction.annotation.Transactional;
importcom.inspur.dao.UserDao;
/**
*@author WHD
*2015-3-18
*/
/**
* 这个service注解说明就是一个业务逻辑层，里面的值可有可无
*/
@Service("userService")
/**
* transactional 这个注解就是使用注解的方式实现事务
*/
@Transactional
public classUserService {
/**
*自动注入dao层
*/
@Autowired
private UserDao userDao;
/**保存用户信息
* @param map
*/
publicvoid saveUser(Map<String, Object> map) {
//TODO Auto-generated method stub
userDao.saveUser(map);
}
/**
*删除user
* @param id
*/
publicvoid delUser(Integer id) {
userDao.delUser(id);
}
/**
* 编辑用户信息
* @param map
*/
publicvoid updateUser(Map<String, Object> map) {
userDao.updateUser(map);
}
/**
* 查询信息
* @param id
*/
publicList<Map<String,Object>> selectUser(Integer id) {
returnuserDao.selectUser(id);
}
}
(5)、dao层
packagecom.inspur.dao;
importjava.util.List;
importjava.util.Map;
importorg.mybatis.spring.SqlSessionTemplate;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Repository;
/**
*@author WHD
*2015-3-18
*/
/**
* repository 说明就是一个dao层的注解
*/
@Repository("userDao")
public class UserDao{
/**
*自动注入这里spring管理了mybatis的sqlsessionfactory
*/
@Autowired
privateSqlSessionTemplate sqlSession;
/**
* 保存用户信息
* @param map
*/
publicvoid saveUser(Map<String, Object> map) {
sqlSession.insert("com.inspur.userMapper.insertUserMap",map);
}
/**
* 删除用户
* @param id
*/
publicvoid delUser(Integer id) {
sqlSession.delete("com.inspur.userMapper.delUser",id);
}
/**
* 修改用户信息
* @param map
*/
publicvoid updateUser(Map<String, Object> map) {
sqlSession.update("com.inspur.userMapper.updateUser",map);
}
/**
* 查询用户信息
* @param id
* @return
*/
publicList<Map<String, Object>> selectUser(Integer id) {
returnsqlSession.selectList("com.inspur.userMapper.selectUser", id) ;
}
}
（6）、sqlmapper 映射文件
<?xmlversion="1.0" encoding="UTF-8" ?>
<!DOCTYPEmapper PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"
"">
<!–这个namespace + 下面的id 就是一个完整的路径，在dao层我们写了完整的路径之后mybatis就是映射这个文件中的相关sql语句 –>
<mappernamespace="com.inspur.userMapper">
<!– parameterType就是你接受的参数的类型， –>
<!– 添加用户信息 –>
<insertid="insertUserMap"parameterType="java.util.Map">
insertinto mytest(id,name,sex) values(#{id},#{name},#{sex})
</insert>
<deleteid="delUser" parameterType="int">
deletefrom mytest where id=#{id}
</delete>
<updateid="updateUser" parameterType="java.util.Map">
update mytest setname=#{name},sex=#{sex} where id=#{id}
</update>
<!– 查询返回的是 list<map> –>
<!– resultType 就是返回查询结果的类型，而如果是resultMap=则返回的就是你定义的javabean –>
<select id="selectUser" parameterType="int"resultType="java.util.Map">
selectid ,name,sex from mytest where id=#{id}
</select>
</mapper>
（7）、spring+mybatis 配置文件
<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns=""
xmlns:xsi=""
xmlns:tx=""
xmlns:context=""
xsi:schemaLocation="://www.springframework.org/schema/beans/spring-beans-3.2.xsd
">
<!– 加载配置JDBC文件 –>
<context:property-placeholderlocation="classpath:datasource.properties" />
<!– 数据源–>
<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<propertyname="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>
</bean>
<!– 下面这两个开启了自动扫描功能 –>
<!– 开启注解配置 即Autowried –>
<context:annotation-config/>
<!– 使用自动注入的时候要 添加他来扫描bean之后才能在使用的时候 –>
<context:component-scanbase-package="com.inspur.service ,com.inspur.dao"/>
<!– 添加事务的控制–>
<tx:annotation-driventransaction-manager="transactionManager" />
<!– 在使用mybatis时 spring使用sqlsessionFactoryBean来管理mybatis的sqlsessionFactory–>
<!– 而像这种使用接口实现的方式 是使用sqlsessionTemplate来进行操作的，他提供了一些方法 –>
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource"ref="dataSource"/>
<!– mybatis配置文件路径–>
<propertyname="configLocation"value=""/>
<!– 实体类映射文件路径–>
<propertyname="mapperLocations"value="classpath:mybatis/UserMapper.xml"/>
</bean>
<!– 配置sqlsession 产生这个实例就是通过 sqlsessionTemplate来实现的 –>
<bean id="sqlSession"class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0">
<refbean="sqlSessionFactory"/>
</constructor-arg>
</bean>
<!– 事务 需要三件事才可以 一具体的事务实现着 二事务管理器 三 aop 事务控制 不起作用–>
<!– 这里使用 全注释 事务 –>
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource" ref="dataSource" />
</bean>
</beans>
Ok 到这里主要的配置文件以及 代码都有了，如果还有什么不清楚的可以下载演示源码看看，，如有错误请 指正谢谢！
演示源码下载：
也只有懂的接受自己的失败，才能更好的去发挥自身优势，也才能够更好的去实现自我;
