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、演示效果