自定义注解简单实现类似Feign的功能
自定义注解简单实现类似Feign的功能
- 最近在玩spring源码，上文 spring自定义组件扫描，模仿@MapperScan 利用spring的beanFactoryProcessor进行扫描注册，最后结合jdbc完成简单封装。
- feign的源码怎么样子我没看过，只知道基于http调用(本文暂未集成配置中心)
- 本文内容深度依赖于spring。
涉及主要知识点：
- spring的BeanPostProcessor后置处理器
- jdk动态代理
- restTemplate进行http请求
1.注解定义
@EnableRemoteClient 开启，对比一下@EnableFeignClients
/**
* 开启http远程调用，为什么叫rpc，因为本项目要结合dubbo一起使用
* @author authorZhao
* @date 2019/12/20
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(RpcInstantiationAwareBeanPostProcessor.class)//这个类重点注意
public @interface EnableRemoteClient {
}
@RpcClient 对比一下@FeignClient
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RpcClient {
/**
* 服务在注册中心的名称，暂未集成配置中心，预计使用nacos
* @return
*/
String value() default "";
/**
* url前缀，访问的url前缀，如果没有注册中心这个路径代表访问的url前缀
* @return
*/
String URLPre() default "";
/**
* 调用方式包括http、rpc
* @return
*/
String cllType() default "";
}
2.@EnableRemoteClient 注解的解析
说明：本文采用beanPostProcessor形式进行bean的代理生成，不采用上篇文章的beanFactoryPosrProcessor进行注册，目的是为了理解springaop的实现.
BeanPostProcessor的功能
- 在bean实例化前后执行一些事情，类似自己的初始化和销毁方法
- BeanPostProcessor有一个子接口的执行时机和一般的不一样，InstantiationAwareBeanPostProcessor 接口实在bean创建之前执行，aop这篇先不多说
spring源码分析
- finishBeanFactoryInitialization(beanFactory);spring创建bean的方法，不清楚的可以看看spring的refresh()方法
try {
//在创bean实例化之前给一个后置处理器返回代理对象的机会，这里就是操作的地方
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.//给后置处理器一个机会返回一个目标代理对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
spring的分析暂时结束
RpcInstantiationAwareBeanPostProcessor 的作用
- RpcInstantiationAwareBeanPostProcessor 重写了postProcessBeforeInstantiation方法，就是上面spring源码需要重写的方法
- 为什么实现ApplicationContextAware ，我用来检测本地有没有注册自己的接口定义，不然代理不到，debug用的，可以不用实现
/**
* @author authorZhao
* @date 2019/12/20
*/
@Slf4j
public class RpcInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor , ApplicationContextAware {
private ApplicationContext applicationContext;
/**
* 实例化前，后面的方法可以不用看了
* @param beanClass
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
log.info("正在为：{}生成代理对象,被代理的类为：{}",beanName,beanClass.getName());
//检测需要实例化的bean有没有@RpcClient注解，有的话进行代理，没有返回null就行
RpcClient rpcClient = AnnotationUtil.getAnnotation(beanClass, RpcClient.class);
if (rpcClient == null) return null;
//动态代理里面需要实现的方法，本文采用的是jdk动态代理
Supplier<ProxyMethod<Object, Method, Object[], Object>> supplier = RpcMethodImpl::httpRemote;
//返回代理对象
Object object = ProxyUtil.getObject(beanClass, supplier.get());
return object;
}
/**
* 实例化后
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
return pvs;
}
/**
* 初始化钱
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
/**
* 初始化后
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext=applicationContext;
}
}
@RequestMapping的解析
- 已经深度使用spring了，就直接利用spring的注解
使用方式
//使用案例如下
@RpcClient(URLPre="http://localhost:8099/menu")
public interface MenuService {
@PostMapping("/getMenuByQuery")
ApiResult getMenuByQuery();
@GetMapping("/getMenuByRoleId")
ApiResult getMenuByRoleId(@PathVariable String roleId);
}
代理方法
//这个就是jdk的动态代理所需要实现的方法，不熟悉的看作者上一篇文章即可
public static ProxyMethod<Object, Method,Object[],Object> httpRemote() {
ProxyMethod<Object, Method,Object[],Object> cgLibProxyMethod =
(proxy,method,args)->{
//1.决定请求方式
String methodName = method.getName();
String url = "";
//2.得到请求路径
RpcClient annotationImpl = AnnotationUtil.getAnnotationImpl(proxy.getClass(), RpcClient.class);//这里的AnnotationUtil是自己写的，简单获取注解，后面带s的是spring的可以获得元注解信息
if(annotationImpl!=null)url = annotationImpl.URLPre();
HttpMapping requestMapping = getRequestMapping(method);//HttpMapping用于统一GetMapping、PostMapping、RequestMapping的
//@RpcClient 的请求前缀
String urlFix = requestMapping.getValue();
if(StringUtils.isBlank(urlFix)){
//如果没写，默认将方法名作为路径
url = url+"/"+methodName;
}else{
url = url +urlFix;
}
//3.执行http请求
return doHttp(url,method,args, requestMapping.getHttpMethod());
};
return cgLibProxyMethod;
}
dohttp
private static Object doHttp(String url, Method method, Object[] args, HttpMethod httpMethod) {
//1.restTemplate构建
RestTemplate restTemplate = new RestTemplate();
//2.请求头与请求类型
//这个执行了两次，暂时未调整
HttpMapping httpMapping = getRequestMapping(method);
//1.获得请求头
HttpHeaders headers = getHeader(); // http请求头
List<MediaType> mediaTypeList = new ArrayList<>();
mediaTypeList.add(MediaType.APPLICATION_JSON_UTF8);
//content-type的设置，默认json+u8，毕竟后台接口返回的都是json
//2.设置consumer
String[] consumes = httpMapping.getConsumes();
if(consumes!=null&&consumes.length>0)headers.setContentType(MediaType.parseMediaType(consumes[0]));
String[] produces = httpMapping.getProduces();
if(produces!=null&&produces.length>0)mediaTypeList.add(MediaType.parseMediaType(produces[0]));
headers.setAccept(mediaTypeList);
MultiValueMap<String, Object> form = new LinkedMultiValueMap<>();
Map<String, Object> map = new HashMap<>();
//重点注解解析
//支持三个注解，不要乱用
//1.PathVariable,将带有这个注解的放在url上面，这列采用手工操作
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
if(parameter==null)continue;
String paramname = parameter.getName();
PathVariable pathVariable = parameter.getAnnotation(PathVariable.class);
if(pathVariable!=null){
//为空会报错
url = url +"/"+args[i].toString();
}
//@RequestParam的value作为http请求参数的key，如果没有采用方法的参数名，注意方法的参数名没做处理可能会是args0等
RequestParam requestParam = parameter.getAnnotation(RequestParam.class);
if(requestParam!=null){
String name = requestParam.value();
paramname = StringUtils.isNotBlank(name)?name:paramname;
}
if(args[i]!=null){
form.add(paramname,(args[i]));
}
}
//@RequestBody，如果带有这个注解的话将所有非url参数转化为json
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
RequestBody requestBody = parameter.getAnnotation(RequestBody.class);
if(requestBody!=null){
headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
//带有requestBody时候全体当做一个参数打包成json
String json = JSON.toJSONString(form);
log.error("正在发送json形式的请求，请求数据为:{}",json);
HttpEntity<String> httpEntity = new HttpEntity<>(json, headers);
return httpEntity;
}
}
//2.RequestBody
//3.PathVariable
//RequestParam，
//RequestBody,
//PathVariable
//3.设置参数
//普通post
//json
//headers.setContentType(MediaType.APPLICATION_JSON_UTF8); // 请求头设置属性
//headers.setContentType(MediaType.parseMediaType("multipart/form-data; charset=UTF-8"));
//
HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<>(form, headers);
//3.参数解析
//4.结果返回
Class<?> returnType = method.getReturnType();
//后台接收的地址
//String url = "http://localhost:8092/process/saveProcess";
log.info("正发起http请求，url={}，请求参数={}",url,httpEntity.getBody().toString());
//restTemplate.postForEntity()
ResponseEntity result = restTemplate.exchange(url, httpMethod, httpEntity, returnType);
log.info("http请求结果为{}", JSON.toJSONString(result.getBody()));
log.info("http请求结果为{}", JSON.toJSONString(result.getBody()));
return result.getBody();
}
测试
1.启动类
@SpringBootApplication
@ComponentScan({"com.git.file","com.git.gateway.controller","com.git.gateway.service"})//扫描
@MapperScan("com.git.file.mapper")
@EnableRemoteClient//开启http代理
@Import({TestService.class,ArticleService.class, MenuService.class})//接口注册，注意接口上面加@Services的时候spring不不会注册这个bean定义的
2.controller,消费者，我这里是网关的
@RestController
@RequestMapping("/test")
public class TestController {
@Autowired
private TestService testService;
@Autowired
private ArticleService articleService;
@Autowired
private MenuService menuService;
@RequestMapping("/getById/{id}")
public ApiResult getById(@PathVariable String id){
return testService.getById(id);
}
@RequestMapping("/read/{id}")
public ApiResult read(@PathVariable String id){
return articleService.getById(id);
}
@RequestMapping("/getMenuByQuery")
public ApiResult getMenuByQuery(){
return menuService.getMenuByQuery();
}
@RequestMapping("/getMenuByRoleId/{id}")
public ApiResult getMenuByRoleId(@PathVariable String id){
return menuService.getMenuByRoleId(id);
}
}
3.service
这个就不全部列出来了，其中json的还未测试
/**
* @author authorZhao
* @date 2019/12/20
*/
@RpcClient(URLPre="http://localhost:8099/menu")
public interface MenuService {
@PostMapping("/getMenuByQuery")
ApiResult getMenuByQuery();
@GetMapping("/getMenuByRoleId")
ApiResult getMenuByRoleId(@PathVariable String roleId);
}
4.启动另一个服务提供接口
这里不展示了
5.效果图
1.网管的截图
2.员服务直接调用的
3.网关的日志
结束
1.说明
- 本文还有很多方法未实现
- 本文的注解工具类一个是自己写的，一个是spring的，spring的带s，并且可以获得元注解，这个很重要
- 本文还未实现与注册中心的对接
- 本文为贴出来的代码暂时没有公开有不理解的直接留言即可，作者还在继续学习继续完善中
2.打码感想 - 虽然没有看feign的源码们现在也基本猜到怎么实现的了，不包括注册中心和负载均衡等等组件
- 对spring注册bean和创房bean的认识进一步加深
本文为作者原创，转载请申明