最详细的Spring +SpringMvc + MyBatis整合教程

ssm整合

构建spring基本项目

一步步来，先导入spring吧！spring没啥也就个ioc，aop，依赖注入，我们导入一个包即可实现，spring-webmvc

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>

测试也不能少

我们将dao层、service层和controller层单独分开成，最后合并到applicationContext.xml中，这里先测试spring功能是否正常，因此测试注解扫描到ioc容器中获取该类
service-config.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.yxhpy.service"/>
</beans>

测试尝试从容器中获取

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService bean = applicationContext.getBean(UserService.class);
System.out.println(bean);

到这里我们的spring就配置好了

整合mybatis到spring中

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.6</version>
</dependency>
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>2.0.6</version>
</dependency>
<dependency>
  <groupId>com.mchange</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.5.5</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.48</version>
</dependency>

dao层是从数据库里获取数据的，因此需要一个dao-config.xml，并且mybatis需要一个单独的配置文件，我们可以将其命名为mybatis-config.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


<!--    扫描所有dao的类，载入到spring容器中-->
    <context:component-scan base-package="com.yxhpy.dao"/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--    创建dataSource-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
<!--   sqlSessionFactory 用于获取sqlSession的工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
<!--    自动配置类，可以自动扫描basePackage下的包，自动将mapper接口自动代理后加载到spring中,因此很显然这一步之前我们已经把spring整合了
        可以通过ClassPathXmlApplicationContext试着获取Mapper，确实是可以在ioc容器中获取到mapper，很显然个配置已经自动帮助我们将
        mapper.xml和mapper接口实现对应的代理类了，我们还可以大胆的猜想这应该是jdk动态代理实现的，因为jdk代理就是代理的接口，而cglib则是
        通过继承类的方式来实现动态代理的
-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.yxhpy.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
</beans>

这里有mybatis的原理

这就和从ioc容器中获取bean是一样的，并且保证mapper的接口和mapper的配置，都是一一对应的，同一包下，虽然官方的导包方式有很多，但这是最方便的

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper bean = applicationContext.getBean(UserMapper.class);
System.out.println(bean.getUsers());

整合spring-mvc

mvc算是整合中最复杂的了，我们需要了解其原理

1. 用户发起请求
2. DispatcherServlet 是一个Servlet，除静态文件其他请求都可以经过这个Servlet，管理移交到spingmvc
3. 到DispathcerServlet后通过你请求的网址通过HandlerMapping来找到对应的Handler
4. Handler找到对应的HandlerAdapter
5. Handler可以认为Contrioller执行Controller
6. 返回的ModelAndView，再由ViewResolver将数据（model）填充到试图（view）中，这个view是真实的view，返回给用户
   controller-config.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: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 https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"
>

    <context:component-scan base-package="com.yxhpy.controller"/>


    <mvc:annotation-driven/>
    <mvc:default-servlet-handler/>
    <!--这一句直接代替了，HandlerMapping和HandlerAdaptor-->

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

三层的配置文件已经基本完成，现在都导入到applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:dao-config.xml"/>
    <import resource="classpath:service-config.xml"/>
    <import resource="classpath:controller-config.xml"/>
</beans>

最后将所有请求移交dispatcherServlet,配置web.xml


这里就是为啥创建空maven项目的原因了，这里可以直接选择最新版本

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--    将所有请求移交dispatcherServlet管理-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
<!--        设置 / 防止文件请求走这个Servlet-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

你可能遇到的问题，很多问题复现麻烦就不多说了

1. 整合之前需对流程有一定的了解，如springmvc基本流程
2. mvc无法正常访问不是404就是500
3. 编码问题，需要使用filter,将编码设置为utf-8, web.xml中添加

<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

4. fastjson返回的json数据乱码,使用 produces

@Controller
public class UserController {
    @Autowired
    UserService userService;

    @RequestMapping(value = "/user/all", produces = {"application/json;charset=utf-8"})
    @ResponseBody
    public String getUsers(){
        return JSON.toJSONString(userService.getUsers());
    }
}

很显然这种方法，没有通用性,可以在controller-config.xml加上

<mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
<!--            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">-->
<!--                <property name="objectMapper">-->
<!--                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">-->
<!--                        <property name="failOnEmptyBeans" value="false"/>-->
<!--                    </bean>-->
<!--                </property>-->
<!--            </bean>-->
     </mvc:message-converters>
 </mvc:annotation-driven>

如果你使用的jackson去掉注释，如果使用fastjson请去掉上面的注释
5. 项目无法正常运行，可能是这里的问题

总结

总的来说，只要将框架的具体原理了解，进行整合则没啥大问题，推荐狂神的视频，我也是二刷背诵整合的，虽然已经有很多现成的整合了，但是总是cv让我不是很自在，哈哈，这可能是优点，但也可能是缺点吧！！

• 有什么问题欢迎提出