SpringBoot框架集成JUnit单元测试

最新推荐文章于 2024-02-19 15:12:35 发布

编程侠Java

最新推荐文章于 2024-02-19 15:12:35 发布

阅读量694

点赞数

分类专栏： Java基础文章标签： junit 单元测试 spring boot

本文链接：https://blog.csdn.net/u012082876/article/details/126390693

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

在开发过程中，有时候需要对正在开发的某些功能进行测试。我们可以使用很多种方式，这里概括介绍对比几种方式。
在这里插入图片描述
第一种就是在当前类中新建一个main方法，在main方面里面调用集成的功能，这种方式简单，但是局限性比较多，主要有以下缺点：

/**
 * 静态方法
 * @param str1
 * @return
 */
public static String function1(String str1){
    log.info("静态方法："+str1);
    return str1;
}

/**
 * 非静态方法
 * @param str2
 */
public String function2(String str2){
    log.info("非静态方法："+str2);
    return str2;
}


public static void main(String args[]){
    log.info("调用静态方法："+function1("1"));
    log.info("调用静态方法："+function2("2"));//报错：Non-static method 'function2(java.lang.String)' cannot be referenced from a static context
}

（1）当前类中只能有一个main方法，如果开发完某一功能再测试另外一个功能，每次都要修改main方法里面的内容，特别是不方便进行来回切换测试。
（2）main方法不能直接调用service层或者dao层的方法，虽然可以通过上下文的工具类来进行调用，无形之中需要额外编写很多代码，并且这种单元测试的方式与原本的业务实现方式已经有所偏离。失去了进行单元测试的意义。因为原有的功能就是直接调用service层或者dao层的方法，在main方法中进行单元测试却换了另外一种方式调用。
（3）main方法申明的方式是：public static void main，由此可以看出main方法是一个static静态方法，所以在main方法里面无法调用非静态方法，因为Java中的静态方法不能调用非静态方法。具体解释就是：静态方法是属于类的，即静态方法是随着类的加载而加载的，在加载类时，程序就会为静态方法分配内存，而非静态方法是属于对象的，对象是在类加载之后创建的，也就是说静态方法先于对象存在。当你创建一个对象时或者说对象初始化之后，程序才会为其在堆中分配内存，也就是说对于非静态方法，在对象创建的时候程序才会为其分配内存，然后通过类的对象去访问非静态方法。这也就解释了静态方法为什么不能调用非静态方法，因为对象未存在时非静态方法也不存在，静态方法自然不能调用一个不存在的方法，造成资源还没准备好就直接去调用的矛盾。
第二种方式，就是封装成接口，然后把项目运行起来，模拟调用一下接口。这种方式虽然实现起来比较简单，但操作起来比较繁琐，主要有以下原因：

import com.mtons.mblog.shiro.AccountRealm;
import com.mtons.mblog.shiro.AccountSubjectFactory;
import com.mtons.mblog.shiro.AuthenticatedFilter;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.mgt.SubjectFactory;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * shiro权限管理的配置
 *
 * @author 编程侠
 */
@Configuration
@ConditionalOnProperty(name = "shiro.web.enabled", matchIfMissing = true)
public class ShiroConfiguration {
    @Bean
    public SubjectFactory subjectFactory() {
        return new AccountSubjectFactory();
    }

    @Bean
    public Realm accountRealm() {
        return new AccountRealm();
    }

    @Bean
    public CacheManager shiroCacheManager(net.sf.ehcache.CacheManager cacheManager) {
        EhCacheManager ehCacheManager = new EhCacheManager();
        ehCacheManager.setCacheManager(cacheManager);
        return ehCacheManager;
    }

    /**
     * Shiro的过滤器链
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);
        shiroFilter.setLoginUrl("/login");
        shiroFilter.setSuccessUrl("/");
        shiroFilter.setUnauthorizedUrl("/error/reject.html");

        HashMap<String, Filter> filters = new HashMap<>();
        filters.put("authc", new AuthenticatedFilter());
        shiroFilter.setFilters(filters);

        /**
         * 配置shiro拦截器链
         *
         * anon  不需要认证
         * authc 需要认证
         * user  验证通过或RememberMe登录的都可以
         *
         * 顺序从上到下,优先级依次降低
         *
         */
        Map<String, String> hashMap = new LinkedHashMap<>();
        hashMap.put("/dist/**", "anon");
        hashMap.put("/theme/**", "anon");
        hashMap.put("/storage/**", "anon");
        hashMap.put("/login", "anon");
        hashMap.put("/interfaceTest/**", "anon");//单独开发指定的接口
        hashMap.put("/user/**", "authc");
        hashMap.put("/settings/**", "authc");
        hashMap.put("/post/editing", "authc");
        hashMap.put("/post/submit", "authc");
        hashMap.put("/post/delete/*", "authc");
        hashMap.put("/post/upload", "authc");

