Spring+SpringMVC+mybatis(SSM)框架整合详细步骤

　　最近一直在自学Spring、springMVC和mybatis的整个体系及框架，学完之后为了巩固一遍框架的流程，所以特此开博记录SSM整合的详细过程，完成的工作是使用SSM框架完成对账户的CRUD操作，是基于配置文件和注解共同完成的，下面开始详细的介绍。

　　首先创建maven项目，填写完基本项目信息。

　　然后在pom.xml文件中导入所需要的jar包(这里面叫坐标)，这里直接复制粘贴即可，如果后续开发需要使用新的坐标，可以到apache的maven库中进行查询，传送门在这里。具体的依赖坐标如下：

  1 <!-- 定义版本号 -->
  2   <properties>
  3     <spring.version>5.0.2.RELEASE</spring.version>
  4     <slf4j.version>1.6.6</slf4j.version>
  5     <log4j.version>1.2.12</log4j.version>
  6     <mysql.version>5.1.46</mysql.version>
  7     <mybatis.version>3.4.5</mybatis.version>
  8   </properties>
  9 
 10   <dependencies>
 11 
 12     <!-- spring的AOP依赖坐标 -->
 13     <dependency>
 14       <groupId>org.aspectj</groupId>
 15       <artifactId>aspectjweaver</artifactId>
 16       <version>1.6.8</version>
 17     </dependency>
 18     <dependency>
 19       <groupId>org.springframework</groupId>
 20       <artifactId>spring-aop</artifactId>
 21       <version>${spring.version}</version>
 22     </dependency>
 23 
 24     <!-- spring的依赖坐标 -->
 25     <dependency>
 26       <groupId>org.springframework</groupId>
 27       <artifactId>spring-context</artifactId>
 28       <version>${spring.version}</version>
 29     </dependency>
 30 
 31     <!-- springMVCweb项目需要的依赖坐标  -->
 32     <dependency>
 33       <groupId>org.springframework</groupId>
 34       <artifactId>spring-web</artifactId>
 35       <version>${spring.version}</version>
 36     </dependency>
 37     <dependency>
 38       <groupId>org.springframework</groupId>
 39       <artifactId>spring-webmvc</artifactId>
 40       <version>${spring.version}</version>
 41     </dependency>
 42 
 43     <!-- spring中支持单元测试的依赖坐标  -->
 44     <dependency>
 45       <groupId>org.springframework</groupId>
 46       <artifactId>spring-test</artifactId>
 47       <version>${spring.version}</version>
 48     </dependency>
 49 
 50     <!-- spring中的事务控制管理器依赖坐标 -->
 51     <dependency>
 52       <groupId>org.springframework</groupId>
 53       <artifactId>spring-tx</artifactId>
 54       <version>${spring.version}</version>
 55     </dependency>
 56 
 57     <!-- spring中连接数据库 -->
 58     <dependency>
 59       <groupId>org.springframework</groupId>
 60       <artifactId>spring-jdbc</artifactId>
 61       <version>${spring.version}</version>
 62     </dependency>
 63 
 64     <!-- 引入junit单元测试 -->
 65     <dependency>
 66       <groupId>junit</groupId>
 67       <artifactId>junit</artifactId>
 68       <version>4.12</version>
 69       <scope>compile</scope>
 70     </dependency>
 71 
 72     <!-- 引入mysql连接驱动 -->
 73     <dependency>
 74       <groupId>mysql</groupId>
 75       <artifactId>mysql-connector-java</artifactId>
 76       <version>${mysql.version}</version>
 77     </dependency>
 78 
 79     <!-- 引入servlet拦截器 -->
 80     <dependency>
 81       <groupId>javax.servlet</groupId>
 82       <artifactId>servlet-api</artifactId>
 83       <version>2.5</version>
 84       <scope>provided</scope>
 85     </dependency>
 86     <dependency>
 87       <groupId>javax.servlet.jsp</groupId>
 88       <artifactId>jsp-api</artifactId>
 89       <version>2.0</version>
 90       <scope>provided</scope>
 91     </dependency>
 92 
 93     <!-- 引入jstl标签库 -->
 94     <dependency>
 95       <groupId>jstl</groupId>
 96       <artifactId>jstl</artifactId>
 97       <version>1.2</version>
 98     </dependency>
 99 
