11. jvm之注解

by developer

一. 注解基本使用

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}

使用@interface的方式新建注释，与创建接口类似

@Target指定注释的所修饰的对象范围

取值(ElementType)有：

  • CONSTRUCTOR:用于描述构造器
  • FIELD:用于描述域
  • LOCAL_VARIABLE:用于描述局部变量
  • METHOD:用于描述方法
  • PACKAGE:用于描述包
  • PARAMETER:用于描述参数
  • TYPE:用于描述类、接口(包括注解类型) 或enum声明

@Retention描述注解的生命周期

  • SOURCE:在源文件中有效（即源文件保留）
  • CLASS:在class文件中有效（即class保留）
  • RUNTIME:在运行时有效（即运行时保留）

@Inherited

@Inherited阐述了某个被标注的类型是被继承的。
如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface Anno {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Anno2 {
}
@Anno
@Anno2
class Parent {
}
public class Children extends Parent {
    public static void main(String[] args) {
        Annotation[] annos = Children.class.getAnnotations();
        for (Annotation anno : annos) {
            System.out.println(anno.toString());
        }
    }
}

输出结果

@Anno()

即未标识@Inherited的注解未被子类继承

@Repeatable

@Repeatable注解以及其相关特性，是在JDK 8中提供的，简单而言，我们可以设计一种风格的annotation，可以被多次修饰在符合要求的@Target上，在此前一个类型的注释是不能重复修饰在相同地方。


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Anno {
    Anno2[] value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Anno.class)
@interface Anno2 {
    String value();
}


@Anno2("1")
@Anno2("2")
class Parent {
}

@Anno({@Anno2("1"), @Anno2("2")})
class Parent2 {
}

public class Children {
    public static void main(String[] args) {
        Annotation[] annos = Parent.class.getAnnotations();
        for (Annotation anno : annos) {
            System.out.println(anno.toString());
        }

        Annotation[] annos2 = Parent2.class.getAnnotations();
        for (Annotation anno : annos2) {
            System.out.println(anno.toString());
        }
    }
}
  • Parent @Anno2("1")与@Anno({@Anno2("1")})这两种注解效果是一致的
  • Anno.class中必须存在value()方法，并且返回值Anno2数组，否则会报错
  • 上述输出结果为@Anno(value=[@Anno2(), @Anno2()]);表示虽然我们类上注解标注的是Anno2,但是实际上的注解是Anno的数组
  • 根据规范，@Scheduled元注解，不能与@Schedules容器注解同时修饰在同一个Target，否则会编译错误

使用方式

@Test
private int i = 0;

二. 注解中可包含方法

  1. 创建方式，和定义接口基本一至，不同的是定义注解可以指定默认值
    如果不指定默认值的话，在使用注解时，必须指定参数值
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    public String id() default "-1";
    public String name() defaule "轶名";
}
  1. 使用方式，在使用注解时，指定注解属性的值，若不指定则取默认值，并且元素值必须为常量，不可使用变量
@Test(id="1",name="我是测试")
private int i = 0;
  1. 如果只创建注解，使用效果有限，最多只能对字段等进行描述，可对注解创建相应的注解处理器

三. 注解处理器

public class TestAnno { 
private String str = "我是测试2"; 

@Test(id="1",name="我是测试")
private int i = 0; 
public static void main(String []args){
        Field[] fs = TestAnno.class.getDeclaredFields();
        for(Field f : fs){
            Test tAnno = f.getAnnotation(Test.class);
            if(tAnno != null){
                System.out.println("id:"+tAnno.id()+";name:"+tAnno.name());
            }else{
                System.out.println("无注解");
            }
        }
    }
}

通过getAnnotation可以获得方法或字段等域上的注解，获得该注解后，可取得注解时的属性，对根据不同的属性进行不同的操作。

四. 使用java注解时不写属性名会给哪个属性赋值

  • 如果注解只有一个属性，那么肯定是赋值给该属性。
  • 如果注解有多个属性，而且前提是这多个属性都有默认值，那么你不写注解名赋值，会赋值给名字为“value”这属性。
  • 如果注解有多个属性，其中有没有设置默认值的属性，那么当你不写属性名进行赋值的时候，是会报错的。

附件

1. 注解的定义

package net.xinshi.jemall.psh.util.logUtil;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Json {
    /**
     * 是否需要编码
     * @return
     */
    public boolean urlEncode() default false;
    /**
     * 是否需要添加前缀
     * @return
     */
    public String prefix() default "";
    /**
     * 是否为id
     * @return
     */
    public boolean id() default false;
    /**
     * 将该字段存日志的时候以key赋值的形式存储
     * @return
     */
    public String key() default "";
}

