为什么每次调用 Spring MVC 服务中的简单方法都比静态方法慢？

Question

在 SpringMVC 服务中进入一个方法和退出该方法花费了太多毫秒。但是，如果我将方法修改为静态，则只需 1 毫秒。 我们的项目是一个SpringMVC-Mybatis项目。我发现控制器进入一个服务方法和退出该方法大约需要70毫秒。 该方法从具有 128 个键的静态映射中获取值。

@Controller 
public class OrdersController extends BaseAction
{
    @Autowired(required=false)
    private CompanyService<Company> companyService; 

    public void validateInfo()
    {
            Company company = CompanyService.queryByIdFromCache(account);// cost about 70 milliseconds, but if the method is static it is 1 milliseconds.
    }

}

@Service("companyService")
public class CompanyService<T> extends BaseService<T> 
{

    private static ConcurrentMap<Integer, Company>cache = new ConcurrentHashMap<>(); //map with 128 keys

    public Company queryByIdFromCache(Integer id)
    {
        return cache.get(id);
    }
}

我希望该方法在 2 毫秒内完成。 该服务在单例模式下工作。和 companyService 是同一个实例。 我不想把所有的方法都改成静态方法，因为有些代码必须用非静态的方式调用。

Answer 1

很可能是切面拦截了对非静态服务方法的调用。

有几种方法可以分析执行情况并找到服务调用的热点。我使用 NetBeans 的 Test Profiler 重现了这个问题。

首先，我创建了静态（组件）和非静态服务：

@Service
public class DemoService {

    private static final ConcurrentMap<Integer, String> CACHE = new ConcurrentHashMap<>();

    public DemoService() {
        for (int i = 0; i < 128; i++) {
            CACHE.put(i, String.valueOf(i));
        }
    }

    public String queryByIdFromCache(Integer id) {
        return CACHE.getOrDefault(id, "");
    }

}


public class DemoStaticService {

    private static final ConcurrentMap<Integer, String> CACHE = new ConcurrentHashMap<>();


    static {
        for (int i = 0; i < 128; i++) {
            CACHE.put(i, String.valueOf(i));
        }
    }

    public static String queryByIdFromCache(Integer id) {
        return CACHE.getOrDefault(id, "");
    }

}

然后我创建了一个控制器，其中包含两个操作，一个调用非静态注入服务，另一个调用使用静态方法的服务：

@RestController
@RequestMapping(path = "/demo")
public class DemoController {

    @Autowired
    private DemoService demoService;

    @GetMapping(path = "/demo")
    public String callService(@RequestParam Integer id) {
        return demoService.queryByIdFromCache(id);
    }

    @GetMapping(path = "/static-demo")
    public String callStaticService(@RequestParam Integer id) {
        return DemoStaticService.queryByIdFromCache(id);
    }

}

之后，我编写了两个单元测试来帮助我分析服务方法：

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoControllerTest {

    @Autowired
    private DemoController demoController;

    @Before
    public void before() {
        demoController.callService(1);
        demoController.callStaticService(1);
    }

    @Test
    public void testCallService() {
        for (int id = 0; id < 128; id++) {
            demoController.callService(id);
        }
    }

    @Test
    public void testCallStaticService() {
        for (int id = 0; id < 128; id++) {
            demoController.callStaticService(id);
        }
    }

}

打开测试文件后，我选择了Profile -> Profile Test File菜单项：

然后从▶ Profile 下拉菜单中，我选择了Methods 选项：

最后我点击了▶ Profile 按钮来分析测试。我得到了这个结果，这表明对注入服务的调用仅比对静态方法的调用贵 50%：

但是如果第二种方法被切面拦截了怎么办（例如@Transactional）？

为了测试这一点，我更新了 DemoService 并使其方法具有事务性

@Service
public class DemoService {

    private static final ConcurrentMap<Integer, String> CACHE = new ConcurrentHashMap<>();

    public DemoService() {
        for (int i = 0; i < 128; i++) {
            CACHE.put(i, String.valueOf(i));
        }
    }

    @Transactional
    public String queryByIdFromCache(Integer id) {
        return CACHE.getOrDefault(id, "");
    }

}

重新运行测试后，我这次得到了这个分析结果：

可以看出，事务方面对DemoService.queryByIdFromCache 的调用慢了大约 14.5 (10.2/0.708) 倍。

要找出服务方法变慢的根本原因，我建议您设置一个类似的测试并使用 NetBeans Profiler（或类似的工具）对其进行分析。