利用Java注解将常量类生成js文件供前端调用

简介:

  注解相当于一种标记,在程序中加了注解就等于为程序打上了某种标记,没加,则等于没有某种标记,以后,javac编译器,开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记,看你有什么标记,就去干相应的事标记可以加在包,类,字段,方法,方法的参数以及局部变量上。

1)定义一个最简单的注解

1
2
3
public  @interface  MyAnnotation {
         //......
     }

2)把注解加在某个类上:

1
2
3
4
@MyAnnotation
     public  class  AnnotationTest{
         //......
     }

  我们的常量类注解如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package  com.gaochao.platform.util;
 
import  java.lang.annotation.ElementType;
import  java.lang.annotation.Retention;
import  java.lang.annotation.RetentionPolicy;
import  java.lang.annotation.Target;
 
/**
  * 常量中文转换注解
  * @author chao.gao
  * @date 2013-12-20 下午1:02:02
  * @version <b>1.0.0</b>
  */
@Retention (RetentionPolicy.RUNTIME)
@Target (ElementType.FIELD)
public  @interface  ConstantsText {
     /**
      * 数据字典的label,获取中文含义时使用
      * @author chao.gao
      * @date 2013-12-20 下午1:17:19
      * @return
      */
     public  String termsLable()  default  "" ;
 
     /**
      * 当数据字典中不存在对面的中文时使用,手动设置
      * @author chao.gao
      * @date 2013-12-20 下午1:17:40
      * @return
      */
     public  String text()  default  "" ;
}

  注解的上方有两个元注解,是注解的注解,含义及用法如下:

//Java中提供了四种元注解,专门负责注解其他的注解,分别如下
//@Retention元注解,表示需要在什么级别保存该注释信息(生命周期)。可选的RetentionPoicy参数包括:
//RetentionPolicy.SOURCE: 停留在java源文件,编译器被丢掉
//RetentionPolicy.CLASS:停留在class文件中,但会被VM丢弃(默认)
//RetentionPolicy.RUNTIME:内存中的字节码,VM将在运行时也保留注解,因此可以通过反射机制读取注解的信息
//@Target元注解,默认值为任何元素,表示该注解用于什么地方。可用的ElementType参数包括
//ElementType.CONSTRUCTOR: 构造器声明
//ElementType.FIELD: 成员变量、对象、属性(包括enum实例)
//ElementType.LOCAL_VARIABLE: 局部变量声明
//ElementType.METHOD: 方法声明
//ElementType.PACKAGE: 包声明
//ElementType.PARAMETER: 参数声明
//ElementType.TYPE: 类、接口(包括注解类型)或enum声明

//@Documented将注解包含在JavaDoc中
//@Inheried允许子类继承父类中的注解

  在常量类中应用注解:

1
2
3
4
5
6
7
8
public  class  RelationshipConstants {
public  static  final  String STATUS_SAVED =  "saved" ;
     public  static  final  String STATUS_FINISHED =  "finished" ;
 
     public  static  final  int  HAVE_YES =  1 ;
     public  static  final  int  HAVE_NO =  0 ;
     
}

  添加注解后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
             * 计划状态:已审核
             */
             @ConstantsText (text =  "我是手动审核" )
             public  static  final  String PLANSTATUS_AUDITED =  "audited" ;
 
             /**
             * 计划状态:已作废,从数据字典查找
             */
             @ConstantsText (termsLable =  "planStatus" )
             public  static  final  String PLANSTATUS_CANCELED =  "canceled" ;
 
             /**
             * 计划状态:已完结
             */
             @ConstantsText (termsLable =  "planStatus" )
             public  static  final  String PLANSTATUS_FINISHED =  "finished" ;