2. 注解的注释

/*
 * 该类使用CodeGen代码生成器生成
 * 生成时间： 2016-10-09 11:37:50.938
 * 生成要求：数据库的主键统一命名为id，int类型
 */
package net.xinshi.jemall.psh.pshKeyWord.bean;

import java.sql.Timestamp;

import net.xinshi.jemall.psh.util.logUtil.Json;

/**
 *搜索词命中率表
 */
public class PSHKeyWord implements java.io.Serializable{

	
    private int id;
    //返回结果条数
    private String count;
    //分站id
    private int mid;
    //城市id
    private int cityid;
    //搜索时间
    private Timestamp searchtime;
    //团类型 0-多品团 1-单品团 
    private int type;
    //用户的userid
    private int userid;
    //备注
    private String remark;
    //搜索词
    private String keyword;
    //solr查询语句
    private String searchQ;
    //渠道信息
    private String channel;

    @Json(id=true)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }


    /**
     * 返回结果条数
     */
    @Json
    public String getCount() {
        return count;
    }

    public void setCount(String count) {
        this.count = count;
    }
    /**
     * 分站id
     */
    @Json
    public int getMid() {
        return mid;
    }

    public void setMid(int mid) {
        this.mid = mid;
    }
    /**
     * 城市id
     */
    @Json
    public int getCityid() {
        return cityid;
    }

    public void setCityid(int cityid) {
        this.cityid = cityid;
    }
    /**
     * 搜索时间
     */
    @Json(key="JsonTime")
    public Timestamp getSearchtime() {
        return searchtime;
    }

    public void setSearchtime(Timestamp searchtime) {
        this.searchtime = searchtime;
    }
    /**
     * 团类型 0-多品团 1-单品团 2-跨境购
     */
    @Json
    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }
    /**
     * 用户的userid
     */
    @Json
    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }
    /**
     * 备注
     */
    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
    /**
     * 搜索词
     */
    @Json(urlEncode=true)
    public String getKeyword() {
        return keyword;
    }

    public void setKeyword(String keyword) {
        this.keyword = keyword;
    }
    @Json
    public String getSearchQ() {
		return searchQ;
	}

	public void setSearchQ(String searchQ) {
		this.searchQ = searchQ;
	}
    @Json(prefix="PSH")
    public String getChannel() {
        return channel;
    }
    public void setChannel(String channel) {
        this.channel = channel;
    }

	/* 主键相同即认为对象相等. */
    public boolean equals(Object obj) {
        if (this == obj)
            return true;

        if (obj == null || !(obj instanceof PSHKeyWord))
            return false;

        PSHKeyWord bean = (PSHKeyWord) obj;
        if (bean.getId() !=this.getId())
            return false;

        return true;
    }
    @Override
    public int hashCode() {
    	String clazzName = this.getClass().toString();
    	clazzName = clazzName + "_" + this.getId();
    	return clazzName.hashCode();
    }
}

3. 注解的使用

package net.xinshi.jemall.psh.util.logUtil;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URLEncoder;
import java.sql.Timestamp;
import java.util.Date;

import org.json.JSONObject;

import net.xinshi.jemall.base.Environment;
import net.xinshi.jemall.commons.StringUtil;
import net.xinshi.jemall.commons.Util;
import net.xinshi.jemall.paymode.util.wechatutil.MD5Util;
import net.xinshi.jemall.psh.pshKeyWord.bean.PSHKeyWord;

/**
 * 用于程序运行期间输出一些运行信息到文件中，如：执行时间、耗时、错误等，可方便的查看程序执行的效率、及正确性与否。
 * 对于调试一些程序执行效果要较长期才能看出，或大数据量处理的有用。
 * 注意：输出信息完后，一定要关闭掉
 */
public class LoggerUtil {
    private PrintWriter myFile; //文件输出流
    private String logFileNameKeyword;//文件名关键字
    private String logFileSrc;//完整的日志目录+日志名称
    private String logFileDir;//日志存放的根目录
    private File logFile;//日志文件
    private StringBuffer strf;//日志内容
    private String dirSub;//子文件夹
    private String defaulePath = "d:\\RunLog";