100     <!-- 引入日志文件 -->
101     <dependency>
102       <groupId>log4j</groupId>
103       <artifactId>log4j</artifactId>
104       <version>${log4j.version}</version>
105     </dependency>
106     <dependency>
107       <groupId>org.slf4j</groupId>
108       <artifactId>slf4j-api</artifactId>
109       <version>${slf4j.version}</version>
110     </dependency>
111     <dependency>
112       <groupId>org.slf4j</groupId>
113       <artifactId>slf4j-log4j12</artifactId>
114       <version>${slf4j.version}</version>
115     </dependency>
116 
117     <!-- 引入mybatis包 -->
118     <dependency>
119       <groupId>org.mybatis</groupId>
120       <artifactId>mybatis</artifactId>
121       <version>${mybatis.version}</version>
122     </dependency>
123 
124     <!-- 引入mybatis与spring的整合包 -->
125     <dependency>
126       <groupId>org.mybatis</groupId>
127       <artifactId>mybatis-spring</artifactId>
128       <version>1.3.0</version>
129     </dependency>
130 
131     <!-- 引入数据库连接池包 -->
132     <dependency>
133       <groupId>c3p0</groupId>
134       <artifactId>c3p0</artifactId>
135       <version>0.9.1.2</version>
136       <type>jar</type>
137       <scope>compile</scope>
138     </dependency>
139   </dependencies>

pom文件中的依赖坐标

　　导完坐标之后，开始设计目录结构，暂时的目录结构如下：

　　设计数据库，因为这只是一个demo练习，所以数据库设计的并没有很复杂，数据库的语句如下：

1 create table account(
2 id int primary key auto_increment,
3 name varchar(20),
4 money double
5 );

sql

