第一个SpringBoot程序

第一个springboot程序

使用idea新建工程，选择springboot initializr，勾选web一路next就搭建了一个最简单的springboot工程。如下：

package com.shy.springboot;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;

@springbootapplication
public class springbootapplication {

    public static void main(string[] args) {
        springapplication.run(springbootapplication.class, args);
    }
}

@springbootapplication整合了三个常用的注解，分别是：

• @componentscan：会自动扫描指定包下的全部标有@component的类，并注册成bean，当然包括@component下的子注解@service,@repository,@controller；
• @springbootconfiguration：可以当成spring的标准配置注解@configuration来使用。而@configuration表明这是一个javaconfig配置类。通常配合@bean注解，@bean注解告诉spring这个方法将返回一个对象，该对象将会注册为spring应用上下文中的bean；
• @enableautoconfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动根据你的类路径和你的bean定义自动配置。

配置文件相关

springboot的配置文件可以使用xml和yml格式，比如使用yml格式

# 自定义属性
cupsize: b
age: 18
# 可以在yml里通过${}来引用
content: "cupsize: ${cupsize}, age: ${age}"

# 指定端口为8080，（不配置默认8080）
server:
  port: 8080

可以使用注解@value("${...}")获取配置文件中的值，@value和@autowired注解作用类似。

spring提供了两种在运行时求值的方式：

• 属性占位符：${...}
• spring表达式语言(spel)：#{...}

如果cupsize和age都是属于同一类属性下的子属性，比如都属于girl。

那么可以写成下面的形式：

girl:
  cupsize: b
  age: 18

在java中注入时，也不用一个个属性注入，可以注入girl的全部属性。不过需要将girl的属性抽象成一个java类。

package com.shy.springboot.config;

import org.springframework.boot.context.properties.configurationproperties;
import org.springframework.stereotype.component;



/**
 * 读取配置文件的信息并自动封装成实体类
 * 注入springboot配置文件中前缀是"girl"的全部属性
 */
@component
@configurationproperties(prefix = "girl")
public class girlproperties {
    private string cupsize;
    private integer age;

    public string getcupsize() {
        return cupsize;
    }

    public integer getage() {
        return age;
    }
}

属性配置方式

• @value，从配置文件中注入属性
• @configurationproperties(prefix = "...")读取配置文件中对应前缀中的属性，并映射成对象实体

环境配置：

可以建立多个application-xxx.yml文件，然后在application.yml文件中配置其中一个环境.

比如我有application-dev.yml文件表示开发环境下的配置文件，application-prod.yml文件表示生产环境下的配置文件。那么再按application.yml中配置如下

spring:
  profiles:
    active: prod

就表示使用application-dev.yml中的配置。

一些常用注解

• controller，作用于类上，表示mvc中的控制层，可以被@componentscan扫描到并注入。用于处理http请求，返回字符串代表的模板,如xx.jsp, xx.ftl。
• @restcontroller，是@responsebody和@controller的整合，处理http请求，可以返回实体对象或字符串，以json格式表示。
• @resqustmapping，配置url映射。可以在类上使用（作为类中方法的前缀），可以在方法上使用。

package com.shy.springboot.controller;

import com.shy.springboot.config.girlproperties;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.requestmethod;
import org.springframework.web.bind.annotation.restcontroller;

@restcontroller
@requestmapping("/girl")
public class hello {
    /**
     * 表示value中的值都可作为url路径，如果不指定请求方法method，那么get和post方式都可以，但是一般不推荐 
     */
    @requestmapping(value = {"/hello", "/hi"}, method = requestmethod.get)
    public string hello() {
        return "hello";
    }
}

• @pathvariable，获取url路径中的数据
• @requstparam，获取请求参数中的值
• @getmapping，组合注解,是@requestmapping(value = "...", method = requestmethod.get)的缩写形式，当然也有postmapping了。

package com.shy.springboot.controller;

import com.shy.springboot.config.girlproperties;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;

