SSM整合之XML方式,与配置事务,拦截器,异常处理,PageHelper分页插件整合

最新推荐文章于 2024-08-08 19:59:48 发布

努力敲代码买猪脚啃

最新推荐文章于 2024-08-08 19:59:48 发布

阅读量325

点赞数

分类专栏： Spring MyBatis 文章标签： spring mybatis mvc

本文链接：https://blog.csdn.net/fushuaiCSDN/article/details/107532463

版权

Spring 同时被 2 个专栏收录

29 篇文章 0 订阅

订阅专栏

MyBatis

12 篇文章 0 订阅

订阅专栏

SSM整合之XML方式

将主流的三大框架整合一起使用
spring:将需要的bean交给IOC管理
SpringMVC:解决表现层
MyBatis:解决持久层

创建maven项目(配置文件与代码中注释有详细解释)

项目目录结构
在这里插入图片描述

数据库数据准备

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

/*Data for the table `account` */

insert  into `account`(`id`,`name`,`money`) values 

(1,'小付',1000),

(2,'小花',1000);

在这里插入图片描述

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.fs</groupId>
  <artifactId>day03_SSM_XML</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <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>
  </properties>

  <dependencies>
    <!--spring环境-->
    <!--spring环境-->
    <!--spring环境-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>


    <!--mybatis环境-->
    <!--mybatis环境-->
    <!--mybatis环境-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.3</version>
    </dependency>
    <!--mysql环境-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>
    <!--spring整合jdbc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
    <!--spring整合mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.1</version>
    </dependency>
    <!--druid连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.20</version>
    </dependency>
    <!--分页插件坐标-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.2</version>
    </dependency>


    <!--springmvc环境-->
    <!--springmvc环境-->
    <!--springmvc环境-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
    <!--jackson相关坐标3个  jackson-databind这一个会包含3个相关坐标-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
<!--    <dependency>-->
<!--        <groupId>com.fasterxml.jackson.core</groupId>-->
<!--        <artifactId>jackson-core</artifactId>-->
<!--        <version>2.9.0</version>-->
<!--    </dependency>-->
<!--    <dependency>-->
<!--        <groupId>com.fasterxml.jackson.core</groupId>-->
<!--        <artifactId>jackson-annotations</artifactId>-->
<!--        <version>2.9.0</version>-->
<!--    </dependency>-->
    <!--servlet环境-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>


    <!--其他组件-->
    <!--其他组件-->
    <!--其他组件-->
    <!--junit单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!--spring整合junit-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

<!--    lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
    </dependency>
  </dependencies>

  <build>
    <!--设置插件-->
    <plugins>
      <!--具体的插件配置-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>80</port>
          <path>/</path>
<!--          设置字符集编码-->
          <uriEncoding>UTF-8</uriEncoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

配置文件

使用xml的方式要配置一下文件

web.xml:tomcat启动初始化
applicationContext.xml:spring的主配置文件
spring-mvc.xml:SpringMVC的配置文件
springMybatis.xml:MyBatis的配置文件

我dao使用的注解方式:若要使用MyBatis映射配置文件,就在resources中创建于dao一样的包下创建dao.xml映射配置文件,然后写SQL语句

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
		  http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
  <!--
  springMVC程序启动流程

  1.tomcat启动首先加载web.xml
  2.保证DispatcherServlet能够正常加载配置文件
  3.spring配置文件必须扫描有spring注解的的包
  -->
<!--  首先加载applicationContext.xml核心配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--  配置调度服务器(前端控制器),配置后就能够去调度controller中的路径-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <!--    初始化DispatcherServlet,
      初始化springIOC容器,读取类路径下的spring-mvc.xml配置文件(target/classes/就会有这个配置文件),扫描controller注解下的RequestMapping的路径-->
      <param-name>contextConfigLocation</param-name>