　　编写java代码，其中包括pojo实体类、与数据库交互的dao层接口、业务层service接口、业务层的实现接口。

 1 package com.ssm.pojo;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6  * 定义用户类
 7  */
 8 public class Account implements Serializable {
 9     private Integer id;
10     private String name;
11     private Double money;
12 
13     public Integer getId() {
14         return id;
15     }
16 
17     public void setId(Integer id) {
18         this.id = id;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public Double getMoney() {
30         return money;
31     }
32 
33     public void setMoney(Double money) {
34         this.money = money;
35     }
36 
37     @Override
38     public String toString() {
39         return "Account{" +
40                 "id=" + id +
41                 ", name='" + name + '\'' +
42                 ", money=" + money +
43                 '}';
44     }
45 }

Account.java

 1 package com.ssm.dao;
 2 
 3 import com.ssm.pojo.Account;
 4 
 5 import java.util.List;
 6 
 7 /**
 8  * 与数据库做交互的接口
 9  */
10 public interface AccountDao {
11     /**
12      * 查询所有用户
13      * @return
14      */
15     public List<Account> findAll();
16 
17     /**
18      * 根据id查询用户
19      * @param id
20      * @return
21      */
22     public Account findById(Integer id);
23 
24     /**
25      * 添加并保存用户
26      * @param account
27      */
28     public void saveAccount(Account account);
29 
30     /**
31      * 根据id删除用户
32      * @param id
33      */
34     public void deleteAccount(Integer id);
35 
36     /**
37      * 更新用户信息
38      * @param account
39      */
40     public void updateAccount(Account account);
41 }

AccountDao.java

 1 package com.ssm.service;
 2 import com.ssm.pojo.Account;
 3 import java.util.List;
 4 
 5 /**
 6  * 业务层接口
 7  */
 8 public interface AccountService {
 9     /**
10      * 查询所有用户
11      * @return
12      */
13     public List<Account> findAll();
14 
15     /**
16      * 根据id查询用户
17      * @param id
18      * @return
19      */
20     public Account findById(Integer id);
21 
22     /**
23      * 添加并保存用户
24      * @param account
25      */
26     public void saveAccount(Account account);
27 
28     /**
29      * 根据id删除用户
30      * @param id
31      */
32     public void deleteAccount(Integer id);
33 
34     /**
35      * 更新用户信息
36      * @param account
37      */
38     public void updateAccount(Account account);
39 }

AccountService.java

 1 package com.ssm.service.impl;
 2 
 3 import com.ssm.dao.AccountDao;
 4 import com.ssm.pojo.Account;
 5 import com.ssm.service.AccountService;
 6 import org.springframework.stereotype.Service;
 7 
 8 import java.util.List;
 9 
10 /**
11  * 业务层的实现类
12  */
13 @Service("accountService")
14 public class AccountServiceImpl implements AccountService {
15     private AccountDao account;
16 
17     public List<Account> findAll() {
18         System.out.println("业务层：查询所有用户");
19         return null;
20     }
21 
22     public Account findById(Integer id) {
23         return null;
24     }
25 
26     public void saveAccount(Account account) {
27         
28     }
29 
30     public void deleteAccount(Integer id) {
31 
32     }
33 
34     public void updateAccount(Account account) {
35 
36     }
37 }

AccountServiceImpl.java

　　开始spring框架的编写，准备添加注解，要想将添加的注解生效，首先要配置spring的xml文件，spring的配置文件名为applicationContext.xml：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:aop="http://www.springframework.org/schema/aop"
 6        xmlns:tx="http://www.springframework.org/schema/tx"
 7        xsi:schemaLocation="http://www.springframework.org/schema/beans
 8        http://www.springframework.org/schema/beans/spring-beans.xsd
 9        http://www.springframework.org/schema/context
10        http://www.springframework.org/schema/context/spring-context.xsd
11        http://www.springframework.org/schema/aop
12        http://www.springframework.org/schema/aop/spring-aop.xsd
13        http://www.springframework.org/schema/tx
14        http://www.springframework.org/schema/tx/spring-tx.xsd">
15     
16     <!-- 开启注解扫描，由于spring是业务层的框架，所以只扫描dao层和service层的注解，至于controller的注解留给springmvc去扫描 -->
17     <context:component-scan base-package="com.ssm">
18         <!-- 配置要忽略的注解 -->
19         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
20     </context:component-scan>
21     
22 </beans>

applicationContext.xml

　　测试当前配置的spring中的注解是否生效，测试代码如下：

1  @Test
2     public void testService(){
3         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
4         AccountService accountService = (AccountService) applicationContext.getBean("accountService");
5         accountService.findAll();
6     }

testSpring.java

　　开始搭建springmvc的环境，因为springmvc是表现层的框架，通过页面发来的请求被前端控制器拦截，去寻找后台的controller对应的方法去响应，响应完之后交给视图解析器去渲染，最后显示页面，所以这里重点在web的配置文件、controller以及页面的编写这三方面。

 1 <!-- Servlet Configuration ========================================== -->
 2 
 3   <!--
 4     - 配置前端控制器，服务器启动时必须加载，需要记载springmvc.xml配置文件
 5     -->
 6   <servlet>
 7     <servlet-name>DispatcherServlet</servlet-name>
 8     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 9     <!-- 配置初始化参数，创建完DispatcherServlet对象，加载springmvc.xml文件 -->
10     <init-param>
11       <param-name>contextConfigLocation</param-name>
12       <param-value>classpath:springmvc.xml</param-value>
13     </init-param>
14     <load-on-startup>1</load-on-startup>
15   </servlet>
16 
17   <!-- URL space mappings ============================================= -->
18 
19   <servlet-mapping>
20     <servlet-name>DispatcherServlet</servlet-name>
21     <url-pattern>/</url-pattern>
22   </servlet-mapping>

web.xml

　　解决中文乱码问题，引入过滤器。

 1 <!-- Servlet Filters ================================================ -->
 2 
 3   <!--
 4     - 配置解决中文乱码问题的过滤器
 5     -->
 6   <filter>
 7     <filter-name>CharacterEncodingFilter</filter-name>
 8     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
 9     <init-param>
10       <param-name>encoding</param-name>
11       <param-value>UTF-8</param-value>
12     </init-param>
13   </filter>
14 
15   <!-- Filter mappings ================================================ -->
16 
17   <filter-mapping>
18     <filter-name>CharacterEncodingFilter</filter-name>
19     <url-pattern>/*</url-pattern>
20   </filter-mapping>

web.xml

　　创建springmvc.xml配置文件。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:mvc="http://www.springframework.org/schema/mvc"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6        xsi:schemaLocation="
 7        http://www.springframework.org/schema/beans
 8        http://www.springframework.org/schema/beans/spring-beans.xsd
 9        http://www.springframework.org/schema/mvc
10        http://www.springframework.org/schema/mvc/spring-mvc.xsd
11        http://www.springframework.org/schema/context
12        http://www.springframework.org/schema/context/spring-context.xsd">
13 
14     <!-- 扫描controller的注解，别的不扫描 -->
15     <context:component-scan base-package="com.ssm">
16         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
17     </context:component-scan>
18 
19     <!-- 配置视图解析器 -->
20     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
21         <!-- JSP文件所在的目录 -->
22         <property name="prefix" value="/WEB-INF/pages/"></property>
23         <!-- 文件的后缀名 -->
24         <property name="suffix" value=".jsp"></property>
25     </bean>
26 
27     <!-- 设置静态资源不过滤 -->
28     <mvc:resources mapping="/css/**" location="/css/"></mvc:resources>
29     <mvc:resources mapping="/images/**" location="/images/"></mvc:resources>
30     <mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
31 
32     <!-- 开启对springmvc的注解支持 -->
33     <mvc:annotation-driven></mvc:annotation-driven>
34 </beans>

springmvc.xml

　　编写index.jsp和list.jsp编写。

index.jsp

 1 <%--
 2   Created by IntelliJ IDEA.
 3   User: 刘云锴
 4   Date: 2019/9/12
 5   Time: 10:17
 6   To change this template use File | Settings | File Templates.
 7 --%>
 8 <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
 9 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
10 <html>
11 <head>
12     <title>Title</title>
13 </head>
14 <body>
15     <h3>查询所有账户信息</h3>
16     <%--<c:forEach items="${list}" var="account">
17         ${account.name}
18     </c:forEach>--%>
19 </body>
20 </html>

list.jsp

　　创建AccountController类，编写方法。

package com.ssm.controller;

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

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

    /**
     * 查询所有数据
     * @return
     */
    @RequestMapping("/findAll")
    public String findAll(){
        System.out.println("表现层：查询所有用户");
        return "list";
    }
}