解释注解:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public  static  String getText(Field field)  throws  Exception {
         String fieldValue = field.get( null ).toString();
         if  (field.isAnnotationPresent(ConstantsText. class )) {
             ConstantsText ct = field.getAnnotation(ConstantsText. class );
             if  (!StringUtils.isBlank(ct.text())) {
                 return  ct.text();
             }
             if  (!StringUtils.isBlank(ct.termsLable())) {
                 String resultStr =  "" ;
                 if  (map.get(ct.termsLable()) !=  null ) {
                     resultStr = map.get(ct.termsLable()).get(fieldValue);
                 else  {
                     logger.error( "数据字典中未找到:termsLable:["  + ct.termsLable() +  "]!" );
                 }
                 if  (resultStr !=  null )
                     return  resultStr;
                 else  {
                     logger.error( "数据字典中未找到termslable:["  + ct.termsLable() +  "],termsCode:["  + fieldValue +  "]的对应值!" );
                 }
             }
         }
         return  fieldValue;
     }
}

  生成js的逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
public  static  void  genJsFile(String fPath) {
         String webRoot = AppContext.getAppContext().getWebAppRoot() +  "/scripts/" ;
         fPath = webRoot;
         String tempPath = fPath;
         PathMatchingResourcePatternResolver util =  new  PathMatchingResourcePatternResolver();
         String fileName =  "" ;
         Map<String, StringBuffer> fileNameMap =  new  HashMap<String, StringBuffer>();
         try  {
             //获取所有*Constants.class文件
             Resource[] file = util.getResources( "classpath*:com/fx/oa/**/api/define/*Constants.class" );
             StringBuffer jsContent =  null ;
             for  (Resource resource : file) {
                 logger.info( "扫描到文件:>>>>>"  + resource.getURI());
                 jsContent =  null ;
                 String clazz = resource.getURI().toString();
                 jsContent =  new  StringBuffer();
                 //获取反射需要的常量类全路径,2:!/,6:.class
                 String className = clazz.substring(clazz.lastIndexOf( "!" ) +  2 , clazz.length() -  6 ).replace( "/" "." );
                 fileName = className.substring( 0 , className.indexOf( ".api" ));
                 //1:.
                 fileName = fileName.substring(fileName.lastIndexOf( "." ) +  1 );
                 if  ((fileName.length() >  0 ) && fileNameMap.containsKey(fileName)) {
                     jsContent = fileNameMap.get(fileName);
                 }
                 logger.info( "扫描到常量类:"  + className);
                 //获取顶级var变量名
                 String varName =  "oa."
                         + className.substring(className.lastIndexOf( "." ) +  1 ).replace( "Constants" "" ).toLowerCase();
                 jsContent.append(genContent(className, fileName, varName));
                 if  (jsContent.length() ==  0 ) {
                     logger.info( "常量类"  + className +  "未定义任何内容,跳过!" );
                     continue ;
                 else  {
                     fileNameMap.put(fileName, jsContent);
                 }
             }
             for  (String s : fileNameMap.keySet()) {
                 fPath += s;
                 File outDir =  new  File(fPath);
                 //输出JS文件
                 if  (!outDir.exists()) {
                     if  (!outDir.mkdir()) {
                         throw  new  RuntimeException( "创建目录:"  + outDir +  "失败!" );
                     }
                 }
                 StringBuffer f = fileNameMap.get(s);
                 File jsFile =  new  File(fPath +  "/"  + s +  ".js" );
                 logger.info( "生成Js文件路径(文件系统):"  + jsFile.getAbsolutePath());
                 logger.info( "生成Js文件路径(项目相对路径):"  + jsFile.getPath());
                 BufferedOutputStream bos =  new  BufferedOutputStream( new  FileOutputStream(jsFile));
                 bos.write(f.toString().getBytes());
                 bos.close();
                 fPath = tempPath;
             }
 
         catch  (Exception e) {
             logger.error(e.getMessage());
             throw  new  RuntimeException(e);
         }
     }
     
         @SuppressWarnings ({  "rawtypes" "unchecked"  })
     public  static  StringBuffer genContent(String className, String packageName, String varName)  throws  Exception {
         Class<?> clazz = Class.forName(className);
         StringBuffer jsContent =  new  StringBuffer();
         Field[] fields = clazz.getDeclaredFields();
         Map<String, List> map =  new  HashMap<String, List>();
         Map<String, List> mapText =  new  HashMap<String, List>();
         List<String> list =  null ;
         List<String> listText =  null ;
         String fieldName =  null , pre =  null , end =  null ;
         if  (fields.length ==  0 ) {
             logger.info(className +  "尚未定义任何常量!" );
             return  new  StringBuffer();
         }
         for  (Field field : fields) {
             fieldName = field.getName();
             int  fieldIndex = fieldName.indexOf( "_" );
             if  (fieldIndex == - 1 ) {
                 logger.error(className +  "字段:"  + fieldName +  "命名不符合规范!" );
                 throw  new  Exception(className +  "字段:"  + fieldName +  "命名不符合规范!" );
             }
             pre = fieldName.substring( 0 , fieldIndex);
             end = firstCharToUpper(fieldName.substring(fieldName.indexOf( "_" ) +  1 ).toLowerCase(),  "_" );
             if  (map.containsKey(pre)) {
                 list = map.get(pre);
                 list.add(end +  "-"  + field.get( null ).toString());
                 map.put(pre, list);
 
                 listText = mapText.get(pre);
                 listText.add(end +  "-"  + getText(field));
                 mapText.put(pre, listText);
             else  {
                 list =  new  ArrayList<String>();
                 list.add(end +  "-"  + field.get( null ).toString());
                 map.put(pre, list);
 
                 listText =  new  ArrayList<String>();
                 listText.add(end +  "-"  + getText(field));
                 mapText.put(pre, listText);
             }
         }
         String value =  null ;
         //处理英文
         jsContent.append(varName +  " = {" );
         for  (String key : map.keySet()) {
             jsContent.append( "\n\t"  + key.toLowerCase() +  " : {" );
             for  ( int  i =  0 ; i < map.get(key).size() -  1 ; i++) {
                 value = (String) map.get(key).get(i);
                 jsContent.append( "\n\t\t\""  + value.substring( 0 , value.indexOf( "-" )) +  "\"" );
                 jsContent.append( " : " );
                 jsContent.append( "\""  + value.substring(value.indexOf( "-" ) +  1 ) +  "\"," );
             }
             value = (String) map.get(key).get(map.get(key).size() -  1 );
             jsContent.append( "\n\t\t\""  + value.substring( 0 , value.indexOf( "-" )) +  "\"" );
             jsContent.append( " : " );
             jsContent.append( "\""  + value.substring(value.indexOf( "-" ) +  1 , value.length()) +  "\"\n" );
             jsContent.append( "\t}," );
         }
         jsContent.replace(jsContent.lastIndexOf( "," ), jsContent.lastIndexOf( "," ) +  1 "" );
         jsContent.append( "\n};\n" );
 
         //处理中文
         jsContent.append(varName +  "Text = {" );
         for  (String key : mapText.keySet()) {
             jsContent.append( "\n\t"  + key.toLowerCase() +  " : {" );
             for  ( int  i =  0 ; i < mapText.get(key).size() -  1 ; i++) {
                 value = (String) mapText.get(key).get(i);
                 jsContent.append( "\n\t\t\""  + value.substring( 0 , value.indexOf( "-" )) +  "\"" );
                 jsContent.append( " : " );
                 jsContent.append( "\""  + value.substring(value.indexOf( "-" ) +  1 ) +  "\"," );
             }
             value = (String) mapText.get(key).get(mapText.get(key).size() -  1 );
             jsContent.append( "\n\t\t\""  + value.substring( 0 , value.indexOf( "-" )) +  "\"" );
             jsContent.append( " : " );
             jsContent.append( "\""  + value.substring(value.indexOf( "-" ) +  1 , value.length()) +  "\"\n" );
             jsContent.append( "\t}," );
         }
         jsContent.replace(jsContent.lastIndexOf( "," ), jsContent.lastIndexOf( "," ) +  1 "" );
         jsContent.append( "\n};\n" );
         return  jsContent;
     }

  生成的js文件如下

1
2
3
4
5
6
7
8
9
10
11
requirements.js
         oa.requirements = {
                status : {
                    'saved' : 'saved' ,
                    'finished'  'finished'
                },
                have : {
                    'yes'  : 1,
                    'no'  : 0
                }
         }

引入js文件后,

通过 模块名.功能标识.含义   模块名.功能标识[含义方式即可取到相应的值.

oa.requirements.status.saved

"saved"


oa.requirements.status[‘saved’]

"saved"

使用说明补充:

在常量类中需要转换成中文含义的常量上面添加注解:

@ConstantsText(termsLable=”数据字典表中的termsLable”),数据库数据字典表中一定要有相应的记录,取得记录是根据termsLable+termsCode取得后面的中文,如果取不到,那么就还是原来的英文. 

@ConstantsText(text=”你自己添加的中文含义”)

生成的js就是如下效果,其实就是一个Map:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
oa.recruitmentText = {
                 have : {
                    "yes"  "1" ,
                    "no"  "0"
                 },
                 status : {
                    "saved"  "saved"
                 },
                 planstatus : {
                    "saved"  "saved" ,
                    "submited"  "submited" ,
                    "audited"  "我是手动审核" , //这个是用的text
                    "canceled"  "已作废" , //这个是数据字典中
                    "finished"  "已完结" //这个也是数据字典中的
                 }
             };

     在js中使用,类似如下:

1
2
template:  function (value) {
             return  oa.recruitmentText.planstatus[value.requirementDeptNames];

  本文应用注解、反射等技术将Constants文件中定义的常量信息提供给前端js,减少了代码量,同时也使前后端文本一致。





     本文转自 gaochaojs 51CTO博客,原文链接:http://blog.51cto.com/jncumter/1679756,如需转载请自行联系原作者



相关文章
|
4天前
|
安全 Java 开发者
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
12 1
|
4天前
|
设计模式 存储 安全
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
10 1
|
2天前
|
前端开发 JavaScript PHP
技术心得:前端点击按钮,导入excel文件,上传到后台,excel接收和更新数据
技术心得:前端点击按钮,导入excel文件,上传到后台,excel接收和更新数据
|
3天前
|
前端开发 JavaScript Java
【vue】 前端 基于 vue-simple-uploader 实现大文件断点续传和分片上传
【vue】 前端 基于 vue-simple-uploader 实现大文件断点续传和分片上传
8 0
|
4天前
|
存储 运维 前端开发
Java面试题:什么是Java的异常处理机制?列举常见的异常类,并说明使用场景
Java面试题:什么是Java的异常处理机制?列举常见的异常类,并说明使用场景
13 0
|
4天前
|
安全 Java 数据处理
Java面试题:什么是Java中的Optional类及其使用场景?
Java面试题:什么是Java中的Optional类及其使用场景?
7 0
|
4天前
|
前端开发 Java 编译器
Java面试题:描述Java类的加载过程,包括加载、链接、初始化等阶段。
Java面试题:描述Java类的加载过程,包括加载、链接、初始化等阶段。
8 0
|
4天前
|
设计模式 安全 NoSQL
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
Java面试题:结合单例模式与Java内存管理,设计一个线程安全的单例类?分析Java多线程工具类ExecutorService与Java并发工具包中的工具类,设计一个Java并发框架的分布式锁实现
12 0
|
17天前
|
前端开发 JavaScript 数据库
如何实现前后端分离-----前端笔记
如何实现前后端分离-----前端笔记
|
17天前
|
前端开发 安全 NoSQL
技术笔记:Security前端页面配置
技术笔记:Security前端页面配置