springmvc-整合三大框架ssm

时间 2019-11-18

标签 springmvc 整合三大框架 ssm 栏目 Spring 繁體版

原文原文链接

1.整合思路css

　　方向：用spring整合springmvc与mybatishtml

　　方式：ssm整合有多种方式，配置或者注解，哪一种简单用哪一种，这里使用xml+注解前端

　　前提：能保证每个框架可以单独使用，好比springmvc能够发送请求，启动服务器，作出响应。java

　　　　保证mybatis能进行数据库的操做。mysql

　　　　　要先保证每个框架可以单独运行，而后再用spring进行整合，避免这里整一点那里整一点，搞混淆了。web

步骤：1.搭建整合的环境，2.搭建spring，3.用spring整合springmvc框架，4.用spring整合mybatis框架spring

三层架构，每一层作的事都不同sql

表现层是用于与浏览器进行交互的，你把请求发给我，我给你作响应数据库

业务层通常不作业务的具体逻辑，而是作事务管理，像以前学的声明式事物管理，会使得事务管理变得很是简单express

持久层用于作持久化工做，将内存的数据存进硬盘，增删改查数据库的

2、整合

2.1 环境准备

1. 建立数据库和表结构

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

2. 建立maven工程

3. 导入坐标创建依赖

  <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>
      <!--aop相关的技术-->
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>
    <dependency>
      <!--aop的jar包-->
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <!--spring的容器-->
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <!--web与webmvc是springmvc须要用的jar包-->
      <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>
      <!--jdbc模板技术-->
      <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>
      <!--mysql驱动包-->
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <!--servlet-->
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <!--jsp-->
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <!--想在页面也el表达式须要用到的包-->
      <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>
      <!--mybatis-->
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <dependency>
      <!--spring整合mybatis须要用到这个包-->
      <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>

4. 编写实体类

补上java与resources目录，而且改为java root 与resources root，新建4个包

在pojo包中建立Account实体类

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

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + 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;
    }
}

5. 编写业务层接口

在service中建立AccountService接口，而且建立它的实现类(具体实现先不写)

public interface AccountService {
    public List<Account> findAll();//查询全部帐户
    public void saveAccount(Account account);//保存帐户信息
}

public class AccountServiceImpl implements AccountService {
    @Override
    public List<Account> findAll() {
        System.out.println("业务层，查询全部帐户...");
        return null;
    }

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

6. 编写持久层接口

在dao中建立AccountDao接口

public interface AccountDao {
    public List<Account> findAll();//查询全部帐户
    public void saveAccount(Account account);//保存帐户信息
}

7. controller

在controller中建立AccountController类

public class AccountController {
}

2.2 整合步骤

1 保证spring框架在web工程中单独运行

使用注解的方式，想要使用注解的方式进行依赖注入，须要写一个配置文件，而后开启注解的扫描

建立applicationContext.xml文件，这是spring的配置文件

开启了注解的扫描，它会扫描全部cong下全部包的

可是，咱们说过spring只负责业务层(service)和持久层(dao)的事，而无论表现层(controller)

因此要不扫描controller注解的代码，等待springmvc来扫描

<?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: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.xsd
       http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解的扫描，但愿处理dao和service，controller不须要spring框架去处理--> 
　　<context:component-scan base-package="com.cong"> 
　　<!--制定扫包规则，不扫描@Controller 注解的 JAVA 类，其余的仍是要扫描 --> 
　　　<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" /> 　　
　　</context:component-scan> 
</beans>

测试spring是否能够运行

在java下建立test.TestSpring测试类

import com.cong.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 context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取对象
        AccountService accountService = (AccountService) context.getBean("accountService");
        //执行方法
        accountService.findAll();
    }
}

执行结果，标明spring能够单独运行

2 保证springmvc框架在web工程中单独运行

