springboot注册接口bean例子，实现表达式接口计算

0、项目结构及jar

        简单的springboot项目，jar包只需

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

1、注册注解

package org.bamboo.plugins.annotation;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)

@Inherited
@Documented
public @interface Operator {
    String value();
}

2、开启注册注解的注解

在启动类使用

package org.bamboo.plugins.annotation;

import org.bamboo.plugins.register.OperatorComponentRegister;
import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(value = {OperatorComponentRegister.class})
@Inherited
@Documented
public @interface EnableOperator {

    String[] value() default {};
}

3、注解操作，计算操作实现

        使用jdk代理实现，获取参数，使用spring的SpelExpressionParser执行表达式计算结果

package org.bamboo.plugins.beans;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class OperatorFactoryBean implements FactoryBean<Object>, InitializingBean {

    private Class<?> type;

    private String expression;
    private Expression sprExpression;
    @Override
    public Object getObject() throws Exception {
        return Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                EvaluationContext standardEvaluationContext = new StandardEvaluationContext();
                char var1 = 'a';
                for (Object arg : args) {
                    standardEvaluationContext.setVariable(String.valueOf(var1++),arg);
                }
                return sprExpression.getValue(standardEvaluationContext);
            }
        });
    }

    @Override
    public Class<?> getObjectType() {
        return this.type;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        ExpressionParser parser = new SpelExpressionParser();
        this.sprExpression = parser.parseExpression(this.expression);
    }

    public Class<?> getType() {
        return type;
    }

    public void setType(Class<?> type) {
        this.type = type;
    }

    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }
}

4、计算操作实现内容

        扫描使用的注解，使用spring的工具类BeanDefinitionReaderUtils注册到ioc容器

package org.bamboo.plugins.register;

import org.bamboo.plugins.annotation.EnableOperator;
import org.bamboo.plugins.annotation.Operator;
import org.bamboo.plugins.beans.OperatorFactoryBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class OperatorComponentRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware, ResourceLoaderAware {

    private Environment  environment;
    private ResourceLoader resourceLoader;

    @Override
    public void setEnvironment(Environment environment) {
            this.environment = environment;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        System.out.println("start  register。。。。。。。。。。。。。。。。。");
        Set<String> basePages = new HashSet<>();
        Map<String, Object> attributes = metadata.getAnnotationAttributes(EnableOperator.class.getName());
        for (String base : ((String[]) attributes.get("value"))) {
            if (StringUtils.hasText(base)){
                basePages.add(base);
            }
        }

        if (basePages.isEmpty()){
            basePages.add(ClassUtils.getPackageName(metadata.getClassName()));
        }

        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(){

            @Override
            public  boolean  isCandidateComponent(AnnotatedBeanDefinition annotatedBeanDefinition){
                return  true;
            }

        };

        scanner.setEnvironment(environment);
        scanner.setResourceLoader(resourceLoader);

        scanner.addIncludeFilter(new AnnotationTypeFilter(Operator.class));

        for(String base: basePages) {
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(base);
            for (BeanDefinition beanDefinition : candidateComponents) {
                if (beanDefinition instanceof AnnotatedBeanDefinition) {
                    AnnotatedBeanDefinition definition = (AnnotatedBeanDefinition) beanDefinition;
                    AnnotationMetadata meta = definition.getMetadata();
                    registerOperatorComponent(meta, registry);
                }
            }
        }
    }


    private void registerOperatorComponent(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(OperatorFactoryBean.class);
        String className = metadata.getClassName();
        beanDefinitionBuilder.addPropertyValue("type",className);
        Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(Operator.class.getName());
        if(StringUtils.isEmpty(annotationAttributes)) return;
        beanDefinitionBuilder.addPropertyValue("expression",annotationAttributes.get("value"));

        beanDefinitionBuilder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        AbstractBeanDefinition abstractBeanDefinition = beanDefinitionBuilder.getBeanDefinition();

        try {
            abstractBeanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE,Class.forName(className));
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(abstractBeanDefinition, className);
        BeanDefinitionReaderUtils.registerBeanDefinition(beanDefinitionHolder,registry);
        System.out.println("finish  register。。。。。。。。。。。。。。。。。");
    }


}

5、使用注解的接口，实现a+b的加法

        表达式不固定，可自行实现，也可实现其他功能

package org.bamboo.service;


import org.bamboo.plugins.annotation.Operator;

@Operator("#a + #b")
public interface AddService {
    public Object add(int a, int b);

}

6、调用接口

package org.bamboo.controller;


import org.bamboo.service.AddService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/third")
public class AddCtrl {

    @Autowired
    private AddService addService;

    @GetMapping("/add")
    public Object add(){
       return addService.add(1,2);
    }

}

7、启动类

package org.bamboo;

import org.bamboo.plugins.annotation.EnableOperator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableOperator
public class ConsumerAPP {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerAPP.class,args);
    }
}

8、演示效果