springmvc+spring+mybatis 整合

最新推荐文章于 2024-08-17 14:33:30 发布

bit-caffe

最新推荐文章于 2024-08-17 14:33:30 发布

阅读量1.9w

点赞数 7

分类专栏： spring

本文链接：https://blog.csdn.net/qh_java/article/details/44559005

版权

spring 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、以前ssm不会，所以花了一段时间，学习了mybatis spring又进行了整合，后来又学习springmvc算是都看了看，今天就把整个搭建好的框架整理一下，和大家分享，如果错误希望指正……

2、整个项目的目录结构：

3、有了整体结构之后我们一步一步整合来实现，整合步骤：

（1）、配置前端控制器,web.xml配置

（2）、创建处理映射器 springmvc-server.xml 配置

（3）、创建控制层

（4）、业务逻辑层

（5）、dao层

（6）、sqlmapper 映射文件

（7）、spring+mybatis 整合配置文件即spring.xml 配置文件

4、具体实现

（1）、web.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app 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"
	id="WebApp_ID" version="3.0">
	<display-name>website2</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>
	<!-- 字符编码过滤器 -->
	<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.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>default.jsp</welcome-file>
	</welcome-file-list>
</web-app>

（2）、创建映射处理器：springmvc-server.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<beans 
	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:mvc="http://www.springframework.org/schema/mvc" 
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
		http://www.springframework.org/schema/cache  http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">
	
	<!-- 注解驱动 -->
	<mvc:annotation-driven/> 
<!-- 	<context:annotation-config />  --> 
<!-- context:component-scan 具有annotation-config 的功能 -->
	<!-- 扫描 -->
	<context:component-scan  base-package="com.inspur.action"></context:component-scan>
	
	<!--  视图解析器 -->
	<bean id="viewResolver"  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property  name="prefix" value="/WEB-INF/view/"> </property>
	<property name="suffix"  value=".jsp"></property>
	</bean>

</beans>

<context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan base-package="xxx.xxx.xxx"/> 后，就可以将 <context:annotation-config/> 移除了。

（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
 */
/*
 * 这里实现控制层的方式有多种，一般有extends abstractController 以及implements  Controller这个接口
 * 但是在平时的项目中使用的都是这个注解方式实现，
 *所以这里也就使用了注解的方式,使用Controller 就说明这就是控制器
 */
@Controller
/**
 * 这里的RequestMapping 可以在类上也可以不再类上，如果在类上则完整的请求路劲就是类+方法
 */