@restcontroller
@requestmapping("/girl")
public class hello {
    // 可以响应 http://localhost:8080/girl/hello/xx
    @requestmapping(value = {"/hello/{id}"}, method = requestmethod.get)
    public string hello(@pathvariable("id") integer id) {
        return "my id is " + id;
    }
    // 可以响应 http://localhost:8080/girl/hello?id=xx
    // required = false表示这个参数可以为空，defaultvalue表示当参数为空时的默认值，因此访问http://localhost:8080/girl/hello，将使用默认值1。
    @requestmapping(value = {"/hello"}, method = requestmethod.get)
    public string hello2(@requestparam(value = "id", required = false,defaultvalue = "1") integer id) {
        return "my id is " + id;
    }
}
 

数据库配置

本例子使用jpa和mysql，所以在pom中加入如下依赖

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-jpa</artifactid>
</dependency>
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
</dependency>

在application.yml中配置数据源和jpa相关。

spring:
  profiles:
    active: dev
  # 以下使用了jpa和mysql  
  datasource:
    driver-class-name: com.mysql.jdbc.driver
    url: jdbc:mysql://127.0.0.1:3306/dbgirl
    username: root
    password: admin
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true

jpa(java persistence api)，即java持久化api，hibernate实现了这个规范。

package com.shy.springboot.database;

import javax.persistence.entity;
import javax.persistence.generatedvalue;
import javax.persistence.id;

@entity
public class girl {
    @id
    @generatedvalue(strategy = generationtype.identity)
    private integer id;
    private integer age;
    private string cupsize;

    public integer getid() {
        return id;
    }

    public void setid(integer id) {
        this.id = id;
    }

    public integer getage() {
        return age;
    }

    public void setage(integer age) {
        this.age = age;
    }

    public string getcupsize() {
        return cupsize;
    }

    public void setcupsize(string cupsize) {
        this.cupsize = cupsize;
    }

    public girl() {
    }
}

• @entity 表示这是个实体类，可以映射成数据表。
• @id表示该属性为主键
• @generatedvalue表示该属性字段为自增，一般搭配@id使用

@generatedvalue有几种策略

• identity：采用数据库id自增长的方式来自增主键字段，oracle 不支持这种方式，使用mysql时，配置该策略可以实现主键自增。
• auto：jpa自动选择合适的策略，是默认选项；
• sequence：通过序列产生主键，通过@sequencegenerator 注解指定序列名，mysql不支持这种方式 ；
• table：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植；

jpa.hibernate.ddl-auto，共有五种配置方式。

• ddl-auto:create: 每次运行该程序，没有表格会新建表格，表内有数据会清空
• ddl-auto:create-drop: 每次程序结束的时候会清空表
• ddl-auto:update: 每次运行程序，没有表格会新建表格，若已经存在表格，则只会更新
• ddl-auto:validate: 运行程序会校验数据与数据库的字段类型是否相同，不同会报错
• none: 禁止ddl处理

controller和几个简单的请求

repository提供了最基本的数据访问功能，通过新建一个接口继承jparepository<t, id>，可以直接使用接口中现成的方法来实现对数据的访问。

package com.shy.springboot.database;

import org.springframework.data.jpa.repository.jparepository;

import java.util.list;

public interface girlrepo extends jparepository<girl, integer> {
    // 自定义的查询方法，方法名要严格按照一定规则来命名
    list<girl> findbyage(integer age);
}

泛型中的girl表示该repository可以访问由girl映射的数据表，integer表示id的数据类型。

写一个controller，处理各种请求来看jpa是如何与数据库交互的。

package com.shy.springboot.controller;

import com.shy.springboot.database.girl;
import com.shy.springboot.database.girlrepo;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;

import java.util.list;

@restcontroller
public class girlcontroller {

    @autowired
    private girlrepo girlrepo;

    /**
     * 查询所有女生
     * @return
     */
    @getmapping("/girls")
    public list<girl> girls() {
        return girlrepo.findall();
    }

    /**
     * 添加一个女生
     * @param cupsize
     * @param age
     * @return
     */
    @postmapping("/addgirl")
    public girl addgirl(@requestparam("cupsize") string cupsize,
                        @requestparam("age") integer age) {

        girl girl = new girl();
        girl.setage(age);
        girl.setcupsize(cupsize);
        return girlrepo.save(girl);
    }