AccountController.java

　　此时还不能进行spring与springmvc整合测试，因为项目启动时自动加载的是WEB-INF下的applicatContext.xml文件，但是我们的文件不在该文件目录下，所以要配置监听器，当监听到项目启动时，就去加载源文件目录下的applicationContext.xml。

 1 <!-- Servlet Context Listener ======================================= -->
 2 
 3   <!--
 4     - 配置Spring的监听器
 5     -->
 6   <listener>
 7     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 8   </listener>
 9 
10   <!-- 配置加载类路径的配置文件 -->
11   <context-param>
12     <param-name>contextConfigLocation</param-name>
13     <param-value>classpath:applicationContext.xml</param-value>
14   </context-param>

web.xml

　　此时可以启动tomcat服务器将项目部署到里面，可以显示我们的索引页面并实现跳转了。表明此时表现层框架springmvc的测试成功。再在AccountController中引入AccountService变量去调用业务层的方法做测试，即可表明业务层与表现层整合成功。

　　前面已经整合成功的表现层和业务层的框架，即springmvc与spring整合成功，接下来整合mybatis。首先配置mybatis的配置文件。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6     <environments default="mysql">
 7         <environment id="mysql">
 8             <transactionManager type="JDBC"></transactionManager>
 9             <dataSource type="POOLED">
10                 <property name="driver" value="com.mysql.jdbc.Driver"/>
11                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis_learning?useSSL=false"/>
12                 <property name="username" value="root"/>
13                 <property name="password" value="7458"/>
14             </dataSource>
15         </environment>
16     </environments>
17     
18     <!-- 这里使用的是注解的sql语句 -->
19     <mappers>
20         <package name="com.ssm.dao"/>
21     </mappers>
22 </configuration>

mybatis.xml

　　配置文件写好之后，在dao层的方法上加入sql语句注解，这里将CRUD所有的方法的sql语句注解都加上。

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

    /**
     * 根据id查询用户
     * @param id
     * @return
     */
    @Select("select * from account where id = #{id}")
    public Account findById(Integer id);

    /**
     * 添加并保存用户
     * @param account
     */
    @Insert("insert into account (name,money) values (#{name},#{money})")
    public void saveAccount(Account account);

    /**
     * 根据id删除用户
     * @param id
     */
    @Delete("delete from account where id = #{id}")
    public void deleteAccount(Integer id);

    /**
     * 更新用户信息
     * @param account
     */
    @Update("update account set money = #{money} where id = #{id}")
    public void updateAccount(Account account);

AccountDao.java

　　编写测试，可以正常连接数据库，表明mybatis设置成功。

