Reflection, an implementation of automatic repeated call interface

problem

Recently, I met a need in my work , You need to implement repeated calls to the interface in the background , The specific needs are ：

• The background needs to cache the results of interface calls ;
• Automatically repeat the call every other period of time , Refresh the result data in the cache ;
• When the front end calls the interface , It will directly return cached data , Instead of actually calling the interface , get data .

The specific implementation plan thought of is ：

• Caching result data is simple , Direct use AOP Just do interface enhancement ;
• Save the state of the interface call , So that the interface can be automatically called again later ;
• Use scheduled tasks or delay queues to achieve automatic invocation .

Realization

AOP Do interface enhancement

Because this is not the focus of this article , So don't post specific implementation , The general idea is ： Create a pointcut , Then, before and after the method is run, enhance the operations of fetching results from the cache and storing results in the cache .

Save interface call status

This is the focus of this paper , We know that the defining elements of an interface are ： class 、 Method name and parameters , So the call information we want to store is this information , The specific implementation steps are as follows ：

• Create a class with interface call information

public class RequestObject implements Serializable {

    //  Class name 
    private String clazzName;
    //  Method name 
    private String methodName;
    //  Parameter object 
    private Object[] params;
    //  Parameter type 
    private String[] paramTypeNames;

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Object[] getParams() {
        return params;
    }

    public void setParams(Object[] params) {
        this.params = params;
    }

    public String[] getParamTypeNames() {
        return paramTypeNames;
    }

    public void setParamTypeNames(String[] paramTypeNames) {
        this.paramTypeNames = paramTypeNames;
    }
}

• stay AOP Enhance the code to save the calling information of the calling interface , As for where this object is stored, you can choose .

		//  Use reflection to obtain various information of the interface 
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
		RequestObject requestObject = new RequestObject();
        //  Class name 
        Object target = joinPoint.getTarget();
        requestObject.setClazzName(target.getClass().getName());
        //  Method name 
        requestObject.setMethodName(method.getName());
        //  Parameter values 
        Object[] args = joinPoint.getArgs();
        requestObject.setParams(args);
        //  Parameter type 
        if (args != null && args.length > 0){
            String[] typeNames = new String[args.length];
            for (int i = 0; i < args.length; i++){
                typeNames[i] = args[i].getClass().getName();
            }
            requestObject.setParamTypeNames(typeNames);
        }

• Use timed tasks 、mq Or delay the queue to realize the automatic call to the interface ： Take out the call information object , Then execute the interface call

	public String test() throws Throwable{
        RequestObject requestObject = (RequestObject) RedisUtils.get("key");
        //  Load class objects 
        Class c = Class.forName(requestObject.getClazzName());
        //  Parameter type 
        String[] paramTypeNames = requestObject.getParamTypeNames();
        //  Generate method objects 
        Method method;
        if (paramTypeNames == null || paramTypeNames.length <= 0){
            method = c.getMethod(requestObject.getMethodName());
        }else {
            Class[] paramTypeClass = new Class[paramTypeNames.length];
            for (int i = 0; i < paramTypeNames.length; i++){
                paramTypeClass[i] = Class.forName(paramTypeNames[i]);
            }
            method = c.getMethod(requestObject.getMethodName(), paramTypeClass);
        }
        //  Method call , A parameter is an object and parameter value of a class ;
        //  Here the object is from spring From , You can also generate objects in other ways ,
        //  After all, class objects already exist , It shouldn't be difficult to generate objects with classes 
        Object result = method.invoke(ApplicationContextHolder.getBean(c), requestObject.getParams());
        return result.toString();
    }

Come here , This function has been roughly realized , Although it's not very difficult , But it's interesting to use reflection to implement repeated calls of interfaces , Make a note of , Happy ~