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