        hashMap.put("/admin/channel/list", "authc,perms[channel:list]");
        hashMap.put("/admin/channel/update", "authc,perms[channel:update]");
        hashMap.put("/admin/channel/delete", "authc,perms[channel:delete]");

        hashMap.put("/admin/post/list", "authc,perms[post:list]");
        hashMap.put("/admin/post/update", "authc,perms[post:update]");
        hashMap.put("/admin/post/delete", "authc,perms[post:delete]");

        hashMap.put("/admin/comment/list", "authc,perms[comment:list]");
        hashMap.put("/admin/comment/delete", "authc,perms[comment:delete]");

        hashMap.put("/admin/user/list", "authc,perms[user:list]");
        hashMap.put("/admin/user/update_role", "authc,perms[user:role]");
        hashMap.put("/admin/user/pwd", "authc,perms[user:pwd]");
        hashMap.put("/admin/user/open", "authc,perms[user:open]");
        hashMap.put("/admin/user/close", "authc,perms[user:close]");

        hashMap.put("/admin/options/index", "authc,perms[options:index]");
        hashMap.put("/admin/options/update", "authc,perms[options:update]");

        hashMap.put("/admin/role/list", "authc,perms[role:list]");
        hashMap.put("/admin/role/update", "authc,perms[role:update]");
        hashMap.put("/admin/role/delete", "authc,perms[role:delete]");

        hashMap.put("/admin/theme/*", "authc,perms[theme:index]");

        hashMap.put("/admin", "authc,perms[admin]");
        hashMap.put("/admin/*", "authc,perms[admin]");

        shiroFilter.setFilterChainDefinitionMap(hashMap);
        return shiroFilter;
    }

}

（1）每次修改代码，为了测试都需要把项目运行起来，等待项目启动也是一个比较耗时的过程，有些项目有各种不同环境的配置，要使项目在本地能顺利运行，得保证有一套本地可以访问的配置。
（2）项目启动运行之后，接口一般都有拦截，可以登录成功之后再调用接口，也可以把当前的接口设置取消拦截，在ShiroFilterFactoryBean里面设置anon不需要认证。这两种方式都不太可取，第一种方式每次都需要登录之后才能模拟调用，第二种方式修改了底层代码，如果误提交上线，该接口就存在安全隐患，无任何拦截。
第三种方式，就是集成junit单元测试，小编比较推荐这种，当然这种方式也有利有弊，先说一下弊端：
（1）junit单元测试的方法只能申明为void，并且不能携带请求参数，这也意味着参数需要写到方法里面，或者提前申明参数，反复测试时可能就需要手动修改参数。
（2）如果你在业务代码中记录日志使用到了如logback技术,在junit单元测试方法里面不能直接使用，有方法可以实现但比较繁琐。
（3）junit单元测试方法里面无法调用非静态方法，只能调用静态方法。
虽然有这些缺陷，但他的优点更突出，主要就是：不需要修改原来任何的业务代码、不需要启动项目就可以直接运行测试方法，多个方法都可以单独测试、可以自由切换环境进行测试等。接下来就重点讲解一下junit单元测试。
1、集成maven依赖，在pom.xml中加入以下代码：

<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
   <scope>test</scope>
</dependency>

2、Springboot项目集成junit单元测试，新建test目录文件夹，与main目录同级，结构层次如下
在这里插入图片描述

3、编写测试代码，模板如下：

import com.alibaba.fastjson.JSON;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.alipay.demo.trade.config.Configs;
import com.alipay.demo.trade.model.ExtendParams;
import com.alipay.demo.trade.model.GoodsDetail;
import com.alipay.demo.trade.model.builder.AlipayTradePrecreateRequestBuilder;
import com.alipay.demo.trade.model.result.AlipayF2FPrecreateResult;
import com.alipay.demo.trade.utils.ZxingUtils;
import com.cn.cy.SpringbootApplication;
import com.cn.cy.common.enums.OrderStatus;
import com.cn.cy.config.AlipayScanConfig;
import com.cn.cy.redis.service.IRedisBaseService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static com.cn.cy.controller.Alipay.AlipayScanController.tradeService;

