@interface自定义注解的实际运用--创建唯一的api接口

矫情吗；* 2022-06-07 08:23 560阅读 0赞

**1.什么是注解和为什么使用注解，优点**

注解：可以看作是对一个类/方法的扩展模版；也就是一类规范；  
使用注解：可以使得每个类/方法 按照注解类中的给定的规则，来为 类/方法注入不同的参数；  
优点：注解反射器在获取类/方法中相关注解后，就可以得到不同的类/方法中注解的各种参数与值

**2.自定义注解的编码格式**

格式：public @interface 注解名 \{定义体\}

实现代码：

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ ElementType.TYPE, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface FunctionCode {
    	//值
    	String value();
    	//描述
    	String descript();
    	//默认参数
    	boolean onlySupportPost() default false;
    }

**3.名词解释**

** ** 3.1  元注解：负责注解其他注解的注解

元注解分四种：  
　　　　1.@Target,  
　　　　2.@Retention,  
　　　　3.@Documented,  
　　　　4.@Inherited

@Target说明了Annotation所修饰的对象范围，用于描述注解的使用范围  
  
  
代码中：ElementType.TYPE, ElementType.METHOD：表示可以使用在类，接口(包括注解类型) 或enum，以及方法中；  
ElementType分为：  
        1.CONSTRUCTOR:用于描述构造器  
　　　　2.FIELD:用于描述域  
　　　　3.LOCAL\_VARIABLE:用于描述局部变量  
　　　　4.METHOD:用于描述方法  
　　　　5.PACKAGE:用于描述包  
　　　　6.PARAMETER:用于描述参数  
　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明  
  
  
@Retention定义了该Annotation被保留的时间有效范围，也就是定义了该注解的生命周期：  
        RetentionPoicy分为：  
                1.SOURCE:在源文件中有效（即源文件保留）  
　　　　2.CLASS:在class文件中有效（即class保留）  
　　　　3.RUNTIME:在运行时有效（即运行时保留）  
  
  
了解：@Documented,@Inherited  
@Documented 标记注解，没有成员；  
@Inherited  标记注解，@Inherited阐述了某个被标注的类型是被继承的；

3.2  @interface：用来声明一个注解，其中的每一个方法都是声明其中需要的一个配置参数。

方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。  
可以通过default来声明参数的默认值  
自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节

**4.自定义实践**

**4.1 配置**

/**
 * 订单判断
 */
 @FunctionCode(value = "order", descript = "订单相关API")
 @Service
 public class OrderServiceImpl implements OrderService {
 @Autowired
 private CommonService commonService;
 
 @Autowired
 ShoppingOrderMapper shoppingOrderMapper;
 
 @FunctionCode(value = "order.placeOrder", descript = "支付成功后的订单处理接口")
 @Override
 public ApiResponse<HashMap<String, Object>> placeOrder(ApiRequest apiRequest) throws Exception {
 Object orderObj = apiRequest.get("orderStr");
 String orderStr = orderObj.toString();
 if (StringUtils.isEmpty(orderStr)) {
 return new ApiResponse<HashMap<String, Object>>(RestResultEnum.MissParameterException);
 }
 ApiResponse<HashMap<String, Object>> apiResponse = null;
 try {
 //如果支付成功则调用此接口，并将订单的数据拆解存储对应的数据表
 HashMap<String, Object> hashMap = commonService.saveAnalyzeJson(orderStr);
 if (hashMap.size() == 1) {
 apiResponse = new ApiResponse<HashMap<String, Object>>(RestResultEnum.CreateOrderFail, 0, hashMap);
 } else {
 apiResponse = new ApiResponse<HashMap<String, Object>>(RestResultEnum.SUCCESS, 1, hashMap);
 }
 
 } catch (Exception ex) {
 apiResponse = new ApiResponse<HashMap<String, Object>>(RestResultEnum.UNKNOW_ERROR);
 }
 return apiResponse;
 }
 }

其中类和方法都标记了自定义注解

**4.2 读取**

读取的方式和方法很多，这里说一种；

配置web.xml添加监听器：

<listener>
 		<listener-class>com.peit.api.web.SpringContextLoaderListener</listener-class>
 </listener>

SpringContextLoaderListener类：

import org.springframework.web.context.ContextLoaderListener;
    import org.springframework.web.context.WebApplicationContext;
    import javax.servlet.ServletContextEvent;
    
    public class SpringContextLoaderListener extends ContextLoaderListener {
        @Override
        public void contextInitialized(ServletContextEvent event) {
            super.contextInitialized(event);
            WebApplicationContext context = (WebApplicationContext) event.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
            SpringBeanProxy.setApplicationContext(context);
        }
    }

加载：SpringBeanProxy.setApplicationContext(context);