<!--      在web.xml中加载springmvc.xml文件-->
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--  配置load-on-startup元素表示这个servlet应该是
    在启动时加载(实例化并调用其init())
    的web应用程序。-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <!--配置请求调度服务-->
  <servlet-mapping>
    <!--    配置调度服务-->
    <servlet-name>dispatcherServlet</servlet-name>

    <!--
        在spring中, / /*
        / : 匹配所有的请求
        /* :匹配所有的请求,查询结果页面,都是以文本显示,不会做任何的渲染页面,包括jsp页面
    -->

    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!--	配置过滤器,来解决post请求乱码问题-->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <!--        加载spring提供的过滤器-->
    <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>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.93.132:3306/test
jdbc.username=root
jdbc.password=root

spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--   扫描web相关的bean.SpringMVC会对这些bean进行特殊处理-->
    <context:component-scan base-package="com.fs.springssm.controller"/>
    <!-- 静态资源加载,核心控制器拦截的是所有请求,需要对静态资源请求进行放行,通过配置放行资源实现
       下面这个配置是可以放行所有的普通资源调用
       让springMVC不处理静态资源,如 .css  .js  .html  .MP3 等-->
    <mvc:default-servlet-handler/>
<!--    配置mvc注解驱动-->
    <mvc:annotation-driven/>

    <!--        配置视图解析器,方便访问jsp页面,并交给spring管理-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--       视图解析前缀(访问前缀)-->
        <property name="prefix" value="/WEB-INF/pages/"/>
        <!--       视图解析后缀(访问后缀)-->
        <property name="suffix" value=".jsp"/>
    </bean>

<!--    配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
<!--            拦截controller的所有请求-->
            <mvc:mapping path="/**"/>
<!--            登录页面不拦截-->
            <mvc:exclude-mapping path="/login"/>
<!--            配置自定义的拦截器-->
            <bean class="com.fs.springssm.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

springMybatis.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: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
       https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

<!--    引入properties-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--    配置德鲁伊连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>


<!--    配置SqlSessionFactoryBean-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--       给实体类起别名,方便MyBatis映射 -->
        <property name="typeAliasesPackage" value="com.fs.springssm.pojo"/>
   <!--配置分页插件pagehelper,若要使用分页就配置,不用就不用配置这个-->
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <props>
                            <prop key="helperDialect">mysql</prop>
                            <prop key="reasonable">true</prop>
                        </props>
                    </property>
                </bean>
            </array>
        </property>
    </bean>

<!--    配置映射扫描dao接口的包,由MyBatis动态代理生成实现类交给spring管理-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.fs.springssm.dao"/>
    </bean>

<!--   配置声明式事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
<!-- 注意:   开启事务驱动注解的支持,配合@Transactional使用-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

<!--    配置扫描包路径下的spring的Bean相关的注解交给springIOC容器中-->
    <context:component-scan base-package="com.fs.springssm"/>
<!--    引入其余的配置文件-->
    <import resource="classpath:spring-mvc.xml"/>
    <import resource="classpath:springMybatis.xml"/>
</beans>

实体类POJO

对应数据库中表的字段信息

Account

package com.fs.springssm.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Account {
    private Integer id;
    private String name;
    private Double money;
}

dao

AccountDao

package com.fs.springssm.dao;

import com.fs.springssm.pojo.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

public interface AccountDao {
    //增
    @Insert("INSERT INTO account(NAME,money) VALUE(#{name},#{money})")
    int addAccount(Account account);
    //删
    @Delete("DELETE FROM account WHERE id = #{id}")
    int delAccountById(Integer id);
    //改
    @Update("UPDATE account SET money = #{money} WHERE id = #{id}")
    int updateAccount(Account account);
    //查询所有
    @Select("select * from account")
    List<Account> findAccountAll();
    //根据id查询
    @Select("select * from account where id = #{id}")
    Account findAccountById(Integer id);
    //根据名字查询
    @Select("select * from account where name = #{name}")
    Account findAccountByName(String name);
}

service

AccountService

规范接口

package com.fs.springssm.service;

import com.fs.springssm.pojo.Account;
import com.github.pagehelper.PageInfo;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


public interface AccountService {
    //增
    int addAccount(Account account);
    //删
    int delAccountById(Integer id);
    //改
    int updateAccount(Account account);
    //查询所有
    List<Account> findAccountAll();
    //根据id查询
    Account findAccountById(Integer id);

    //使用分页插件分页查询
    PageInfo findPage(int pageNum,int pageSize);

    //对转账业务进行事务管理
    //转账业务
    @Transactional
    Boolean transferMoney(String nameA,String nameB,double money);
}

}

AccountServiceImpl

package com.fs.springssm.service.impl;

import com.fs.springssm.dao.AccountDao;
import com.fs.springssm.pojo.Account;
import com.fs.springssm.service.AccountService;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {

    //依耐dao层
    @Autowired
    private AccountDao accountDao;

    @Override
    public int addAccount(Account account) {
        return accountDao.addAccount(account);
    }

    @Override
    public int delAccountById(Integer id) {
        return accountDao.delAccountById(id);
    }

    @Override
    public int updateAccount(Account account) {
        return accountDao.updateAccount(account);
    }

    @Override
    public List<Account> findAccountAll() {
        return accountDao.findAccountAll();
    }

    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    //分页查询
    @Override
    public PageInfo findPage(int pageNum, int pageSize) {
        //分页数据设置
        PageHelper.startPage(pageNum,pageSize);
        //调用查询全部方法
        List<Account> accountAll = accountDao.findAccountAll();
        //获取分页数据
        PageInfo<Account> accountPageInfo = new PageInfo<>(accountAll);
        return accountPageInfo;
    }

    //转账业务
    @Override
    public Boolean transferMoney(String nameA, String nameB, double money) {
        //先把两个用户信息查出来
        Account name1 = accountDao.findAccountByName(nameA);
        Account name2 = accountDao.findAccountByName(nameB);
        //将1-money 2+money
        name1.setMoney(name1.getMoney() - money);
        name2.setMoney(name2.getMoney() + money);

        //然后更新两个用户
        int a = accountDao.updateAccount(name1);
        //制作异常
//        int i = 1 / 0;
        int b = accountDao.updateAccount(name2);
        //没有异常就返回true
        return a == b && b > 0;
    }
}

将返回的结果集封装成一个对象,然后将这个对象转成json返回到前端

ResultMapper

package com.fs.springssm.result;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResultMapper<T> {
    //响应回前端状态码
    private Integer code;
    //是否成功
    private Boolean flag;
    //数据(可以将查询出的数据封装到这里,任何数据都可以,因为是泛型)
    private T data;
    //消息
    private String message;

    public ResultMapper(Boolean flag, String message) {
        this.flag = flag;
        this.message = message;
        this.code = Code.DELETE_OK;
        this.data = null;
    }
}

Code 自定义状态码

package com.fs.springssm.result;

public class Code {
//    操作结果编码
    public static final Integer SAVE_OK = 20011;
    public static final Integer UPDATE_OK = 20021;
    public static final Integer DELETE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERROR = 20010;
    public static final Integer UPDATE_ERROR = 20020;
    public static final Integer DELETE_ERROR = 20030;
    public static final Integer GET_ERROR = 20040;

//    系统错误编码

//    操作权限编码

//    校验结果编码

}

自定义拦截器(需要在spring-mvc.xml配置才会生效)

MyInterceptor

package com.fs.springssm.interceptor;
/*
拦截器与过滤器有什么不同
    Interceptor拦截器是SpringMVC的技术,拦截控制的controller,拦截springIOC中的controller
    filter过滤器是tomcat中所有的接收到的请求都可以被拦截,包括spring中的controller

    //三个方法的运行顺序为    preHandle -> controller中被拦截的方法执行 ->postHandle -> afterCompletion
    //如果preHandle返回值为false，三个方法仅运行preHandle

    由HandlerInterceptor接口源码得知,方法被default修饰了(java8新特性)被默认实现了方法的,所以我们自定义拦截器没有强制我们重写接口中的方法
    所以我们需要自己重写接口中的方法实现自定义拦截器的具体功能

    HandlerInterceptor接口源码
    public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}
 */
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//自定义拦截器需要实现HandleInterceptor接口,实现这个接口没有被强制现实所有方法
//是因为HandlerInterceptor接口中的方法有默认的default实现方法,所以我们需要自己重写接口中的方法
public class MyInterceptor implements HandlerInterceptor {
    //处理器运行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request,//请求携带的request
                             HttpServletResponse response,//响应携带的Response
                             //handler就是我们执行的controller方法路径
                             Object handler) throws Exception {
        //下面打印的就是我们自己写的controller的方法,使用反射技术
        //public java.lang.String com.fs.springmvc.controller.InterceptorController.handleRun()
        ///System.out.println(handler.toString());
        System.out.println("前置运行----a1");
        //返回值为false将拦截原始处理器的运行,访问的controller中的方法不会被执行,
        //而且后面的postHandle,afterCompletion也不会执行
        //如果配置多拦截器，返回值为false将终止当前拦截器后面配置的拦截器的运行
        return true;
    }

    //处理器运行之后执行
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           //controller执行方法后要返回的视图ModelAndView
                           ModelAndView modelAndView) throws Exception {
        System.out.println("后置运行----b1");
    }

    //所有拦截器的后置执行全部结束后，执行该操作
    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                //
                                Exception ex) throws Exception {
        System.out.println("完成运行----c1");
    }

    //三个方法的运行顺序为    preHandle -> postHandle -> afterCompletion
    //如果preHandle返回值为false，三个方法仅运行preHandle
}

