简单理解....SSM框架整合

最新推荐文章于 2023-02-01 12:19:35 发布

是哈猿啊

最新推荐文章于 2023-02-01 12:19:35 发布

阅读量375

点赞数

分类专栏： Java学习心得文章标签： mybatis spring java

本文链接：https://blog.csdn.net/haroroc/article/details/109201176

版权

Java学习心得专栏收录该内容

13 篇文章 0 订阅

订阅专栏

SSM三大框架整合

简介
搭建整合环境
Spring框架代码的编写
- 1.搭建Spring的开发环境
- 2.测试Spring的开发环境
Spring整合SpringMVC框架
Spring整合MyBatis框架
Spring事务管理
- 1.配置Spring事务
- 2.测试save方法

简介

在把MyBatis、Spring、SpringMVC三大框架学完之后，就要把这些框架整合到项目中一起使用，这里主要是演示了三大框架整合的步骤，所以里面采用的例子是都是一些简单的，以及前端代码的效果也是粗略的，重在讲解整合过程。

搭建整合环境

1.整合环境说明

在进行整合的时候，我们不是像MyBatis框架这里做一点，然后在Spring这里也做一点那样的随心所欲，这样很容易产生混乱，所以我们要有一定的整合思路：

先搭建整合的项目环境
把Spring的配置搭建完成
使用Spring整合SpringMVC框架
最后使用Spring整合MyBatis框架

同时SSM整合可以使用多种的方法，这里使用的是XML+注解的方式。

2.数据库准备

在数据库创建一张如下的用户表：

create database ssm;
use ssm;
create table account(
	id int primary key auto_increment,
   name varchar(20),
   money double
);

创建一张account的用户表，有自动增长的主键id，还有用户名name和金额money这三个属性。

3.创建maven工程

这里的项目我是将SSM作为一个模块创建出来，在这个模块下有以下的子包分工合作。
（PS：有时候我们在创建maven工程的时候，会比较慢，这有一篇文章希望能够帮你解决https://blog.csdn.net/haroroc/article/details/106886367）

创建需要的子包
        controller
        domain
        dao
        service

根据子模块的创建，下图为工程的目录结构：

在这里插入图片描述
导入相关jar包的坐标：

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
  </properties>

  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

  </dependencies>

在进行整合的时候要注意MyBatis和Spring的版本兼容问题：

MyBatis-Spring	MyBatis	Spring
1.0.0 and 1.0.1	3.0.1 to 3.0.5	3.0.0 or higher
1.0.2	3.0.6	3.0.0 or higher
1.1.0 or higher	3.0.1 or higher	3.0.0 or higher
1.3.0 or higher	3.4.0 or higher	3.0.0 or higher

最后，部署项目，只要把项目加入到tomcat服务器中即可。

4.编写实体类

在domain包下创建一个Account的实体类，其属性名称对应数据库里面的account表的字段，并且生成该类的Getter和Setter方法：

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

5.编写dao接口

在dao包下编写用于直接操作数据库的AccountDao接口，对于这个接口我们就不写它的实现类或AccountDao.xml映射配置文件了，因为下文我们直接用注解的方式来表示操作数据库的SQL语句。

import com.ha.domain.Account;
import java.util.List;

public interface AccountDao {
    /**
     * 查询所有账户
     * @return
     */
    public List<Account> findAll();

    /**
     * 保存账户信息
     * @param account
     */
    public void saveAccount(Account account);
}

6.编写service接口和实现类

编写service的接口 AccountService

import com.ha.domain.Account;
import java.util.List;

public interface AccountService {
    /**
     * 查询所有账户
     * @return
     */
    public List<Account> findAll();

    /**
     * 保存账户信息
     * @param account
     */
    public void saveAccount(Account account);
}

编写AccountService接口的实现类AccountServiceImpl，该类存放在service目录下的impl包下

import com.ha.dao.AccountDao;
import com.ha.domain.Account;
import com.ha.service.AccountService;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有账户");
        return null;
    }

    @Override
    public void saveAccount(Account account) {
        System.out.println("业务层：保存账户");
    }
}

Spring框架代码的编写

1.搭建Spring的开发环境

在resources资源包中创建Spring框架所需要的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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--开启注解扫描,但只希望处理service和dao,controller不需要Spring框架去处理-->
    <context:component-scan base-package="com.ha">
        <!--配置哪些注解不扫描-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

   
</beans>

2.测试Spring的开发环境

在test测试目录中编写测试方法，对Spring单独测试，检查能不能独立运行。

import com.ha.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void run1(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService service = ac.getBean("accountService", AccountService.class);
        service.findAll();
    }
}

测试结果：
在这里插入图片描述