/**
 * 在类上面加上@SpringBootTest注解。
 * 使用@SpringBootTest的时候，需要用classes指定启动类的名字
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootApplication.class)
@ActiveProfiles("dev")
public class AlipayScanTest {

    private final Logger log = LoggerFactory.getLogger(AlipayScanTest.class);

    @Autowired
    private AlipayScanConfig alipayScanConfig;

    @Autowired
    IRedisBaseService redisBaseService;

    /**
     * junit测试方法——不带请求参数、无返回值
     */
    @Test
    public void precreateOrder()  {
        try {
            String outTradeNo = "AliPay" + new Date().getTime();//订单号
            String subject = "测试订单名称";//订单名称
            String totalAmount = "0.03";//订单金额，如果单位是分，则需要转换为元，我这里使用的是元
            String body = "订单描述";//订单描述，可以对交易或商品进行一个详细地描述
            
            String operatorId = "test_operator_id";//操作员编号，很重要的参数，可以用作之后的营销
            String storeId = "test_store_id";//门店编号，很重要的参数，可以用作之后的营销

            ExtendParams extendParams = new ExtendParams();
            extendParams.setSysServiceProviderId(Configs.getPid());//商户号

            // 商品明细列表
            List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();
            GoodsDetail goodsDetail = new GoodsDetail();
            goodsDetail.setGoodsId("goodsId");
            goodsDetail.setGoodsName("测试商品");
            goodsDetail.setPrice(1);
            goodsDetail.setQuantity(1);
            goodsDetailList.add(goodsDetail);

            AlipayTradePrecreateRequestBuilder builder = (new AlipayTradePrecreateRequestBuilder()).setSubject(subject)
                    .setTotalAmount(totalAmount).setOutTradeNo(outTradeNo).setBody(body)
                    .setOperatorId(operatorId).setStoreId(storeId)
                    .setExtendParams(extendParams).setTimeoutExpress(alipayScanConfig.getTimeoutExpress())
                    .setNotifyUrl(alipayScanConfig.getNotifyUrl()).setGoodsDetailList(goodsDetailList);

            //发起向支付宝服务端预创建请求，并返回创建结果
            AlipayF2FPrecreateResult alipayF2FPrecreateResult = tradeService.tradePrecreate(builder);
            log.info("预创建订单响应内容：" + JSON.toJSONString(alipayF2FPrecreateResult));
            switch (alipayF2FPrecreateResult.getTradeStatus()) {
                case SUCCESS:
                    redisBaseService.setValue(outTradeNo, OrderStatus.pre_create.getCode(), 1);
                    log.info(outTradeNo + "支付宝订单预创建成功");
                    AlipayTradePrecreateResponse alipayTradePrecreateResponse = alipayF2FPrecreateResult.getResponse();
                    String filePath = String.format(alipayScanConfig.getDownloadPath() +"/qr-%s.png", new Object[] { alipayTradePrecreateResponse.getOutTradeNo() });
                    //将二维码保存到本地filePath目录
                    ZxingUtils.getQRCodeImge(alipayTradePrecreateResponse.getQrCode(), 256, filePath);
                    break;
                case FAILED:
                    log.error(outTradeNo + "支付宝预下单失败");
                    break;
                case UNKNOWN:
                    log.error(outTradeNo + "支付宝预下单，系统异常，预下单状态未知");
                    break;
                default:
                    log.error(outTradeNo + "支付宝预下单,不支持的交易状态，交易返回异常");
                    break;
            }
        } catch (Exception e) {
            log.error("系统抛出异常");
        }
    }
}

详细说明：
（1）junit单元测试类上要加一些注解，主要注解说明如下：
@RunWith就是一个运行器，@RunWith(SpringRunner.class)指让类运行在Spring的测试环境，以便测试开始时自动创建Spring应用上下文。
@SpringBootTest替代了spring-test中的@ContextConfiguration注解，目的是加载ApplicationContext，启动spring容器。
@ActiveProfiles指定配置环境，我设置了四种环境，开发【dev】、测试【test】、演示【uat】和生产【pro】。在@ActiveProfiles注解上指定对应的配置就会使用对应的配置参数来执行方法。

（2）日志记录，最开始已经说明了在junit单元测试方法里面不能直接使用logback，我改用通用类日志LoggerFactory，也可以实现控制台的日志打印。
（3）在junit单元测试方法上，需要添加注解@Test，他的作用就是该方法可以不用main方法调用就可以测试出运行结果，是一种测试方法。
（4）在junit测试方法里面可以直接调用service方法或者dao层方法，跟正常的控制类controller里面调用一样。
（5）junit测试方法里面只能调用静态方法。
（6）junit测试方法不能带参，无返回值。
注意事项：有些项目在启动时需要去加载一些配置文件，比如我在项目启动时需要加载支付宝的参数文件zfbinfo_dev.properties，加载完之后才能获取到参数。在junit单元测试类中就不需要再去重写这个方法，如果重写反而获取不到参数，返回是空。

编程侠Java

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot框架集成JUnit单元测试

Springboot框架集成junit，不需要修改原来任何的业务代码、不需要启动项目就可以直接运行测试方法，多个方法都可以单独测试、可以自由切换环境进行测试，方便进行业务的单元测试。
复制链接

扫一扫