SpringMVC_SSM整合_springmvc整合的ssm-优快云博客

本文链接：https://blog.youkuaiyun.com/Running_lemon/article/details/104447994

本文详细介绍了SpringMVC_SSM框架的整合步骤，包括环境搭建、各组件配置、整合测试及最终的SSM整合验证，适合初学者快速掌握SSM框架的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SpringMVC_SSM整合

针对之前的学习，进行SSM整合，然后结合做过的项目，熟悉整个过程。

SSM整合思路

选择XML + 注解的方式进行SSM框架整合

第一步：先搭建整合的环境；

1，创建SSM项目对应的数据库以及表结构；
2，创建Maven结构的工程；
3，在pom.xml中引入对应的坐标依赖；
4，部署ssm项目（只要把ssm项目加入Tomcat服务器即可）；
5，编写实体类；
6，编写业务层service接口以及实现类；
7，编写持久层dao接口；

注意点： MyBatis会根据dao接口自动生成代理对象，所以dao不需要编写实体类；

第二步：搭建Spring框架；

1，创建Spring框架的配置文件applicationContext.xml，导入约束，并编写具体的配置信息：

  <!--Spring框架开启注解扫描,只处理service和dao-->
    <context:component-scan base-package="com.yp">

        <!--Spring框架的配置文件不扫描表现层controller,交由springmvc框架处理-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
    </context:component-scan>

2，使用注解配置业务层和持久层：@Service注解配置业务层实现类，@Repository注解配置持久层接口；

3，测试 spring 能否独立运行：

 @Test
    public void springTest(){
    
        //加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取对象
        AccountService accountService = (AccountService) ac.getBean("accountService");
        //调用方法
        accountService.findAll();


    }

第三步：搭建SpringMVC框架；

1，在web.xml中配置DispatcherServlet前端控制器：

<!--前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <!--加载springmvc.xml配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
      <!--启动服务器，创建该servlet-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

2，在web.xml中配置DispatcherServlet过滤器：

   <!--解决中文乱码的过滤器-->
    <filter>
        <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

3，创建SpringMVC框架的配置文件springmvc.xml，导入约束，并编写具体的配置信息：

 <!--开启注解扫描，SpringMVC框架只扫描Controller注解-->
    <context:component-scan base-package="com.yp">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:include-filter>
    </context:component-scan>

    <!--配置的视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--过滤静态资源-->
    <mvc:resources location="/js/" mapping="/js/**" ></mvc:resources>

    <!--开启SpringMVC注解的支持-->
    <mvc:annotation-driven></mvc:annotation-driven>

4，编写controller类和jsp页面，并进行测试：

/**
 * 账户控制器
 */
@Controller
@RequestMapping("/account")
public class AccountController {

    /**
     * 查询账户信息
     * @param model
     * @return
     */
    @RequestMapping("/findAll")
    public String findAll(){

        return "list";
    }
}

第四步：使用Spring整合SpringMVC框架；

目的： 在controller中能成功的调用service对象中的方法

1，在web.xml中配置Spring的监听器，用于启动服务时加载容器：

 <!--配置Spring的监听器，默认只加载WEB-INF目录下的applicationContext.xml配置文件-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--手动指定配置文件的路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

2，在controller中注入service对象，修改controller中的方法，实现调用service的方法进行测试：

/**
 * 账户控制器
 */
@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;

    /**
     * 查询账户信息
     * @param model
     * @return
     */
    @RequestMapping("/findAll")
    public String findAll(){
    
 		   accountService.findAll();
           return "list";
    }

第五步：搭建MyBatis框架；

1，编写 AccountDao 映射配置文件；

2，编写数据库连接文件jdbcConfig.properties（可省略，直接在SqlMapConfig.xml中填充数据库连接）；

2，编写SqlMapConfig.xml的配置文件：