import com.epeit.api.annotations.FunctionCode;
 import org.springframework.context.ApplicationContext;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
 
 public class SpringBeanProxy {
 	private static ApplicationContext applicationContext;
 	private static Map<String, Object> functionCodeBeanMap = new HashMap<String, Object>();
 	private static Map<String, Method> functionCodeMethodMap = new HashMap<String, Method>();
 	private static Map<String, String> functionCodeCatalogMap = new HashMap<String, String>();
 	private static Map<String, Map<String, String>> functionCodeListMap = new HashMap<String, Map<String, String>>();
 
 	public synchronized static void setApplicationContext(ApplicationContext arg0) {
 		applicationContext = arg0;
 		//加载bean的Map
 		Map<String, Object> tempMap = applicationContext.getBeansWithAnnotation(FunctionCode.class);
 		if (tempMap != null && tempMap.size() > 0) {
 			for (Map.Entry<String, Object> entry : tempMap.entrySet()) {
 				Object bean = entry.getValue();
 				FunctionCode beanFc = bean.getClass().getAnnotation(FunctionCode.class);
 				if (beanFc != null) {
 					//值
 					String beanFunctionCode = beanFc.value();
 					//值和Bean
 					functionCodeBeanMap.put(beanFunctionCode, bean);
 					//值和描述
 					functionCodeCatalogMap.put(beanFunctionCode, beanFc.descript());
 					//方法集合
 					Method[] methodArr = bean.getClass().getDeclaredMethods();
 					if (methodArr != null && methodArr.length > 0) {
 						Map<String, String> methodFunctionCodeMap = new HashMap<String, String>();
 						for (Method method : methodArr) {
 							FunctionCode methodFc = method.getAnnotation(FunctionCode.class);
 							if (methodFc != null) {
 								//code和方法绑定
 								String methodFunctionCode = methodFc.value();
 								functionCodeMethodMap.put(methodFunctionCode, method);
 								methodFunctionCodeMap.put(methodFunctionCode, methodFc.descript());
 							}
 						}
 						functionCodeListMap.put(beanFunctionCode, methodFunctionCodeMap);
 					}
 				}
 			}
 		}
 	}
 
 	public static Object getBean(String beanName) {
 		return applicationContext.getBean(beanName);
 	}
 
 	public static Object getBeanByFunctionCode(String functionCode) {
 		return functionCodeBeanMap.get(functionCode);
 	}
 
 	public static Method getMethodByFunctionCode(String functionCode) {
 		return functionCodeMethodMap.get(functionCode);
 	}
 
 	public static Map<String, String> getFunctionCodeCatalogMap() {
 		return functionCodeCatalogMap;
 	}
 
 	public static Map<String, Map<String, String>> getFunctionCodeListMap() {
 		return functionCodeListMap;
 	}
 
 }

**4.3 调用**