由测试结果，看出测试方法通过从spring容器中获取到业务层的对象service后，能够成功的调用AccountServiceImpl的findAll()方法，这样就表示Spring框架能够独立运行了。

Spring整合SpringMVC框架

1. 搭建SpringMVC的开发环境

在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>

在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>

创建springmvc.xml的配置文件，编写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

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

    <!--配置的视图解析器对象-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--JSP文件所在的目录-->
        <property name="prefix" value="/WEB-INF/pages/"/>
        <!--文件的后缀名-->
        <property name="suffix" value=".jsp"/>
    </bean>

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


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

</beans>

2.测试SpringMVC的框架

编写index.jsp和list.jsp编写，超链接

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        <a href="account/findAll">测试</a>
</body>
</html>

list.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        <h3>查询所有用户信息</h3>
</body>
</html>

index.jsp和list.jsp所在的目录
在这里插入图片描述

在index.jsp中创建一个超链接，这个超链接跳转的路径为account/findAll，当点击这个超链接的时候，web.xml配置的前端控制器会拦截这个请求，然后到下文编写的控制类AccountController去执行，最后会根据路径执行findAll的方法，这里由于是测试，所以只是简单的在控制台打印出来，然后会return到list.jsp，将list.jsp的内容输出。具体页面效果如下图所示：
index.jsp的效果图
在这里插入图片描述

创建AccountController类，编写方法，进行测试

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("表现层：查询所有方法执行");
        return "list";
    }
}

测试结果：
在这里插入图片描述

3.Spring整合SpringMVC的框架

既然要Spring整合SpringMVC，那么就要做一些配置，怎么算是成功呢？就是能够在controller中能成功的调用service对象中的方法。

配置

在项目启动的时候，就去加载applicationContext.xml的配置文件，在web.xml中配置ContextLoaderListener监听器（该监听器只能加载WEB-INF目录下的applicationContext.xml的配置文件，但是我们为了方便管理配置文件，所以不移动resources下的applicationContext.xml，选择设置文件了路径，同样达到访问的效果）。

<!--配置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>

在web.xml中配置监听器，ContextLoaderListener监听器的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。同时因为它实现了ServletContextListener这个接口，web.xml配置的这个监听器在启动容器时，就会默认执行它实现的方法，帮助了Spring完成其他初始化功能。

在controller中注入service对象，调用service对象的方法进行测试

import com.ha.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("表现层：查询所有方法执行");
        accountService.findAll();
        return "list";
    }
}

修改完Controller类之后，再重启服务器，然后点击index.jsp的测试超链接，跳转到list.jsp的页面输出，这时我们查看IDEA的控制台打印出来的结果：
在这里插入图片描述

不难看出，Spring的业务层和SpringMVC的表现层都能够执行里面的方法，表明Spring和SpringMVC这两个框架已经成功的整合了。

Spring整合MyBatis框架

1. 搭建和测试MyBatis的环境

在web项目中编写SqlMapConfig.xml的配置文件，编写核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--mybatis的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
                <property name="username" value="root"/>
                <property name="password" value="czj1998"/>
            </dataSource>
        </environment>
    </environments>

    <!--指定映射配置文件的位置，映射配置文件指的是每一个dao独立的配置文件-->
    <mappers>
        <package name="com.ha.dao"/>
    </mappers>
</configuration>

在AccountDao接口的方法上添加注解，编写SQL语句

import com.ha.domain.Account;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface AccountDao {

    /**
     * 查询所有账户
     * @return
     */
    @Select("select * from account")
    public List<Account> findAll();

    /**
     * 保存账户信息
     * @param account
     */
    @Insert("insert into account(name,money) values(#{name},#{money})")
    public void saveAccount(Account account);
}

2.测试

import com.ha.dao.AccountDao;
import com.ha.domain.Account;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestMyBatis {

    @Test
    public void run1() throws IOException {
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        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();
        in.close();
    }
}

根据流程，这个测试类也是用于测试MyBatis框架能否独立运行，根据下图的结果和数据库中表的数据内容：
在这里插入图片描述

由这两张图的内容相比较，测试类通过获取到的dao对象，并且调用findAll()方法，把account表中的数据都能在控制台打印出来，这就说明MyBatis框架能够独立运行。

3. Spring整合MyBatis框架

目的：把SqlMapConfig.xml配置文件中的内容配置到applicationContext.xml配置文件中

<!--Spring整合MyBatis框架-->
    <!--配置连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssm"/>
        <property name="user" value="root"/>
        <property name="password" value="czj1998"/>
    </bean>

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

    <!--配置AccountDao接口所在的包-->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ha.dao"/>
    </bean>

applicationContext.xml按照上述这样的配置，就相当于把SqlMapConfig.xml的主要内容也放进applicationContext.xml配置文件中，这样我们就可以不用SqlMapConfig.xml配置文件了，可以删掉它。