    /**
     * 通过id更新一个女生
     * @param id
     * @param cupsize
     * @param age
     * @return
     */
    @postmapping("/updategirl/{id}")
    public girl updategirl(@pathvariable("id") integer id,
                           @requestparam("cupsize") string cupsize,
                           @requestparam("age") integer age) {

        girl girl = new girl();
        girl.setid(id);
        girl.setage(age);
        girl.setcupsize(cupsize);
        return girlrepo.save(girl);
    }

    /**
     * 根据id删除一个女生
     * @param id
     */
    @getmapping("/deletegirl/{id}")
    public void deletegirl(@pathvariable("id") integer id) {
        girl girl = new girl();
        girl.setid(id);
        girlrepo.delete(girl);
    }

    /**
     * 根据id查询一个女生
     * @param id
     * @return
     */
    @getmapping("girls/{id}")
    public girl girlfindone(@pathvariable("id") integer id) {
        return girlrepo.findbyid(id).get();
    }

    /**
     * 根据年龄查询一个女生
     * @param age
     * @return
     */
    @getmapping("girls/age/{age}")
    public list<girl> findgirlsbyage(@pathvariable("age") integer age) {
        return girlrepo.findbyage(age);
    }
}

没有写一句sql语句，就完成了对girl表的增删改查，用起来还是很舒服的。

事务管理

下面的inserttwo方法插入两条数据，如果不进行事务管理，则插入girla成功，插入girlb失败。加上@transactional注解后（有两个同名注解，导入spring的），要么两条数据都插入成功，要么两条都插入失败。因为在本例中会出现异常，所以两条都插入失败。

// service中
package com.shy.springboot.service;

import com.shy.springboot.database.girl;
import com.shy.springboot.database.girlrepo;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import org.springframework.transaction.annotation.transactional;

@service
public class girlservice {
    @autowired
    private girlrepo girlrepo;
    @transactional
    public void inserttwo() {
        girl girla = new girl();
        girla.setcupsize("b");
        girla.setage(18);
        girlrepo.save(girla);
        // 除0异常，退出
        int a = 3 / 0;
        girl girlb = new girl();
        girlb.setcupsize("c");
        girlb.setage(20);
        girlrepo.save(girlb);
    }
}

// controller中
@postmapping("/girls/inserttwo")
    public void inserttwo() {
        girlservice.inserttwo();
}

因为hibernate创建的表默认引擎是myisam，所以如果发现事务没有作用，要手动修改引擎为innodb。

alter table xxx engine=innodb;

表单验证

在上面的例子中如果要对年龄作限制，比如小于18岁的girl不能添加。可以在实体类中对其中的字段属性使用注解来加以限制。

@min(value = 18, message = "未满18岁不得入内！")
private integer age;

这句代码限制了girl的年龄不能低于18岁。在controller中修改添加女生的逻辑

/**
 * 添加一个女生
 * @return
 */
@postmapping("/addgirl")
public girl addgirl(@valid girl girl, bindingresult result) {
    if (result.haserrors()) {
        system.out.println(result.getfielderror().getdefaultmessage());
        return null;
    }
    return girlrepo.save(girl);
}

@valid可以对对象进行验证，加了@valid注解的参数，其后要紧跟着bindingresult或者errors（前者是后者的实现类），用于保存验证结果。如果对象中有属性不满足验证条件，其结果将体现中bindingresult中。

aop

首先在pom中添加依赖

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-aop</artifactid>
</dependency>

然后编写切面

package com.shy.springboot.aspect;

import org.aspectj.lang.annotation.after;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.aspectj.lang.annotation.pointcut;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;

@aspect
@component
public class httpaspect {
    private static final logger log = loggerfactory.getlogger(httpaspect.class);

    @pointcut("execution(public * com.shy.springboot.controller.girlcontroller.*(..))")
    public void log() {}

    @before("log()")
    public void dobefore() {
        log.info("我在方法调用前执行");
    }

    @after("log()")
    public void doafter() {
        log.info("我在方法调用后执行");
    }

}

因为在方法调用的前后都要对相同的方法进行通知，为了避免代码冗余，把@before和@after的execution表达式抽取成切点。

