1. 背景
有时候为了对系统进行优化，我们需要找出系统中访问时间长的那些方法，本文就来演示下，如何实现这个功能。最终实现的效果是访问一个url，列出当前系统中所有api接口的访问信息，包括：接口的调用次数、正常调用次数、异常调用次数、接口的平均访问时间、最大访问时间、最小访问。
2. 思路
- 定义一个拦截器，记录方法的开始时间和结束时间
- 定义一个全局的异常处理器，记录防范访问发生异常
- 定义ThreadLocal，保存方法的访问信息。
- 为了访问多线程并发访问影响记录的准确性，用队列把计算串行化。
- 定义结果输出界面
3. 设计
3.1 设计拦截器
@Service
public class AccessInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if(handler instanceof HandlerMethod){
HandlerMethod hm = (HandlerMethod)handler;
AccessInfo mi = new AccessInfo();
mi.setHm(hm);
mi.setStartAt(System.currentTimeMillis());
mi.setUri(request.getRequestURI());
AccessHolder.accessStart(mi);//记录方法开始
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView model)
throws Exception {
//可以向view中写入数据
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception)
throws Exception {
if(handler instanceof HandlerMethod){
AccessHolder.accessEnd();//记录方法结束
}
}
}
3.2 设计全局异常Handler
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
@ExceptionHandler(value=Exception.class)
public Result<String> allExceptionHandler(HttpServletRequest request, Exception exception) throws Exception{
AccessHolder.accessError();//记录方法异常
if(exception instanceof BizException){
exception.printStackTrace();
BizException biz = (BizException)exception;
return Result.error(biz.getCodeMsg());
}else {
exception.printStackTrace();
return Result.error(CodeMsg.SERVER_ERROR);
}
}
}
3.3 设计ThreadLocal对象
@Service
public class AccessHolder {
private static ThreadLocal<AccessInfo> accessHolder = new ThreadLocal<AccessInfo>();//记录单次访问信息
private static ConcurrentHashMap<Class<?>, ControllerAccessInfo> map = new ConcurrentHashMap<Class<?>, ControllerAccessInfo>();//记录所有的访问信息
private static WorkingService<AccessRequest> workingService = new WorkingService<AccessRequest>();//工作队列，串行化
static {
workingService.start();
}
public static void accessStart(AccessInfo mai) {
accessHolder.set(mai);
}
public static AccessInfo getAccessInfo() {
return accessHolder.get();
}
public static void accessError() {
AccessInfo ai = getAccessInfo() ;
if(ai == null) {
return;
}
ai.setOccurError(true);
}
public static void accessEnd() {
AccessInfo ai = getAccessInfo();
if(ai == null) {
return;
}
ai.setEndAt(System.currentTimeMillis());
accessHolder.set(null);
workingService.execute(new AccessRequest(ai), new LazyExecutable<AccessRequest>() {
@Override
public void lazyExecute(AccessRequest request) {
addAccessInfo(request.getAi());
}
});
}
private static void addAccessInfo(AccessInfo ai) {
HandlerMethod hm = ai.getHm();
Class<?> controllerClazz = hm.getBeanType();
if(!AccessAble.class.isAssignableFrom(controllerClazz)) {
return;
}
Method method = hm.getMethod();
long startAt = ai.getStartAt();
long endAt = ai.getEndAt();
boolean occurError = ai.isOccurError();
long useTime = endAt - startAt;
String uri = ai.getUri();
ControllerAccessInfo cai = map.get(controllerClazz);
if(cai == null) {
cai = new ControllerAccessInfo();
cai.setControllerClazz(controllerClazz);
map.put(controllerClazz, cai);
}
List<MethodAccessInfo> mais = cai.getMethodInfos();
if(mais == null) {
mais = new ArrayList<MethodAccessInfo>();
cai.setMethodInfos(mais);
}
MethodAccessInfo mai = getMethodAccessInfo(mais, method);
if(mai == null) {
mai = new MethodAccessInfo();
mai.setMethod(method.getName());
mai.setUri(uri);
mai.setInvokeCount(1);
if(occurError) {
mai.setErrorCount(1);
}else {
mai.setSuccessCount(1);
}
mai.setMinMillSecond(useTime);
mai.setMaxMillSecond(useTime);
mai.setAvgMillSecond(useTime);
mais.add(mai);
}else {
if(useTime < mai.getMinMillSecond()) {
mai.setMinMillSecond(useTime);
}
if(useTime > mai.getMaxMillSecond()) {
mai.setMaxMillSecond(useTime);
}
mai.setInvokeCount(mai.getInvokeCount() + 1);
if(occurError) {
mai.setErrorCount(mai.getErrorCount()+1);
}else {
mai.setSuccessCount(mai.getSuccessCount()+1);
}
mai.setAvgMillSecond((mai.getAvgMillSecond()+useTime)/2);
}
}
private static MethodAccessInfo getMethodAccessInfo(List<MethodAccessInfo> mais, Method method) {
for(MethodAccessInfo mai : mais) {
if(method.getName().equals(mai.getMethod())) {
return mai;
}
}
return null;
}
public static Map<String, Object> getAllAccessInfo() {
Map<String, Object> result = new HashMap<String, Object>();
for(Map.Entry<Class<?>, ControllerAccessInfo> entry : map.entrySet()) {
ControllerAccessInfo cai = entry.getValue();
result.put(cai.getControllerClazz().getSimpleName(), cai.getMethodInfos());
}
return result;
}
}
3.4 实现EndPoint接口
public class AccessEndPoint implements Endpoint<Map<String, Object>> {
public String getId() {
return "access";
}
public boolean isEnabled() {
return true;
}
public boolean isSensitive() {
return false;
}
public Map<String, Object> invoke() {
return AccessHolder.getAllAccessInfo();
}
}
3.5 配置configuration
@Configuration
public class EndPointAutoConfig {
@Bean
public AccessEndPoint myEndPoint() {
return new AccessEndPoint();
}
}
4. 总结
实现对接口的信息记录方案其实很多，有的时候可以手写AOP,然后基于切面proceed后的对象进行操作，也可以直接用拦截器进行。说到底，一切切面型的工作，都需要深入理解AOP的思想，善于总结和归纳。