<configuration>
    <!--指定数据库连接信息的文件,可省略，后面property标签直接写具体的数据库连接信息-->
	<properties resource="jdbcConfig.properties"></properties>
	 	<environments default="mysql">
			<environment id="mysql">
				<transactionManager type="JDBC"></transactionManager>
				<dataSource type="pooled">
					<property name="driver" value="${jdbc.driver}"/>
					<property name="url" value="${jdbc.url}"/>
					<property name="username" value="${jdbc.username}"/>
					<property name="password" value="${jdbc.password}"/>
				</dataSource>
			</environment>
		</environments>

	<mappers>
		<!--第一种：指定AccountDao的映射配置文件-->
		<mapper resource="com/yp/dao/AccountDao.xml"/>
		<!--第二种：直接包路径下所有的dao接口都可以使用-->
		<package name="cn.yp.dao"/>
	</mappers>
</configuration>

3，测试 MyBatis能否独立运行：

@Test
public void testMyBatis() throws Exception {
	// 加载配置文件
	InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
	// 创建工厂
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
	// 创建sqlSession对象
	SqlSession session = factory.openSession();
	// 获取代理对象
	AccountDao dao = session.getMapper(AccountDao.class);
	// 调用查询的方法
	List<Account> list = dao.findAll();
	for (Account account : list) {
	System.out.println(account);
	} 
	// 释放资源
	session.close();
	inputStream.close();
}

第六步：使用Spring整合MyBatis框架；

目的： 把MyBatis配置文件中的内容配置到Spring框架的配置文件中，去除MyBatis的配置文件

1，在 applicationContext.xml 中，Spring 接管 MyBatis 的 Session 工厂：

    <!-- 加载数据库连接文件jdbcConfig.properties -->
    <context:property-placeholder location="classpath:jdbcConfig.properties"></context:property-placeholder>

    <!-- 配置数据源连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 配置 MyBatis 的 Session 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
    </bean>

2，在applicationContext.xml中配置自动扫描所有 Mapper 接口和文件：

  <!--配置 Mapper 扫描器-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.yp.dao"></property>
    </bean>

3，在applicationContext.xml中配置 spring 的事务：

 <!--配置Spring框架声明式事务管理-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" ></property>
    </bean>

    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true"></tx:method>
            <tx:method name="*" isolation="DEFAULT"></tx:method>
        </tx:attributes>
    </tx:advice>

   <!-- 配置aop增强 -->
    <aop:config>
        <!-- 配置切入点表达式 -->
        <aop:pointcut expression="execution(* com.yp.service.impl.*.*(..))" id="pt1"></aop:pointcut>
        <!-- 建立通知和切入点表达式的关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>

4，测试Spring整合MyBatis：


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:applicationContext.xml"})
public class TestMyBatis {

    @Autowired
    private AccountService accountService;

    /**
     * 测试查询
     */
    @Test
    public void myBatisFindAll() {
        // 查询所有数据
        List<Account> list = accountService.findAll();
        for(Account account : list){
            System.out.println(account);
        }
    }
}

验证SSM整合

1，修改相应的jsp页面：

<!--请求发起页面-->

<a href="account/findAll">测试查询...</a>

<h3>测试保存...</h3>

<form action="account/save" method="post">
    姓名：<input type="text" name="name" /><br/>
    金额：<input type="text" name="money" /><br/>
    <input type="submit" value="保存"/><br/>
</form>

<!--响应结果页面-->
 <h3>展示所有的帐户信息</h3>

    <table border="1" width="300px">
    <tr>
        <th>编号</th>
        <th>账户名称</th>
        <th>账户金额</th>
    </tr>

        <c:forEach items="${accounts}" var="account" varStatus="vs">
            <tr>
                <td>${vs.count}</td>
                <td>${account.name }</td>
             <td>${account.money }</td>
            </tr>
        </c:forEach>
    </table>

2，为了展示视图效果，修改controller控制器中的方法：

    /**
     * 查询账户信息
     * @param model
     * @return
     */
    @RequestMapping("/findAll")
    public String findAll(Model model){

        System.out.println("表现层：查询所有账户信息......");

       //调用AccountService的findAll方法
       List<Account> accounts = accountService.findAll();

        model.addAttribute("accounts",accounts);
        return "list";
    }

    /**
     * 保存账户信息
     * @param account
     * @param request
     * @param response
     * @throws IOException
     */
    @RequestMapping("/save")
    public void save(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {

        System.out.println("表现层：保存账户信息......");

		 //调用AccountService的save方法
        accountService.save(account);
        //重定向
        response.sendRedirect(request.getContextPath()+"/account/findAll");
    }