自定义异常通知,对ioc容器中bean的异常进行管理

ExceptionAdvice

package com.fs.springssm.exception;

import com.fs.springssm.result.Code;
import com.fs.springssm.result.ResultMapper;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;


@ControllerAdvice//表示为异常通知类,会对ioc中的所以类的异常进行统一管理
public class ExceptionAdvice {

    //异常处理方法,处理个大的,也可以细分
    @ExceptionHandler(Exception.class)
    @ResponseBody//将自定义的结果映射类返回给前端
    public ResultMapper exceptionHandle(Exception ex){
        //创建自定义的结果集,封装成json返回给前端
        ResultMapper<String> exceptionResultMapper = new ResultMapper<>();
        exceptionResultMapper.setCode(Code.DELETE_ERROR);
        exceptionResultMapper.setData("服务器发生异常啦");
        exceptionResultMapper.setMessage("服务器繁忙,请稍候再试~~~");
        //exceptionResultMapper.setMessage(ex.getMessage());
        exceptionResultMapper.setFlag(false);
        return exceptionResultMapper;
    }
}

controller

AccountController

package com.fs.springssm.controller;


import com.fs.springssm.pojo.Account;
import com.fs.springssm.result.Code;
import com.fs.springssm.result.ResultMapper;
import com.fs.springssm.service.AccountService;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RequestMapping("/account")
@RestController//@Controller@ResponseBody相当于这两个注解
public class AccountController {