@pointcut("execution(public * com.shy.springboot.controller.girlcontroller.*(..))")

表示对girlcontroller中所有public的任意返回值、任意参数的方法进行通知。注意该注解需要用在方法上，所以public log() {}在这里只是起一个标识作用，供@pointcut依附，所以它的方法体是空的。

该切面使用了slf4j的日志。当请求http://localhost:8080/addgirl时，控制台输出以下日志，可以显示比system.out.println()更详细的信息。

2018-10-03 10:03:46.899  info 1892 --- [nio-8080-exec-3] com.shy.springboot.aspect.httpaspect     : 我在方法调用前执行
hibernate: insert into girl (age, cup_size) values (?, ?)
2018-10-03 10:03:47.031  info 1892 --- [nio-8080-exec-3] com.shy.springboot.aspect.httpaspect     : 我在方法调用后执行

输出的hibernate: insert into girl (age, cup_size) values (?, ?)表示了controller中addgirl方法的执行，在其前后分别输出了@before和@after执行的逻辑，所以aop确实是生效了的。

现在修改dobefore方法，使它能从request域中获取请求url、ip地址、请求方法、请求中传递的参数。

@aspect
@component
public class httpaspect {
    private static final logger log = loggerfactory.getlogger(httpaspect.class);

    @pointcut("execution(public * com.shy.springboot.controller.girlcontroller.*(..))")
    public void log() {}

    @before("log()")
    public void dobefore(joinpoint joinpoint) {
        servletrequestattributes attributes = (servletrequestattributes) requestcontextholder.getrequestattributes();
        httpservletrequest request = attributes.getrequest();
        // url
        log.info("url={}", request.getrequesturi());
        // ip
        log.info("ip={}", request.getremoteaddr());
        // method
        log.info("method={}", request.getmethod());
        // 参数
        log.info("args={}", joinpoint.getargs());
        // class-method
        log.info("class_method={}", joinpoint.getsignature().getdeclaringtypename() + " " + joinpoint.getsignature().getname());

        log.info("我在方法调用前执行");
    }

    @afterreturning(value = "log()",returning = "obj")
    public void doafterreturning(object obj) {
        if (obj != null) {
            log.info("girl={}", obj.tostring());
        }
    }

    @after("log()")
    public void doafter() {
        log.info("我在方法调用后执行");
    }

}

在通知方法中可以声明一个joinpoint类型的参数，通过joinpoint可以访问连接点的细节。

• getargs()：获取连接点方法运行时的入参列表；
• getsignature() ：获取连接点的方法签名对象；
• getsignature().getname()：获取连接点的方法名
• getsignature().getdeclaringtypename()：获取连接点所在类的名称

还新增了一个@afterreturning的通知，在方法成功返回后执行（若抛出异常将不会执行该通知），和@after的区别在于：被增强的方法不论是执行成功还是抛出异常，@after通知方法都会得到执行。

aop中 @before @after @afterthrowing @afterreturning的执行顺序如下：

public object invoke(object proxy, method method, object[] args) throws throwable {
   object result;
   try {
       // @before
       result = method.invoke(target, args);
       // @after
       return result;
   } catch (invocationtargetexception e) {
       throwable targetexception = e.gettargetexception();
       // @afterthrowing
       throw targetexception;
   } finally {
       // @afterreturning
   }
}

可知@afterreturning的执行在@after之后。

如果请求http://localhost:8080/addgirl，将输出以下日志（日志一些无关紧要的内容已被删除）

url=/addgirl
ip=0:0:0:0:0:0:0:1
method=post
args=girl{id=null, age=26, cupsize='c'}
class_method=com.shy.springboot.controller.girlcontroller addgirl
我在方法调用前执行
hibernate: insert into girl (age, cup_size) values (?, ?)
我在方法调用后执行
girl=girl{id=27, age=26, cupsize='c'}

统一异常处理

前面的addgirl方法，当验证不通过时，返回null并在控制台打印相关信息；当验证通过又返回girl。返回值不统一，而且如果我们希望将错误信息显示在页面，怎么办呢？