@RequestMapping(value="/user")
public classUserController {
/**
 * 自动注入业务逻辑层，注入方式使用了注解自动注入
 */
 
@Autowired
private UserService userService;
 
/**
 * 添加用户信息
 */
/*  增加 */
@RequestMapping(value="/save.do")
public String insert(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 String update(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 String select(Integer id,Map<String,Object> map){
List<Map<String,Object>>list= new ArrayList<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
 */
public void saveUser(Map<String, Object> map) {
//TODO Auto-generated method stub
userDao.saveUser(map);
}
 
/**
 *删除user
 * @param id
 */
public void delUser(Integer id) {
userDao.delUser(id);
}
 
/**
 * 编辑用户信息
 * @param map
 */
public void updateUser(Map<String, Object> map) {
 userDao.updateUser(map);
}
 
/**
 * 查询信息
 * @param id
 */
public List<Map<String,Object>> selectUser(Integer id) {
       return userDao.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
private SqlSessionTemplate sqlSession;
 
/**
 * 保存用户信息
 * @param map
 */
publicvoid saveUser(Map<String, Object> map) {
sqlSession.insert("com.inspur.userMapper.insertUserMap",map);
}
 
/**
 * 删除用户
 * @param id
 */
public void delUser(Integer id) {
sqlSession.delete("com.inspur.userMapper.delUser",id);
}
/**
 * 修改用户信息
 * @param map
 */
public void updateUser(Map<String, Object> map) {
sqlSession.update("com.inspur.userMapper.updateUser",map);
}
/**
 * 查询用户信息
 * @param id
 * @return
 */
public List<Map<String, Object>> selectUser(Integer id) {
return sqlSession.selectList("com.inspur.userMapper.selectUser", id) ;
}
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

（6）、mybatis sqlmapper 映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <!--这个namespace + 下面的id 就是一个完整的路径，在dao层我们写了完整的路径之后mybatis就是映射这个文件中的相关sql语句 -->
<mapper namespace="com.inspur.userMapper">
<!-- parameterType就是你接受的参数的类型，  -->
<!-- 添加用户信息 -->
<insert id="insertUserMap"  parameterType="java.util.Map">
 insert  into  mytest(id,name,sex)  values(#{id},#{name},#{sex})
</insert>

<delete id="delUser" parameterType="int">
 delete  from  mytest where id=#{id}
</delete>

<update id="updateUser" parameterType="java.util.Map">
update mytest set name=#{name},sex=#{sex} where id=#{id}
</update>

<!--  查询返回的是 list<map> -->
<!-- resultType 就是返回查询结果的类型，而如果是resultMap=则返回的就是你定义的javabean  -->
<select  id="selectUser"  parameterType="int" resultType="java.util.Map">
  select  id ,name,sex from mytest where id=#{id}
</select>

</mapper>

（7）、ApplicationContext 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans 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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
				http://www.springframework.org/schema/context
				 http://www.springframework.org/schema/context/spring-context-3.2.xsd
				http://www.springframework.org/schema/tx 
				http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
    
    <!-- 加载配置JDBC文件 -->
	<context:property-placeholder location="classpath:datasource.properties" />
	<!-- 数据源 -->
    <bean id="dataSource"  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <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>
    </bean>
    
     <!-- 下面这两个开启了自动扫描功能 -->
      <!-- 开启注解配置 即Autowried -->  
  <!--   <context:annotation-config/>   -->
    <!--    使用自动注入的时候要  添加他来扫描bean之后才能在使用的时候   -->
	   <!--其实component-scan 就有了annotation-config的功能即把需要的类注册到了spring容器中-->
    <context:component-scan base-package="com.inspur.service ,com.inspur.dao"/>  
    <!-- 在使用mybatis时 spring使用sqlsessionFactoryBean 来管理mybatis的sqlsessionFactory-->
    <!-- 而像这种使用接口实现的方式 是使用sqlsessionTemplate来进行操作的，他提供了一些方法 -->
    <bean id="sqlSessionFactory"  class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!-- mybatis配置文件路径-->
    <property name="configLocation"  value=""/>   
    <!-- 实体类映射文件路径-->
     <property name="mapperLocations" value="classpath:mybatis/UserMapper.xml"/> 
    </bean>
    <!-- 配置sqlsession 产生这个实例就是通过 sqlsessionTemplate来实现的 -->    
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0">
    <ref  bean="sqlSessionFactory"/>
    </constructor-arg>
    </bean>
    <!-- 事务 需要三件事才可以  一具体的事务实现着  二事务管理器  三  aop 事务控制  不起作用-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    
        <property name="dataSource" ref="dataSource" />    
    </bean>
   <!-- 使用全注释事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

多个映射文件使用*来替代

 <bean id="sqlSessionFactory"  class="org.mybatis.spring.SqlSessionFactoryBean">  
    <property name="dataSource" ref="dataSource"/>  
    <!-- mybatis配置文件路径-->  
    <property name="configLocation"  value=""/>     
    <!-- 实体类映射文件路径,如果映射文件比较多的话可以这样写(*)来替代-->  
     <property name="mapperLocations" value="classpath:mybatis/*.xml"/>   
    </bean>

Ok 到这里主要的配置文件以及代码都有了，如果还有什么不清楚的可以下载演示源码看看，如有错误请指正谢谢！

演示源码下载：http://download.csdn.net/detail/qh_java/8524235

5、annotation-config,annotation-driven,compont-scan 的区别

（1）、<context:annotation-config/>
隐式地向Spring容器中注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 及 RequiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor
对这个结果类做个解释：
1、如果你想使用@Autowired注解，那么就必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。
2、如果想使用@ Resource 、@ PostConstruct、@ PreDestroy等注解就必须声明CommonAnnotationBeanPostProcessor。
3、如果想使用@PersistenceContext注解，就必须声明PersistenceAnnotationBeanPostProcessor的Bean。
4、如果想使用 @Required的注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean。

4个类的传统注入方式：

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/> 
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/> 
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/> 
<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor"/>

一般来说，这些注解我们还是比较常用，尤其是Antowired的注解，在自动注入的时候更是经常使用，所以如果总是需要按照传统的方式一条一条配置显得有些繁琐和没有必要，于是spring给我们提供 <context:annotation-config> 的简化配置方式，自动帮你完成声明。

（2）、<context:component-scan/>
<context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan base-package="xxx.xxx.xxx"/> 后，就可以将<context:annotation-config/> 移除了。

（3）、<mvc:annotation-driven/>

相当于注册了DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter两个bean，配置一些messageconverter。即解决了@Controller注解的使用前提配置。

这也是spring3.0中新增加的。