在web.xml中配置核心控制器(DisptcherServlet)

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!-- 配置 spring mvc 的核心控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置初始化参数，用于读取 springmvc 的配置文件 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!-- 配置 servlet 的对象的建立时间点：应用加载时建立。取值只能是非 0 正整数，表示启动顺序 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <!-- 配置 springMVC 编码过滤器 -->
  <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>/*</url-pattern>
  </filter-mapping>
</web-app>

在resources下建立springmvc的配置文件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.cong">
        <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 mapping="/css/**" location="/css/"></mvc:resources>
    <mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
    <mvc:resources mapping="/images/**" location="/images/"></mvc:resources>
    <!--开启springmvc框架注解的支持-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

编写jsp页面

index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
　　<h2>Hello World!</h2>
　　<a href="/account/findAll">查询全部用户</a>
</body>
</html>

list.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>这是全部用户</h3>
</body>
</html>

修改controller下面的AccountController

@Controller
@RequestMapping("/account")
public class AccountController {
    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("run findAll()...");
        return "list";
    }
}

配置tomcat服务器，进行测试

至此，springmvc框架能够在web项目中独立运行

3 spring整合springmvc

怎么能算整合成功呢？

在controller中能成功的调用service对象中的方法就算整合成功。

如图，咱们点击超链机，发送请求，执行AccountController中的方法，

由于是查询全部用户，若是AccountController在执行的过程当中能够调用业务层AccountService中的findAll()方法，

就能够查询到全部的用户信息了。

因此controller中须要有一个service对象，这时就须要往依赖注入的方向想，

controller放在了springmvc的容器中了，若是把service也放在容器当中，

就能够在controller中定义一个service成员属性，这样的话，controller就能够调用service的方法了。

可是，当咱们启动tomcat服务器的时候，会根据前端控制器加载配置文件springmvc.xml

而springmvc.xml中，仅仅扫描了controller注解，service对象加载不到容器当中，由于applicationContext.xml从头至尾都没有加载过

    <context:component-scan base-package="com.cong">
        <context:include-filter type="annotation" 
                 expression="org.springframework.stereotype.Controller"></context:include-filter>
    </context:component-scan>

so，解决方案就是在启动服务器的时候把spring的配置文件applicationContext.xml加载到服务器当中。

那么，怎么去作呢？

先讲几个对象。

1.ServletContext

这是咱们学习java web最大的一个域对象，通常叫应用的域对象，

一个应用只会有一个ServletContext对象，这个对象只会建立一次。

启动服务器的时候会建立它，关闭服务器了才会销毁它，也就是它的声明周期和tomcat的生命周期是同样的。

2.一类监听器

咱们学过监听器。有这么一类监听器，能够监听ServletContext对象的建立和销毁。

这个监听器只会执行一次，并且是在服务器启动的时候执行。

因此，可让这个监听器去加载spring的配置文件。

这个监听器在org.springframework.web.context 中。

如下是整合过程

1.在web.xml中配置ContextLoaderListener监听器，将spring的配置文件加载到tomcat服务器当中

<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!-- 配置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

@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private AccountService accountService;
    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("表现层，查询全部用户...");
        //调用service中的方法，public List<Account> findAll()
        accountService.findAll();
        return "list";
    }
}

结果,打印两行，证实在controller中调用了service的方法

至此，spring整合springmvc成功。

4 保证mybatis框架在web工程中单独运行

采用的是注解方式查询，而不建立映射文件。

在resources中建立S去了MapConfig.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>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"></property>
                <property name="password" value="123456"></property>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定映射配置文件-->
    <mappers>
        <!--指定-->
        <!--<mapper class="com.cong.dao.AccountDao"></mapper>-->
        <!--该包均可以-->
        <package name="com.cong.dao"></package>
    </mappers>
</configuration>

经过注解进行保存和查找操做

import com.cong.pojo.Account;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface AccountDao {
    @Select("select * from account")
    public List<Account> findAll();//查询全部帐户
    @Insert("insert into account (name,money) values (#{name},#{money})")
    public void saveAccount(Account account);//保存帐户信息
}

测试类

package com.cong.test;

import com.cong.dao.AccountDao;
import com.cong.pojo.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.InputStream;
import java.util.List;


public class TestMybatis {
    @Test
    public void save() throws Exception{
        //加载文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //建立工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //建立session对象
        SqlSession session = factory.openSession();
        //获取代理对象
        AccountDao accountDao = session.getMapper(AccountDao.class);
        Account account = new Account();
        account.setName("聪聪");
        account.setMoney(111111);
        accountDao.saveAccount(account);
        //提交事务
        session.commit();
        //释放资源
        session.close();
        inputStream.close();
    }
    @Test
    public void findAll() throws Exception{
        //加载文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //建立工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        //建立session对象
        SqlSession session = factory.openSession();
        //获取代理对象
        AccountDao accountDao = session.getMapper(AccountDao.class);
        List<Account> accounts = accountDao.findAll();
        for (Account account : accounts) {
            System.out.println(account.toString());
        }
        //释放资源
        session.close();
        inputStream.close();
    }
}

结果，至此mybatis可以在web工程中独立运行

5 spring整合mybatis

怎么算整合成功？

service能够调用dao的对象，这样就可进行查询或者把数据存到数据库中。

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

过程

service已经放到了ioc容器中，dao是一个接口，当时能够经过代码生成一个代理对象，

若是把生成的代理对象也存到ioc容器中，这样service就能够拿到dao对象，进行调用，进行持久层的操

怎么操做呢？

在spring的配置文件applicationContext.xml中配置三个东西

1.配置C3P0的链接池对象

　数据库的必要信息

2.配置SqlSessionFactory工程

为何配置这个，在咱们以前进行数据库操做的时候，须要建立工厂，有了工厂咱们就能够拿到session对象，

　而后就能够经过session对象获取dao代理对象，有了dao代理对象就能够存到ioc容器中去

3.配置扫描dao的包

经过这个包告知程序须要生成哪些dao的代理对象

配置以后的applicationContext.xml

配置了以后SqlMapConfig.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: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.xsd
       http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解的扫描，但愿处理dao和service，controller不须要spring框架去处理-->
    <context:component-scan base-package="com.cong">
        <!--制定扫包规则，不扫描@Controller 注解的 JAVA 类，其余的仍是要扫描 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <!--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:///ssm?useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </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.cong.dao"/>
    </bean>
</beans>

jsp页面

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello World!</h2>
    <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>
    <c:forEach items="${list}" var="account">
        ${account.toString()}<br/>
    </c:forEach>
</body>
</html>

controller，service以及dao

controller代码

@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";
    }
}

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);
    }
}

dao代码

@Repository
public interface AccountDao {
    @Select("select * from account")
    public List<Account> findAll();//查询全部帐户
    @Insert("insert into account (name,money) values (#{name},#{money})")
    public void saveAccount(Account account);//保存帐户信息
}

结果，至此，spring整合mybatis的查找全部用户完成。

保存用户功能与事务管理

此外还有一个功能，就是保存用户，这里须要用到事务管理

在applicationContext.xml中配置声明式事务管理

    <!--配置Spring框架声明式事务管理-->
    <!--配置事务管理器-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="manager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置事务通知-->
    <tx:advice transaction-manager="manager" id="txAdvice">
        <tx:attributes>
            <!--表示只读-->
            <tx:method name="/find*" read-only="true"/>
　　　　　　　<!-- 表示出了find开头的方法的隔离级别-->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!--配置aop的加强-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution(* com.cong.service.impl.*ServiceImpl.*(..)))"/>
    </aop:config>
</beans>

涉及到的jsp与控制器

jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
    <h3>查询</h3>
    <a href="account/findAll">查询全部用户</a><br/>
    <H3>保存</H3>
    <form action="/account/save" method="post">
        姓名：<input type="text" name="name"/><br/>
        金额：<input type="text" name="money"/><br/>
        <input type="submit" value="保存用户"/>
    </form>
</body>
</html>


控制器代码
    @RequestMapping("/save")
    public void save(Account account, HttpServletRequest request, HttpServletResponse response) throws IOException {
        System.out.println("表现层，保存用户...");
        accountService.saveAccount(account);
        response.sendRedirect(request.getContextPath()+"/account/findAll");//重定向到查询全部用户
        return ;
    }

结果

至此，ssm整合完毕

完整的项目结构