可定义一个result<t>，将要呈现的信息统一化，分别是错误码code，错误信息msg和承载的对象t，这样不管是成功还是发生各种各样的异常，都可以返回统一的result对象。

package com.shy.springboot.domain;

public class result<t> {
    /** 错误码 */
    private integer code;
    /** 信息 */
    private string msg;
    /** 对象 */
    private t data;

    public integer getcode() {
        return code;
    }

    public void setcode(integer code) {
        this.code = code;
    }

    public string getmsg() {
        return msg;
    }

    public void setmsg(string msg) {
        this.msg = msg;
    }

    public t getdata() {
        return data;
    }

    public void setdata(t data) {
        this.data = data;
    }
}

再写一个工具类，可在成功和异常时候设置对应的状态和信息，可有效减少重复代码。

package com.shy.springboot.util;

import com.shy.springboot.domain.result;

public class resultutil {
    public static result success(object obj) {
        result result = new result();
        result.setmsg("成功");
        result.setcode(0);
        result.setdata(obj);
        return result;
    }

    public static result success() {
        return success(null);
    }

    public static result error(integer code, string msg) {
        result result = new result();
        result.setmsg(msg);
        result.setcode(code);
        return result;
    }
}

于是我们的addgirl方法可以重构成下面的样子

@postmapping("/addgirl")
public result<girl> addgirl(@valid girl girl, bindingresult bindingresul) {
    if (bindingresul.haserrors()) {
        return resultutil.error(1,bindingresul.getfielderror().getdefaultmessage());
    }
    girlrepo.save(girl);
    return resultutil.success(girl);
}

现在新增一个检查年龄的逻辑，小于14岁的认为在上小学，14~17岁认为在上初中，这两种情况都不允许其进入，当检查到年龄不符合要求时，抛出异常。

在girlservice中

public void checkage(integer id) {
    girl girl = girlrepo.findbyid(id).get();
    int age = girl.getage();
    if (age < 14) {
        throw new girlexception(resultenum.primary_school);
    } else if (age < 17) {
        throw new girlexception(resultenum.middle_school);
    }
    // 其他年龄的逻辑处理
}

注意上面使用枚举来统一管理各种code对应的msg。

package com.shy.springboot.enums;

public enum resultenum {
    success(0, "成功"),
    error(-1, "未知错误"),
    primary_school(100, "你可能还在上小学"),
    middle_school(101, "你可能还在上初中");

    private integer code;
    private string msg;

    resultenum(integer code, string msg) {
        this.code = code;
        this.msg = msg;
    }

    public integer getcode() {
        return code;
    }

    public string getmsg() {
        return msg;
    }
}

girlexception是个自定义异常类，除了message还把code整合进去了。

package com.shy.springboot.exception;

import com.shy.springboot.enums.resultenum;

public class girlexception extends runtimeexception{
    private integer code;

    public girlexception(resultenum resultenum) {
        super(resultenum.getmsg());
        this.code = resultenum.getcode();
    }

    public integer getcode() {
        return code;
    }

    public void setcode(integer code) {
        this.code = code;
    }
}

在controller中只是简单调用下service中的方法而已

@getmapping("/girlage/{id}")
public void getage(@pathvariable("id") integer id) {
    girlservice.checkage(id);
}

如果现在启动程序，请求http://localhost:8080/girlage/22, 将按照自定义异常，但是返回的结果其格式是下面这样的：

{
    timestamp: 14xxxxxxx,
    status: 500,
    exception: xxx,
    message: xxx,
    path: "/girlage/22"
}

因为系统内部发生了错误，不断往上抛异常就会得到上面的信息。如果要保持不管在什么情况下统一返回result<t>中的信息，像下面这样：

{
    code: xxx,
    msg: xxx,
    data: xxx
}

则需要对异常做一个捕获，取出有用的message部分，然后再封装成result对象，再返回给浏览器。为此新建一个异常捕获类

package com.shy.springboot.handle;

import com.shy.springboot.domain.result;
import com.shy.springboot.exception.girlexception;
import com.shy.springboot.util.resultutil;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.web.bind.annotation.controlleradvice;
import org.springframework.web.bind.annotation.exceptionhandler;
import org.springframework.web.bind.annotation.responsebody;