    public LoggerUtil(String fileNameKeyword, String dirSub) {
        try {
	        this.logFileNameKeyword = fileNameKeyword;
	        if (dirSub != null) {
	        	this.dirSub = dirSub;
	        }
	        String webAppPath = Environment.getEnv().getWebAppPath();
	        if(webAppPath != null){
	        	this.logFileDir = webAppPath;
	        }else{
	        	this.logFileDir = defaulePath;
	        }
	        this.initLogger();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

   
    //创建一个PrintWriter对像,用于写数据,第一次创建的时间同时写入操作文件的信息

    private PrintWriter getPrintWriter() throws Exception {
        try {
	        logFile = new File(this.logFileSrc);
	        if (!logFile.exists()) {
	            logFile.createNewFile();
	        }
            FileWriter fileWriter = new FileWriter(logFile, true);
            myFile = new PrintWriter(fileWriter);
            //文件不存在则创建文件,并记录操作文件信息
            if (!logFile.exists()) {
                logFile.createNewFile();
                myFile.println("当前日志文件:" + logFile.getAbsolutePath());
            }
            return myFile;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 关闭之前打印日志,,创建文件和流
     */
    private String loggering() {
     try {
    	 	//判断是否存在日志
	        if(strf != null && strf.length() ==0){
	        	return null;
	        }
	        String path = this.logFileDir;
	        File file = new File(path);
	        if (!file.exists() || !file.isDirectory()) {
	            file.mkdirs();
	        }
	
	        String dirSubTmp = this.dirSub;
	        if (dirSubTmp != null && dirSubTmp.trim().length() != 0) {
	            path = path + File.separator + dirSubTmp;
	            this.logFileDir = path;
	            File file2 = new File(path);
	            if (!file2.exists() || !file2.isDirectory()) {
	                file2.mkdirs();
	            }
	        }
	        
            String shortDataString = Util.getShortDateFormatByTimestamp(new Timestamp(System.currentTimeMillis()));
            String fileName = this.logFileNameKeyword + "_" + shortDataString + ".log";
            this.logFileSrc=this.logFileDir + "/" + fileName;
            this.myFile = this.getPrintWriter();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "success";
    }
    /**
     * new DebugLogger 时候创建StringBuffer
     */
    private void initLogger() {
        try {
	        strf = new StringBuffer();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //记录一条log记录

    public void log(String content) {
        try {
		  	strf.append(content);
	    } catch (Exception e) {
	    }
    }
    
    //关闭文件
    public void closeLogger() {
        try {
        	String str = this.loggering();
        	if(!StringUtil.isBlank(str)){
        		this.myFile.println(strf.toString());
        		this.myFile.println();
        		this.myFile.flush();
        		this.myFile.close();
        	}
	    } catch (Exception e) {
	    }
    }
    
    public <T> String obj2Json(T t){
    	JSONObject jsonObject = new JSONObject();
		try {
			Class clazz = t.getClass();
			Method[] methods = clazz.getDeclaredMethods();
			for(Method method : methods){
				String fieldValue = getFieldValue(method, t);
				String key = method.getName();
				if(key.indexOf("get") == 0){
					key = key.replaceFirst("get", "");
				}
				key = String.valueOf(key.charAt(0)).toLowerCase()+key.substring(1);
				jsonObject.put(key, fieldValue);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return jsonObject.toString();
    }
    
    private <T> String getFieldValue(Method method,T t){
    	String fieldValue = null;
    	try {
    		Json log = method.getAnnotation(Json.class);
        	if(log == null){
        		return null;
        	}
        	if(method.invoke(t) == null){
        		fieldValue = "";
        	}else{
        		fieldValue = String.valueOf(method.invoke(t));
        	}
    		if(log.id()){
    			fieldValue = t.getClass().getPackage()+"."+t.getClass().getName()+"."+fieldValue.toString();
    			fieldValue = MD5Util.MD5Encode(fieldValue, "utf-8");
    		}
    		if(log.prefix()!=null && !"".equals(log.prefix())){
    			fieldValue = log.prefix()+fieldValue;
    		}
    		if(log.urlEncode()){
    			fieldValue = URLEncoder.encode(fieldValue);
    		}
		} catch (Exception e) {
			e.printStackTrace();
		}
    	return fieldValue;
    }
    
    public static void main(String[] args) {
		LoggerUtil util = new LoggerUtil("", "");
		PSHKeyWord pshKeyWord = new PSHKeyWord();
		pshKeyWord.setCityid(31000);
		pshKeyWord.setCount("10");
		pshKeyWord.setKeyword("牛奶");
		pshKeyWord.setMid(0);
		pshKeyWord.setSearchtime(new Timestamp(new Date().getTime()));
		pshKeyWord.setType(0);
		pshKeyWord.setUserid(8542344);
		pshKeyWord.setSearchQ("q");
		pshKeyWord.setChannel("H5");
		String result = util.obj2Json(pshKeyWord);
		System.err.println(result);
	}
}