/**
     * 测试查询功能
     * @throws Exception
     */
    @Test
    public void testFindAllAndById() throws Exception {
        // 加载配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        // 创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 创建sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取代理对象
        AccountDao dao = sqlSession.getMapper(AccountDao.class);
        // 调用查询方法
        List<Account> accounts = dao.findAll();
        for (Account account:accounts){
            System.out.println(account.toString());
        }
        System.out.println(dao.findById(1));
        sqlSession.close();
        inputStream.close();
    }

    /**
     * 测试插入功能
     */
    @Test
    public void testSaveAccount() throws Exception {
        // 加载配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        // 创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 创建sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取代理对象
        AccountDao dao = sqlSession.getMapper(AccountDao.class);
        // 调用插入方法
        Account account = new Account();
        account.setName("樊振东");
        account.setMoney(1000d);
        dao.saveAccount(account);

        // 事务提交
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }

    /**
     * 测试删除
     */
    @Test
    public void testDeleteAccount() throws Exception {
        // 加载配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        // 创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 创建sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取代理对象
        AccountDao dao = sqlSession.getMapper(AccountDao.class);
        // 调用插入方法
        dao.deleteAccount(11);
        // 事务提交
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }

    /**
     * 测试更新
     */
    @Test
    public void testUpdateAccount() throws Exception {
        // 加载配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        // 创建工厂
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        // 创建sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取代理对象
        AccountDao dao = sqlSession.getMapper(AccountDao.class);
        // 调用插入方法
        Account account = dao.findById(1);
        account.setMoney(2000d);
        dao.updateAccount(account);
        // 事务提交
        sqlSession.commit();
        sqlSession.close();
        inputStream.close();
    }

testSpring.java

　　mybatis可以正常连接数据库，接下来就要将spring与mybatis整合，首先就要把mybatis.xml配置内容转移到applicatContext.xml中。

<!-- 配置c3p0的连接池对象 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis_learning?useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="7458"/>
    </bean>

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

    <!-- 配置扫描dao的包 -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ssm.dao"></property>
    </bean>

applicationContext.xml

　　其次在spring中添加声明式的事务控制

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

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

applicationContext.xml

　　完善AccountServiceImpl中的所有方法。

package com.ssm.service.impl;

import com.ssm.dao.AccountDao;
import com.ssm.pojo.Account;
import com.ssm.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;

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

    public Account findById(Integer id) {

        return accountDao.findById(id);
    }

    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
}

AccountServiceImpl.java

　　在AccountController中完成对每一个功能的映射。

 1 package com.ssm.controller;
 2 
 3 import com.ssm.pojo.Account;
 4 import com.ssm.service.AccountService;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Controller;
 7 import org.springframework.ui.Model;
 8 import org.springframework.web.bind.annotation.RequestMapping;
 9 import org.springframework.web.bind.annotation.RequestParam;
10 
11 import java.util.ArrayList;
12 import java.util.List;
13 
14 @Controller
15 @RequestMapping("/account")
16 public class AccountController {
17 
18     @Autowired
19     private AccountService accountService;
20 
21     /**
22      * 查询所有数据
23      *
24      * @return
25      */
26     @RequestMapping("/findAll")
27     public String findAll(Model model) {
28         System.out.println("表现层：查询所有用户");
29         List<Account> accounts = accountService.findAll();
30         /*for (Account account: accounts) {
31             System.out.println(account);
32         }*/
33         model.addAttribute("accounts", accounts);
34         return "list";
35     }
36 
37     /**
38      * 按照id查询用户
39      *
40      * @return
41      */
42     @RequestMapping("/findById")
43     public String findById(Model model, @RequestParam(value = "id") Integer id) {
44         List<Account> accounts = new ArrayList<Account>();
45         accounts.add(accountService.findById(id));
46         model.addAttribute("accounts", accounts);
47         return "list";
48     }
49 
50     /**
51      * 保存账户
52      * @param account
53      * @return
54      */
55     @RequestMapping("/saveAccount")
56     public String saveAccount(Account account) {
57         accountService.saveAccount(account);
58         return "redirect:findAll";
59     }
60 
61     /**
62      * 根据id删除用户
63      * @param id
64      * @return
65      */
66     @RequestMapping("/delete")
67     public String deleteAccount(@RequestParam(value = "id") Integer id) {
68         accountService.deleteAccount(id);
69         return "redirect:findAll";
70     }
71 
72     /**
73      * 更新用户金额
74      * @param account
75      * @return
76      */
77     @RequestMapping("/update")
78     public String updateAccount(Model model,Account account) {
79         accountService.updateAccount(account);
80         List<Account> accounts = new ArrayList<Account>();
81         accounts.add(accountService.findById(account.getId()));
82         model.addAttribute("accounts", accounts);
83         return "list";
84     }
85 }

AccountController.java

　　至此整个demo全部完毕，流程和理解非常重要，spring、springmvc以及该demo的源码在这里

原文地址：https://www.cnblogs.com/yunkaiL/p/11511812.html