SpringBoot 基于注解实现接口的代理Bean注入
SpringBoot 基于注解实现接口的代理Bean注入
在springboot加载时需自己手动将接口的代理bean注入到spring容器中,这样在service层注入该接口类型即可,
1.在SpringBoot启动类上添加EnableProxyBeanScan注解
EnableProxyBeanScan为自定义注解,通过Import注解扫描被ProxyBean注解的类或者被ProxyBean修饰的注解注解的类("注解继承")
ProxyBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar 通过ProxyInterfaceBeanBeanDefinitionScanner 来进行bean的加载
ProxyFactoryBean为bean的工厂类,提供代理bean
ProxyHandler为代理业务逻辑接口,提供三个参数: Class(被代理的类),Method(被代理的方法),Object[] 入参参数
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(EnableProxyBeanScan.ProxyBeanDefinitionRegistrar.class)
public @interface EnableProxyBeanScan {
String[] basePackages() default {};
class ProxyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
ProxyInterfaceBeanBeanDefinitionScanner scanner = new ProxyInterfaceBeanBeanDefinitionScanner(registry);
scanner.scan(getBasePackages(importingClassMetadata));
}
private String[] getBasePackages(AnnotationMetadata importingClassMetadata){
Map<String, Object> attributes = importingClassMetadata.getAnnotationAttributes(EnableProxyBeanScan.class.getCanonicalName());
Set<String> basePackages = new HashSet();
String[] basePackagesArr = (String[])((String[])attributes.get("basePackages"));
for(String item: basePackagesArr){
if(StringUtils.hasText(item))
basePackages.add(item);
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
}
return basePackages.toArray(new String[basePackages.size()]);
}
}
}
public class ProxyInterfaceBeanBeanDefinitionScanner extends ClassPathBeanDefinitionScanner { public ProxyInterfaceBeanBeanDefinitionScanner(BeanDefinitionRegistry registry) { //registry是Spring的Bean注册中心 // false表示不使用ClassPathBeanDefinitionScanner默认的TypeFilter // 默认的TypeFilter只会扫描带有@Service,@Controller，@Repository，@Component注解的类 super(registry,false); } @Override protected Set<BeanDefinitionHolder> doScan(String... basePackages) { addIncludeFilter(new AnnotationTypeFilter(ProxyBean.class)); Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages); if (beanDefinitionHolders.isEmpty()){ System.err.println("No Interface Found!"); }else{ //创建代理对象 createBeanDefinition(beanDefinitionHolders); } return beanDefinitionHolders; } @Override protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { AnnotationMetadata metadata = beanDefinition.getMetadata(); return metadata.isInterface() || metadata.isAbstract(); } /** * 为扫描到的接口创建代理对象 * @param beanDefinitionHolders */ private void createBeanDefinition(Set<BeanDefinitionHolder> beanDefinitionHolders) { for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) { GenericBeanDefinition beanDefinition = ((GenericBeanDefinition) beanDefinitionHolder.getBeanDefinition()); //将bean的真实类型改变为FactoryBean beanDefinition.getConstructorArgumentValues(). addGenericArgumentValue(beanDefinition.getBeanClassName()); beanDefinition.setBeanClass(ProxyFactoryBean.class); beanDefinition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE); } } }
@Target({ElementType.TYPE,ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface ProxyBean { Class<? extends ProxyHandler> value(); }
public interface ProxyHandler{ Object execute(Class<?> proxyType,Object proxy, Method proxyMethod, Object[] args); }
public class ProxyFactoryBean<T> implements FactoryBean { private static final Map<Class<? extends ProxyHandler>,ProxyHandler> ProxyHandlers = new ConcurrentHashMap<>(); private Class<T> interfaceClass; private Class<? extends ProxyHandler> proxyHandlerType; public ProxyFactoryBean(Class<T> interfaceClass) { this.interfaceClass = interfaceClass; this.proxyHandlerType = AnnotationUtils.findAnnotation(interfaceClass, ProxyBean.class).value(); if(!ProxyFactoryBean.ProxyHandlers.containsKey(proxyHandlerType)) { ProxyHandler proxyHandler = ClassUtils.newInstance(proxyHandlerType); SpringBean.inject(proxyHandler); ProxyFactoryBean.ProxyHandlers.put(proxyHandlerType, proxyHandler); } } @Override public T getObject() throws Exception { final ProxyHandler proxyHandler = ProxyFactoryBean.ProxyHandlers.get(proxyHandlerType); return (T) Proxy.newProxyInstance( interfaceClass.getClassLoader(), new Class[]{interfaceClass}, (proxy,method,args) -> proxyHandler.execute(interfaceClass,proxy,method,args) ); } @Override public Class<T> getObjectType() { return interfaceClass; } }
简单的例子:
类似spring-feign的接口发送Http请求
1.先定义一个注解HttpClient,和HttpClientProxyHandler
@Target({ElementType.TYPE,ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @ProxyBean(HttpClient.HttpClientProxyHandler.class) public @interface HttpClient { @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @interface Request{ String url(); RequestMethod method() default RequestMethod.POST; } /**简单定义下进行测试,实际实现肯定要比这个复杂*/ class HttpClientProxyHandler implements ProxyHandler { /**这个类虽然没有被Spring管理,不过通过这个注解可以实现SpringBean的注入和使用, * 见ProxyFactoryBean构造方法的代码 * SpringBean.inject(proxyHandler); */ @Autowired private RestTemplate template; @Override public Object execute(Class<?> proxyType,Object proxy, Method proxyMethod, Object[] args) { return template.postForObject( proxyMethod.getAnnotation(Request.class).url() ,args[0] ,proxyMethod.getReturnType() ); } } }
2.被代理的接口
@HttpClient public interface LoginService { @HttpClient.Request(url="ddd") String getUserAge(ExamineReqDto username); }
3.测试,
测试这里没有细致的测,RestTemplate这里是成功拿到了,不影响后续的使用
最后,附Bean注入的代码:
@Component
public class SpringBean implements ApplicationContextAware {
private static final Logger log = LoggerFactory.getLogger(SpringBean.class);
private static ApplicationContext applicationContext;
private SpringBean(){}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringBean.applicationContext = applicationContext;
}
public static <T> T getSpringBean(Class<T> clazz){
return SpringBean.applicationContext.getBean(clazz);
}
@SuppressWarnings("unchecked")
public static <T> T getSpringBean(String beanName){
return (T) SpringBean.applicationContext.getBean(beanName);
}
public static void inject(Object object){
if(object == null)
return;
Class clazz = object.getClass();
while (clazz != Object.class) {
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
Autowired annotation = field.getAnnotation(Autowired.class);
if (annotation != null) {
Reflector.setFieldValue(object,field,SpringBean.getSpringBean(field.getType()));
}
Resource resource = field.getAnnotation(Resource.class);
if (resource != null) {
Reflector.setFieldValue(object,field,SpringBean.getSpringBean(field.getName()));
}
}
clazz = clazz.getSuperclass();
}
}
}
补全Http请求代理接口
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @ProxyCustomizer(HttpClientProxyHandler.class) public @interface HttpClient { }
import com.sinosoft.demo.componment.proxy.core.ProxyHandler;
import javafx.util.Builder;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.BufferingClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.ClassUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.client.RestTemplate;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.*;
import java.util.*;
import static org.springframework.objenesis.instantiator.util.ClassUtils.newInstance;
public class HttpClientProxyHandler implements ProxyHandler {
@Override
public Object execute(Class<?> proxyType, Object proxy ,Method proxyMethod, Object[] args) {
if(proxyMethod.isDefault()){ //不对default 的方法进行代理
try {
Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
.getDeclaredConstructor(Class.class, int.class);
constructor.setAccessible(true);
Class<?> declaringClass = proxyMethod.getDeclaringClass();
int allModes = MethodHandles.Lookup.PUBLIC | MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED | MethodHandles.Lookup.PACKAGE;
return constructor.newInstance(declaringClass, allModes)
.unreflectSpecial(proxyMethod, declaringClass)
.bindTo(proxy)
.invokeWithArguments(args);
}catch(Exception ex) {
throw new RuntimeException(ex);
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
RequestMapping requestMapping = AnnotationUtils.getAnnotation(proxyMethod, RequestMapping.class);
String url = getRequestUrl(requestMapping);
Object invokeParam = handleRequestObject(proxyMethod,args);
Class<?> returnType = getReturnType(proxyMethod);
MultiValueMap<String, String> httpAttributes = getHttpAttributes(proxyType, proxyMethod);
RestTemplate template = createRestTemplate(httpAttributes,proxyType,proxyMethod);
HttpEntity entity = new HttpEntity(invokeParam,headers(httpAttributes));
ResponseEntity<?> responseEntity = template.exchange(url,getHttpMethod(requestMapping),entity,returnType,args);
return handleReturnObject(proxyMethod,invokeParam,responseEntity);
}
private String getRequestUrl(RequestMapping requestMapping){
Map<String, Object> annotationAttributes = AnnotationUtils.getAnnotationAttributes(requestMapping);
String[] path = (String[]) annotationAttributes.get("path");
if(path.length>0)
return path[0];
throw new UnsupportedOperationException("url not be null!");
}
private Class<?> getReturnType(Method proxyMethod){
Class<?> returnType = proxyMethod.getReturnType();
if(ClassUtils.isAssignable(CallBack.class,returnType)){
Type[] interfaces = returnType.getGenericInterfaces();
for (int i = 0; i < interfaces.length; i++) {
if (interfaces[i] instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) interfaces[i];
if (parameterizedType.getRawType() == CallBack.class) {
return (Class<?>) parameterizedType.getActualTypeArguments()[0];
}
}
}
}
if(ClassUtils.isAssignable(ResponseEntity.class,returnType)){
Type genericReturnType = proxyMethod.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
return (Class<?>) actualTypeArguments[0];
}
}
return returnType;
}
private Object handleRequestObject(Method proxyMethod,Object[] args){
Object invokeParam;
if(args.length==1){
if(args[0] instanceof Builder)
invokeParam = ((Builder)args[0]).build();
else
invokeParam = args[0];
}else{
Map<String,Object> paramsMap = new LinkedHashMap<>();
Parameter[] parameters = proxyMethod.getParameters();
for(int i=0;i<parameters.length;i++){
RequestParam annotation = AnnotationUtils.findAnnotation(parameters[i], RequestParam.class);
if(annotation!=null)
paramsMap.put((String)AnnotationUtils.getDefaultValue(annotation),args[i]);
else
paramsMap.put(parameters[i].getName(),args[i]);
}
invokeParam = paramsMap;
}
return invokeParam;
}
private Object handleReturnObject(Method proxyMethod,Object invokeParam,ResponseEntity<?> responseEntity){
Object result = null;
if(ClassUtils.isAssignable(CallBack.class,proxyMethod.getReturnType())){
CallBack callBack = (CallBack) newInstance(proxyMethod.getReturnType());
callBack.call(responseEntity,invokeParam);
result = callBack;
}else if(ClassUtils.isAssignable(ResponseEntity.class,proxyMethod.getReturnType())){
result = responseEntity;
}else{
result = responseEntity.getBody();
}
return result;
}
private HttpMethod getHttpMethod(RequestMapping requestMapping){
RequestMethod[] requestMethod = requestMapping.method();
if(requestMethod.length>0)
return HttpMethod.valueOf(requestMethod[0].name());
return HttpMethod.POST;
}
private MultiValueMap<String,String> getHttpAttributes(Class<?> proxyType, Method proxyMethod){
MultiValueMap<String,String> attributes= new LinkedMultiValueMap<>();
HttpAttribute[] proxyTypeAttributeAnnotations = proxyType.getAnnotationsByType(HttpAttribute.class);
for(HttpAttribute attribute : proxyTypeAttributeAnnotations)
attributes.add(attribute.name(),attribute.value());
HttpAttribute[] proxyMethodAttributeAnnotations = proxyMethod.getAnnotationsByType(HttpAttribute.class);
for(HttpAttribute attribute : proxyMethodAttributeAnnotations)
attributes.add(attribute.name(),attribute.value());
return attributes;
}
private HttpHeaders headers(MultiValueMap<String,String> multiValueMap){
if(multiValueMap.containsKey(HttpAttribute.CONNECTION_TIMEOUT))
multiValueMap.remove(HttpAttribute.CONNECTION_TIMEOUT);
if(multiValueMap.containsKey(HttpAttribute.SOCKET_TIMEOUT))
multiValueMap.remove(HttpAttribute.SOCKET_TIMEOUT);
return new HttpHeaders(multiValueMap);
}
private RestTemplate createRestTemplate(MultiValueMap<String,String> attributes,Class<?> proxyType, Method proxyMethod){
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
if(attributes.containsKey(HttpAttribute.CONNECTION_TIMEOUT))
factory.setConnectTimeout(Integer.valueOf(attributes.getFirst(HttpAttribute.CONNECTION_TIMEOUT)));
if(attributes.containsKey(HttpAttribute.SOCKET_TIMEOUT))
factory.setReadTimeout(Integer.valueOf(attributes.getFirst(HttpAttribute.SOCKET_TIMEOUT)));
RestTemplate template = new RestTemplate();
template.setRequestFactory(new BufferingClientHttpRequestFactory(factory));
HashSet<Class<? extends ClientHttpRequestInterceptor>> interceptors = new LinkedHashSet<>();
HttpRequestInterceptors proxyTypeAnnotation = proxyType.getAnnotation(HttpRequestInterceptors.class);
HttpRequestInterceptors proxyMethodAnnotation = proxyMethod.getAnnotation(HttpRequestInterceptors.class);
if(proxyTypeAnnotation!=null) {
for (Class<? extends ClientHttpRequestInterceptor> interceptor : proxyTypeAnnotation.include())
interceptors.add(interceptor);
for (Class<? extends ClientHttpRequestInterceptor> interceptor : proxyTypeAnnotation.unInclude())
interceptors.remove(interceptor);
}
if(proxyMethodAnnotation!=null) {
for (Class<? extends ClientHttpRequestInterceptor> interceptor : proxyMethodAnnotation.include())
interceptors.add(interceptor);
for (Class<? extends ClientHttpRequestInterceptor> interceptor : proxyMethodAnnotation.unInclude())
interceptors.remove(interceptor);
}
List<ClientHttpRequestInterceptor> interceptorsList = template.getInterceptors();
for( Class<? extends ClientHttpRequestInterceptor> interceptor :interceptors)
interceptorsList.add(newInstance(interceptor));
return template;
}
}
public interface CallBack<T,R> { void call(ResponseEntity<T> entity, R requestParam); }
@Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Repeatable(HttpAttribute.HttpAttributes.class) public @interface HttpAttribute { String name(); String value(); String SOCKET_TIMEOUT = "http.socket.timeout"; String CONNECTION_TIMEOUT = "http.connection.timeout"; @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @interface HttpAttributes { HttpAttribute[] value(); } }
@Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited public @interface HttpRequestInterceptors { Class<? extends ClientHttpRequestInterceptor>[] include() default {}; Class<? extends ClientHttpRequestInterceptor>[] unInclude() default {}; }
CallBack(补充)---"集合"类结果数据
CallBack类型返回值作为对响应报文实体的进一步封装,Http接口为我们有时可能希望返回集合类型的数据结果(List<Pojo>),该代理类没有直接提供针对集合类型返回值的封装,
比如保险系统针对被保人进行风控校验(第三方接口来校验,自己解析结果,"集合">0表示有风控风险,进行提示或者其他后续处理)
这里通过实现callBack来变相实现对象的迭代(foreach)操作,
public class InsuredRiskWarnInfo implements CallBack<ResponseDto,RequestDto>,Iterable<InsuredRiskWarnInfo>{ private List<InsuredRiskWarnInfo> data; @Getter private String name; //姓名 @Getter private String code; //错误码 @Getter private String message;//错误信息 public void merge(InsuredRiskWarnInfo info){ if(this.data == null) this.data = info.data; else this.data.addAll(info.data); } @Override public void call(ResponseEntity<ResponseDto> entity, RequestDto requestParam) { data = new ArrayList<>(); // if(entity.getStatusCode() != HttpStatus.OK) // throw new RuntimeException(entity.getStatusCode().getReasonPhrase()); /**这里是具体的对响应对象的数据封装逻辑,假设一些数据*/ Map<String,String> map = new HashMap<>(); map.put("1","错误1"); map.put("2","错误2"); map.put("3","错误3"); for(Map.Entry<String,String> item : map.entrySet()){ InsuredRiskWarnInfo info = new InsuredRiskWarnInfo(); info.name = "某某人"; //可以从请求对象requestParam中取 info.code = item.getKey(); info.message = item.getValue(); info.data = this.data; this.data.add(info); } } @Override public Iterator<InsuredRiskWarnInfo> iterator() { return data.iterator(); }
调用示例 :
/**模拟请求后*/ InsuredRiskWarnInfo insuredRiskWarnInfo = new InsuredRiskWarnInfo(); insuredRiskWarnInfo.call(null,null); String format = "%s风控失败%s:%s"; for (InsuredRiskWarnInfo info : insuredRiskWarnInfo){ System.err.println(String.format(format,info.getName(),info.getCode(),info.getMessage())); } /** 某某人风控失败1:错误1 某某人风控失败2:错误2 某某人风控失败3:错误3 */