/**
 * controlleradvice注解将作用在所有注解了@requestmapping的控制器的方法上。
 * 配合@exceptionhandler，用于全局处理控制器里的异常
 */
@controlleradvice
public class exceptionhandle {
    private static final logger log = loggerfactory.getlogger(exceptionhandle.class);

    @exceptionhandler(exception.class)
    @responsebody
    public result handle(exception e) {
        if (e instanceof girlexception) {
            girlexception exception = (girlexception) e;
            return resultutil.error(exception.getcode(),exception.getmessage());
        }
        log.error("系统异常：{}", e.getmessage());
        return resultutil.error(-1,"未知错误");
    }
}

该类使用了注解@controlleradvice，@controlleradvice会作用在所有注解了@requestmapping的控制器的方法上，再配合@exceptionhandler，用于全局处理控制器里的异常。@exceptionhandler(exception.class)表示可以处理exception类及其子类。

因为除了会抛出自定义异常girlexception外，还有可能因为系统原因抛出其他类型的异常（如空指针异常），因此针对不同类型的异常返回不同的状态码，上面使用了instanceof来判断异常类型。如果不是girlexception，被统一归类为未知错误，但是各种异常都显示未知错误不便于排查问题，因此在可控制台输出了异常原因来加以区分。

单元测试

springboot中进行单元测试十分便捷，springboot中默认使用了junit4。

在src/test下可以创建单元测试类，当然更简单的方法是在idea下右键，go to -> test subject，然后选择想要进行测试的方法即可。

下面的单元测试针对service层，主要是判断某数据库中某id的girl，其年龄实际值和预期值是否一致。有两个比较关键的注解

• @runwith(springrunner.class)：当一个类用@runwith注释或继承一个用@runwith注释的类时，junit将调用它所引用的类来运行该类中的测试而不是开发者去在junit内部去构建它，因此这句代码意思是让测试运行于spring测试环境中，springrunner仅仅继承了springjunit4classrunner而已，并没有扩展什么功能，前者可以看作是后者的“别名”。
• @springboottest：可以自动搜寻@springbootconfiguration；在没有明确指定@contextconfiguration(loader=...)时，使用springbootcontextloader作为默认的contextloader，等等。

package com.shy.springboot.service;

import com.shy.springboot.domain.girl;
import com.shy.springboot.repository.girlrepo;
import org.junit.assert;
import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.context.springboottest;
import org.springframework.test.context.junit4.springrunner;

/**
 * runwith(springrunner.class),让测试运行于spring测试环境
 */
@runwith(springrunner.class)
@springboottest
public class girlservicetest {
    @autowired
    private girlrepo girlrepo;
    @test
    public void findone() {
        girl girl = girlrepo.findbyid(22).get();
        assert.assertequals(new integer(14), girl.getage());
    }
}

然后针对controller层，对某次请求进行测试，这里使用到了mockmvc。

package com.shy.springboot.controller;

import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.autoconfiguremockmvc;
import org.springframework.boot.test.context.springboottest;
import org.springframework.test.context.junit4.springrunner;
import org.springframework.test.web.servlet.mockmvc;
import org.springframework.test.web.servlet.request.mockmvcrequestbuilders;
import org.springframework.test.web.servlet.result.mockmvcresultmatchers;
@runwith(springrunner.class)
@springboottest
@autoconfiguremockmvc
public class girlcontrollertest {
    @autowired
    private mockmvc mockmvc;
    @test
    public void girls() throws exception {
        mockmvc.perform(mockmvcrequestbuilders.get("/girls")).andexpect(mockmvcresultmatchers.status().isok());
        /* 下面这条测试不能通过 */
        // mockmvc.perform(mockmvcrequestbuilders.get("/girls")).andexpect(mockmvcresultmatchers.content().string("abc"));
    }
}

第一条测试模拟以get方法请求/girls，并期望状态码是200 ok。注释掉的第二条测试期望响应的内容是abc，然而我们返回的是json格式，所以肯定不能通过测试的。

---

2018.10.4

如对本文有疑问， 点击进行留言回复！！