import com.alibaba.fastjson.JSON;
 import com.epeit.api.dto.ApiFinalResponse;
 import com.epeit.api.dto.ApiRequest;
 import com.epeit.api.dto.ApiResponse;
 import com.epeit.api.enums.RestResultEnum;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.RequestMapping;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.lang.reflect.Method;
 import java.util.Date;
 import java.util.Enumeration;
 
 /**
 * API分发处理器 
 * 
 * 1.首先定义一个注解，如FunctionCode，value 约定； 
 * 2.将这个注解应用于相应业务的service以及service方法上; 
 * 3.当请求进入时，拦截请求，封装请求参数至ApiRequest，并分发到相应的service上； 
 * 4.业务处理完成后，由总控制的地方，统一输出响应数据，如ApiResponse。 
 */
 @Controller
 public class ApiDispatchController {
 private final Log loger = LogFactory.getLog(ApiDispatchController.class);
 
 private static final String API_ID = "apiId";
 private static final String ACCESS_TOKEN = "token";
 private static final String FUNCTION_CODE = "functioncode";
 
 @Value("${api.version}")
 private String apiVersion;
 
 @Value("${epeit.api.secert}")
 private String apiSecert;
 
 @Value("${cookie.domain}")
 private String cookieDomain;
 
 @SuppressWarnings({"rawtypes"})
 @RequestMapping(value = "/apicenter")
 public String apiDispatch(HttpServletRequest req, HttpServletResponse rsp) {
 ApiResponse apiRsp = null;
 try {
 ApiRequest apiReq = new ApiRequest();
 ApiRequest sysReq = new ApiRequest();
 //请求转换
 Enumeration em = req.getParameterNames();
 while (em.hasMoreElements()) {
 String name = (String) em.nextElement();
 if (API_ID.equals(name) || FUNCTION_CODE.equals(name) || ACCESS_TOKEN.equals(name)) {
 sysReq.put(name, req.getParameter(name));
 }
 String value = req.getParameter(name);
 apiReq.put(name, value);
 }
 //参数验证
 apiRsp = this.checkParam(sysReq);
 if (apiRsp != null) {
 return this.outputApiResponse(req, rsp, apiRsp);
 }
 // 把调用接口的IP,时间记录下来
 apiReq.setApiId(req.getParameter(API_ID));
 apiReq.setAccessToken(req.getParameter(ACCESS_TOKEN));
 apiReq.setFunctionCode(req.getParameter(FUNCTION_CODE));
 apiReq.setRequestIp(WebHelper.getRequestIp(req));
 apiReq.setRequestTime(new Date());
 apiReq.setCookies(req.getCookies());
 apiReq.setSession(req.getSession());
 apiReq.setRequest(req);
 apiReq.setResponse(rsp);
 loger.info("apiReq======" + apiReq.toString());
 //对传入的fuctionCode做处理
 String functioncode = req.getParameter(FUNCTION_CODE);
 // 目录,暂时以这种方法反射
 String[] tempArr = functioncode.split("\\.");
 if (tempArr != null && tempArr.length > 0) {
 //获取服务类的FunctionCode
 String serviceFunctionCode = tempArr[0];
 //获取到类
 Object bean = SpringBeanProxy.getBeanByFunctionCode(serviceFunctionCode);
 //获取到方法
 Method method = SpringBeanProxy.getMethodByFunctionCode(functioncode);
 try {
 //请求类中的方法中
 Object rspObj = method.invoke(bean, new Object[]{apiReq});
 //类判定
 if (rspObj instanceof ApiResponse) {
 apiRsp = (ApiResponse) rspObj;
 }
 } catch (Exception e) {
 e.printStackTrace();
 apiRsp = new ApiResponse(RestResultEnum.INVOKE_ERROR);
 
 }
 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 if (apiRsp == null) {
 apiRsp = new ApiResponse(RestResultEnum.UNKNOW_ERROR);
 }
 // 统一输出响应JSON
 return this.outputApiResponse(req, rsp, apiRsp);
 }
 
 /**
 * 验证参数
 */
 @SuppressWarnings("rawtypes")
 private ApiResponse checkParam(ApiRequest apiReq) {
 loger.info("入参： " + apiReq.toString());
 ApiResponse apiRsp = null;
 if (!StringUtils.isEmpty(apiReq.get(API_ID)) && !StringUtils.isEmpty(apiReq.get(ACCESS_TOKEN)) && !StringUtils.isEmpty(apiReq.get(FUNCTION_CODE))) {
 String apiId = apiReq.get(API_ID).toString();
 String inputToken = apiReq.get(ACCESS_TOKEN).toString();
 String functionCode = apiReq.get(FUNCTION_CODE).toString();
 //Token验证
 String rightToken = SimpleTokenUtil.buildToken(apiReq, apiSecert);
 loger.info("inputToken===" + inputToken + "	rightToken=" + rightToken);
 if (!inputToken.equals(rightToken)) {
 apiRsp = new ApiResponse(RestResultEnum.TOKEN_ERROR);
 }
 } else {
 apiRsp = new ApiResponse(RestResultEnum.MissParameterException);
 }
 return apiRsp;
 }
 
 
 @SuppressWarnings({"rawtypes", "unchecked"})
 private String outputApiResponse(HttpServletRequest req, HttpServletResponse rsp, ApiResponse apiRsp) {
 // 统一输出响应JSON
 ApiFinalResponse finalRsp = new ApiFinalResponse();
 finalRsp.setVersion(apiVersion);
 finalRsp.setFunctioncode(req.getParameter(FUNCTION_CODE));
 finalRsp.setIsSuccess(apiRsp.getReturnEnum().getIsSuccess());
 finalRsp.setCode(apiRsp.getReturnEnum().getCode());
 finalRsp.setMsg(apiRsp.getReturnEnum().getMsg());
 finalRsp.setTotal(apiRsp.getTotal());
 finalRsp.setRecord(apiRsp.getRecord());
 String jsonString = JSON.toJSONString(finalRsp, true);
 loger.info("jsonString===" + jsonString);
 String jsonpCallback = req.getParameter("jsonpCallback");
 if (jsonpCallback != null && !"".equals(jsonpCallback.trim())) {
 return WebHelper.outputForJsonp(jsonpCallback, jsonString, rsp);
 } else {
 return WebHelper.outputJson(jsonString, rsp);
 }
 }
 
 }

**5.优势**

**1.统一调用，无需暴露大量的接口，降低开发成本；同时也降低了前端接口调用地址的维护的复杂度；**

**2.代码结构明晰，方便拓展**

**6.请求和返回**

**请求参数：**

{apiId=1234567890876542345678, functioncode=order.placeOrder, token=c664788ac23ac2c839cd1649601382de, orderStr={"userId":1,"totalPrice":1.38,"deviceInfo":"866184023611242","userIp":"105.31.168.192","orderAddress":"上海田林路288号田林大厦123号","linkman":"","linkTel":"15601751301","record":[{"id":"60","proId":"23","proName":"产品","productPic":"/epeit/20150717/default/2ae8eef72eff47fb8c650bf438618bd2.png","proPrice":"1","proNum":"1","emerLever":"0","emerName":"不加急","emerPrice":"0","orderPrice":"1.0","freight":"0"}]}}

**返回值：  
\{"code":"0000","functioncode":"order.placeOrder","isSuccess":true,"msg":"成功","record":\{"orderAddress":"上海田林路288号田林大厦123号","orderCode":"DD514375267736684","totalPrice":1.38,"userId":"1"\},"total":1,"version":"1.0"\}**

**部分字段解释  
orderCode：订单编号  
totalPrice：商品价格**