在AccountDao接口中添加@Repository注解

import com.ha.domain.Account;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface AccountDao {

    /**
     * 查询所有账户
     * @return
     */
    @Select("select * from account")
    public List<Account> findAll();

    /**
     * 保存账户信息
     * @param account
     */
    @Insert("insert into account(name,money) values(#{name},#{money})")
    public void saveAccount(Account account);
}

在service中注入dao对象，进行测试

在业务层实现类AccountServiceImpl中调用持久层AccountDao的方法，AccountDao属性通过插入@Autowired注解来自动注入。

import com.ha.dao.AccountDao;
import com.ha.domain.Account;
import com.ha.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有账户");
        return accountDao.findAll();
    }

    @Override
    public void saveAccount(Account account) {
        System.out.println("业务层：保存账户");
        accountDao.saveAccount(account);
    }
}

import com.ha.domain.Account;
import com.ha.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有方法执行");

        List<Account> list = accountService.findAll();
        model.addAttribute("list",list);
        return "list";
    }

    @RequestMapping("/save")
    public void save(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {
        accountService.saveAccount(account);
        response.sendRedirect(request.getContextPath()+"/account/findAll");
        return;
    }
}

为了使三个框架的整合效果，还要将list.jsp的内容修改一下：

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        <h3>查询所有用户信息</h3>

        <c:forEach items="${list}" var="account">
            ${account.name}<br/>
        </c:forEach>
</body>
</html>

通过用一个forEach循环把得到的list里面的account数据里面的用户名name逐一显示到页面中。
在这里插入图片描述

到这一步，三大框架就成功整合起来，但是还没有结束，之前我一直都是调用查询所有用户的方法，无论是业务层还是持久层，但是我们的持久层里面还有一个保存用户的方法–save()，这个方法的使用环境和findAll()的不一样，save()方法需要有事务管理来实现的，下面我们接着说事务的实现。

Spring事务管理

1.配置Spring事务

要Spring能够进行事务管理，就要在Spring的配置文件applicationContext.xml配置事务管理器。

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

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

    <!--配置AOP增强-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.ha.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"/>
    </aop:config>

在配置事务管理器transactionManager后，还要配置事务通知，对控制器里面的所有方法设置为"REQUIRED"，表示如果当前没有事务，就新建一个事务，如果已经存在一个事务，就加入到这个事务中。由于查找的方法是不需要事务管理的，所以在事务通知里面在加一项配置，对find*（即匹配到这个名称规则的方法）设置为"SUPPORTS"，即支持当前事务，如果当前没有事务，就以非事务方式执行。

2.测试save方法

配置完事务管理后，就可以去测试save方法，首先要将AccountController类中加入save的方法：

import com.ha.domain.Account;
import com.ha.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;

    @RequestMapping("/findAll")
    public String findAll(Model model){
        System.out.println("表现层：查询所有方法执行");

        List<Account> list = accountService.findAll();
        model.addAttribute("list",list);
        return "list";
    }

    @RequestMapping("/save")
    public void save(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {
        accountService.saveAccount(account);
        response.sendRedirect(request.getContextPath()+"/account/findAll");
        return;
    }
}

要测试save的方法能否成功运行，我们在这就将保存新用户信息之后，用response的重定向再去调用findAll()，然后将数据库之前存在的用户名和新保存的新用户名一起在list.jsp页面展示出来。
接着产生一些页面效果，在index.jsp里面加入表单的提交：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        <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>
</body>
</html>

重启Tomcat服务器，在表单输入数据
在这里插入图片描述

点击保存之后，首先查看数据库里面是否已经正确插入数据
在这里插入图片描述

用户表里面已经成功插入了数据，再查看list.jsp能不能将新用户展示出来
在这里插入图片描述

新插入的用户名也显示出来了，这样整个SSM框架整合就成功了。

虽然整个项目并没有太惊艳的代码操作或是页面展示，但是还是能够把了整个SSM框架的整合步骤讲清楚，这是我最近学到的知识，写出来记录一下自己的理解，并且分享出来。。

是哈猿啊

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
简单理解....SSM框架整合

这里写目录标题简介搭建整合环境1.整合环境说明2.数据库准备3.创建maven工程4.编写实体类：5.编写dao接口：6.编写service接口和实现类：Spring框架代码的编写1.搭建Spring的开发环境2.测试Spring的开发环境Spring整合SpringMVC框架1. 搭建SpringMVC的开发环境在web.xml中配置DispatcherServlet前端控制器在web.xml中配置DispatcherServlet过滤器解决中文乱码创建springmvc.xml的配置文件，编写配置文件2
复制链接

扫一扫