    @Autowired
    private AccountService accountService;

    //添加
    @RequestMapping("/add")
    @ResponseBody//将返回的对象通过jackson转换成json传递到前端
    public ResultMapper<String> addAccount(@RequestBody Account account){//@RequestBody从请求体中获取json对象
        int i = accountService.addAccount(account);
        if (i>0) {
            return new ResultMapper<>(Code.DELETE_OK,true,"添加成功","成功");
        }else {
            return new ResultMapper<>(Code.GET_ERROR,false,"添加失败","失败");
        }
    }


    //查询所有
    @RequestMapping("/all")
    @ResponseBody
    public ResultMapper<List<Account>>  findAll(){
        List<Account> accountAll = accountService.findAccountAll();
        if (accountAll.size()!=0) {
            return new ResultMapper<>(Code.DELETE_OK,true,accountAll,"查询成功");
        }else {
            return new ResultMapper<>(Code.GET_ERROR,false,null,"查询结果为空");
        }
    }

    //分页查询
    @RequestMapping("/findPage")
    @ResponseBody
    public ResultMapper<PageInfo> findPage(int pageNum,int pageSize){
        //调用分页业务方法
        PageInfo page = accountService.findPage(pageNum, pageSize);
        if (page!=null) {
            return new ResultMapper<>(Code.DELETE_OK,true,page,"查询成功");
        }else {
            return new ResultMapper<>(Code.GET_ERROR,false,null,"查询结果为空");
        }
    }

    //转账
    @RequestMapping("/transfer")
    @ResponseBody
    public ResultMapper transferMoney(String nameA,String nameB,Double money){
        //调用转账方法
        Boolean aBoolean = accountService.transferMoney(nameA, nameB, money);
        //将结果封装到结果对象中
        ResultMapper resultMapper = new ResultMapper<>(aBoolean,"转账结果");
        return resultMapper;
    }

}

启动Tomcat测试ssm整合(使用Postman工具)

测试查询所有方法

http://localhost/account/all

在这里插入图片描述

测试添加方法

http://localhost/account/add
在这里插入图片描述

测试转账方法

http://localhost/account/transfer?nameA=小付&nameB=小花&money=100

正常转账成功

在这里插入图片描述

在业务层制造异常模拟转账失败

在业务层转账方法制作一个异常来测试声明式事务与自定义异常是否会执行

        //制作异常
        int i = 1 / 0;

然后重启tomcat

执行结果

在这里插入图片描述

努力敲代码买猪脚啃

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录