91福利精品一区二区,欧美激情一区二区三3,国产91精品久久久久久久粉嫩,国产精品ww在线观看,91久久精品一区二区别,国产99视频精品草莓免视看,91伊人成人成网77777,亚洲精华液一二三产区,97免费播放视频观看

注解的那點(diǎn)事兒

桂林seo半杯酒博客 2017-11-02 19:15:27

什么是注解?

注解是JDK1.5引入的一個語法糖，它主要用來當(dāng)作元數(shù)據(jù)，簡單的說就是用于解釋數(shù)據(jù)的數(shù)據(jù)。在Java中，類、方法、變量、參數(shù)、包都可以被注解。很多開源框架都使用了注解，例如Spring、MyBatis、Junit。我們平常最常見的注解可能就是@Override了，該注解用來標(biāo)識一個重寫的函數(shù)。

注解的作用：

配置文件：替代xml等文本文件格式的配置文件。使用注解作為配置文件可以在代碼中實(shí)現(xiàn)動態(tài)配置，相比外部配置文件，注解的方式會減少很多文本量。但缺點(diǎn)也很明顯，更改配置需要對代碼進(jìn)行重新編譯，無法像外部配置文件一樣進(jìn)行集中管理（所以現(xiàn)在基本都是外部配置文件+注解混合使用）。
數(shù)據(jù)的標(biāo)記：注解可以作為一個標(biāo)記（例如：被@Override標(biāo)記的方法代表被重寫的方法）。
減少重復(fù)代碼：注解可以減少重復(fù)且乏味的代碼。比如我們定義一個@ValidateInt，然后通過反射來獲得類中所有成員變量，只要是含有@ValidateInt注解的成員變量，我們就可以對其進(jìn)行數(shù)據(jù)的規(guī)則校驗(yàn)。

定義一個注解非常簡單，只需要遵循以下的語法規(guī)則：

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

@Documented

public @interface ValidateInt {

// 它們看起來像是定義一個函數(shù)，但其實(shí)這是注解中的屬性

int maxLength();

int minLength();

}

我們發(fā)現(xiàn)上面的代碼在定義注解時也使用了注解，這些注解被稱為元注解。作用于注解上的注解稱為元注解（元注解其實(shí)就是注解的元數(shù)據(jù)），Java中一共有以下元注解。

@Target：用于描述注解的使用范圍（注解可以用在什么地方）。

ElementType.CONSTRUCTOR：構(gòu)造器。
ElementType.FIELD：成員變量。
ElementType.LOCAL_VARIABLE：局部變量。
ElementType.PACKAGE：包。
ElementType.PARAMETER：參數(shù)。
ElementType.METHOD：方法。
ElementType.TYPE：類、接口(包括注解類型) 或enum聲明。

@Retention：注解的生命周期，用于表示該注解會在什么時期保留。

RetentionPolicy.RUNTIME：運(yùn)行時保留，這樣就可以通過反射獲得了。
RetentionPolicy.CLASS：在class文件中保留。
RetentionPolicy.SOURCE：在源文件中保留。

@Documented：表示該注解會被作為被標(biāo)注的程序成員的公共API，因此可以被例如javadoc此類的工具文檔化。

@Inherited：表示該注解是可被繼承的（如果一個使用了@Inherited修飾的annotation類型被用于一個class，則這個annotation將被用于該class的子類）。

了解了這些基礎(chǔ)知識之后，接著完成上述定義的@ValidateInt，我們定義一個Cat類然后在它的成員變量中使用@ValidateInt，并通過反射進(jìn)行數(shù)據(jù)校驗(yàn)。

public class Cat {

private String name;

@ValidateInt(minLength = 0, maxLength = 10)

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public static void main(String[] args) throws IllegalAccessException {

Cat cat = new Cat();

cat.setName("樓樓");

cat.setAge(11);

Class<? extends Cat> clazz = cat.getClass();

Field[] fields = clazz.getDeclaredFields();

if (fields != null) {

for (Field field : fields) {

ValidateInt annotation = field.getDeclaredAnnotation(ValidateInt.class);

if (annotation != null) {

field.setAccessible(true);

int value = field.getInt(cat);

if (value < annotation.minLength()) {

// ....

} else if (value > annotation.maxLength()) {

// ....

}

}

}

}

}

}

注解的實(shí)現(xiàn)

注解其實(shí)只是Java的一顆語法糖（語法糖是一種方便程序員使用的語法規(guī)則，但它其實(shí)并沒有表面上那么神奇的功能，只不過是由編譯器幫程序員生成那些繁瑣的代碼）。在Java中這樣的語法糖還有很多，例如enum、泛型、forEach等。

通過閱讀JLS(Java Language Specification（當(dāng)你想了解一個語言特性的實(shí)現(xiàn)時，最好的方法就是閱讀官方規(guī)范）發(fā)現(xiàn)，注解是一個繼承自java.lang.annotation.Annotation接口的特殊接口，原文如下：

https://link.juejin.im/?target=http%3A%2F%2Fdocs.oracle.com%2Fjavase%2Fspecs%2Fjls%2Fse8%2Fhtml%2Fjls-9.html%23jls-9.6

An annotation type declaration specifies a new annotation type, a special kind of interface type. To distinguish an annotation type declaration from a normal interface declaration, the keyword interface is preceded by an at-sign (@).

Note that the at-sign (@) and the keyword interface are distinct tokens. It is possible to separate them with whitespace, but this is discouraged as a matter of style.

The rules for annotation modifiers on an annotation type declaration are specified in §9.7.4 and §9.7.5.

The Identifier in an annotation type declaration specifies the name of the annotation type.

It is a compile-time error if an annotation type has the same simple name as any of its enclosing classes or interfaces.

The direct superinterface of every annotation type is java.lang.annotation.Annotation.

package java.lang.annotation;

/**

* The common interface extended by all annotation types. Note that an

* interface that manually extends this one does <i>not</i> define

* an annotation type. Also note that this interface does not itself

* define an annotation type.

*

* More information about annotation types can be found in section 9.6 of

* <cite>The Java? Language Specification</cite>.

*

* The {@link java.lang.reflect.AnnotatedElement} interface discusses

* compatibility concerns when evolving an annotation type from being

* non-repeatable to being repeatable.

*

* @author Josh Bloch

* @since 1.5

*/

public interface Annotation {

...

}

我們將上節(jié)定義的@ValidateInt注解進(jìn)行反編譯來驗(yàn)證這個說法。

Last modified Oct 14, 2017; size 479 bytes

MD5 checksum 2d9dd2c169fe854db608c7950af3eca7

Compiled from "ValidateInt.java"

public interface com.sun.annotation.ValidateInt extends java.lang.annotation.Annotation

minor version: 0

major version: 52

flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION

Constant pool:

#1 = Class #18 // com/sun/annotation/ValidateInt

#2 = Class #19 // java/lang/Object

#3 = Class #20 // java/lang/annotation/Annotation

#4 = Utf8 maxLength

#5 = Utf8 ()I

#6 = Utf8 minLength

#7 = Utf8 SourceFile

#8 = Utf8 ValidateInt.java

#9 = Utf8 RuntimeVisibleAnnotations

#10 = Utf8 Ljava/lang/annotation/Retention;

#11 = Utf8 value

#12 = Utf8 Ljava/lang/annotation/RetentionPolicy;

#13 = Utf8 RUNTIME

#14 = Utf8 Ljava/lang/annotation/Target;

#15 = Utf8 Ljava/lang/annotation/ElementType;

#16 = Utf8 FIELD

#17 = Utf8 Ljava/lang/annotation/Documented;

#18 = Utf8 com/sun/annotation/ValidateInt

#19 = Utf8 java/lang/Object

#20 = Utf8 java/lang/annotation/Annotation

{

public abstract int maxLength();

deor: ()I

flags: ACC_PUBLIC, ACC_ABSTRACT

public abstract int minLength();

deor: ()I

flags: ACC_PUBLIC, ACC_ABSTRACT

}

SourceFile: "ValidateInt.java"

RuntimeVisibleAnnotations:

0: #10(#11=e#12.#13)

1: #14(#11=[e#15.#16])

2: #17()

public interface com.sun.annotation.ValidateInt extends java.lang.annotation.Annotation，很明顯ValidateInt繼承自java.lang.annotation.Annotation。

那么，如果注解只是一個接口，又是如何實(shí)現(xiàn)對屬性的設(shè)置呢？這是因?yàn)镴ava使用了動態(tài)代理對我們定義的注解接口生成了一個代理類，而對注解的屬性設(shè)置其實(shí)都是在對這個代理類中的變量進(jìn)行賦值。所以我們才能用反射獲得注解中的各種屬性。

為了證實(shí)注解其實(shí)是個動態(tài)代理對象，接下來我們使用CLHSDB(Command-Line HotSpot Debugger)來查看JVM的運(yùn)行時數(shù)據(jù)。如果有童鞋不了解怎么使用的話，可以參考R大的文章借HSDB來探索HotSpot VM的運(yùn)行時數(shù)據(jù) – Ahead, Code Behind – ITeye博客。

0x000000000257f538 com/sun/proxy/$Proxy1

注解的類型為com/sun/proxy/$Proxy1，這正是動態(tài)代理生成代理類的默認(rèn)類型，com/sun/proxy為默認(rèn)包名，$Proxy是默認(rèn)的類名，1為自增的編號。

實(shí)踐-包掃描器

我們在使用Spring的時候，只需要指定一個包名，框架就會去掃描該包下所有帶有Spring中的注解的類。實(shí)現(xiàn)一個包掃描器很簡單，主要思路如下：

先將傳入的包名通過類加載器獲得項(xiàng)目內(nèi)的路徑。
然后遍歷并獲得該路徑下的所有class文件路徑（需要處理為包名的格式）。
得到了class文件的路徑就可以使用反射生成Class對象并獲得其中的各種信息了。

定義包掃描器接口：

public interface PackageScanner {

List<Class<?>> scan(String packageName);

List<Class<?>> scan(String packageName, ScannedClassHandler handler);

}

函數(shù)2需要傳入一個ScannedClassHandler接口，該接口是我們定義的回調(diào)函數(shù)，用于在掃描所有類文件之后執(zhí)行的處理操作。

@FunctionalInterface // 這個注解表示該接口為一個函數(shù)接口，用于支持Lambda表達(dá)式

public interface ScannedClassHandler {

void execute(Class<?> clazz);

}

我想要包掃描器可以識別和支持不同的文件類型，定義一個枚舉類ResourceType：

public enum ResourceType {

JAR("jar"),

FILE("file"),

CLASS_FILE("class"),

INVALID("invalid");

private String typeName;

public String getTypeName() {

return this.typeName;

}

private ResourceType(String typeName) {

this.typeName = typeName;

}

}

PathUtils是一個用來處理路徑和包轉(zhuǎn)換等操作的工具類：

public class PathUtils {

private static final String FILE_SEPARATOR = System.getProperty("file.separator");

private static final String CLASS_FILE_SUFFIX = ".class";

private static final String JAR_PROTOCOL = "jar";

private static final String FILE_PROTOCOL = "file";

private PathUtils() {

}

// 去除后綴名

public static String trimSuffix(String filename) {

if (filename == null || "".equals(filename))

return filename;

int dotIndex = filename.lastIndexOf(".");

if (-1 == dotIndex)

return filename;

return filename.substring(0, dotIndex);

}

public static String pathToPackage(String path) {

if (path == null || "".equals(path))

return path;

if (path.startsWith(FILE_SEPARATOR))

path = path.substring(1);

return path.replace(FILE_SEPARATOR, ".");

}

public static String packageToPath(String packageName) {

if (packageName == null || "".equals(packageName))

return packageName;

return packageName.replace(".", FILE_SEPARATOR);

}

/**

* 根據(jù)URL的協(xié)議來判斷資源類型

*/

public static ResourceType getResourceType(URL url) {

String protocol = url.getProtocol();

switch (protocol) {

case JAR_PROTOCOL:

return ResourceType.JAR;

case FILE_PROTOCOL:

return ResourceType.FILE;

default:

return ResourceType.INVALID;

}

}

public static boolean isClassFile(String path) {

if (path == null || "".equals(path))

return false;

return path.endsWith(CLASS_FILE_SUFFIX);

}

/**

* 抽取URL中的主要路徑.

* Example:

* "file:/com/example/hello" to "/com/example/hello"

* "jar:file:/com/example/hello.jar!/" to "/com/example/hello.jar"

*/

public static String getUrlMainPath(URL url) throws UnsupportedEncodingException {

if (url == null)

return "";

// 如果不使用URLDecoder解碼的話，路徑會出現(xiàn)中文亂碼問題

String filePath = URLDecoder.decode(url.getFile(), "utf-8");

// if file is not the jar

int pos = filePath.indexOf("!");

if (-1 == pos)

return filePath;

return filePath.substring(5, pos);

}

public static String concat(Object... args) {

if (args == null || args.length == 0)

return "";

StringBuilder stringBuilder = new StringBuilder();

for (int i = 0; i < args.length; i++)

stringBuilder.append(args[i]);

return stringBuilder.toString();

}

}

定義了這些輔助類之后，就可以去實(shí)現(xiàn)包掃描器了。

public class SimplePackageScanner implements PackageScanner {

protected String packageName;

protected String packagePath;

protected ClassLoader classLoader;

private Logger logger;

public SimplePackageScanner() {

this.classLoader = Thread.currentThread().getContextClassLoader();

this.logger = LoggerFactory.getLogger(SimplePackageScanner.class);

}

@Override

public List<Class<?>> scan(String packageName) {

return this.scan(packageName, null);

}

@Override

public List<Class<?>> scan(String packageName, ScannedClassHandler handler) {

this.initPackageNameAndPath(packageName);

if (logger.isDebugEnabled())

logger.debug("Start scanning package: {} ....", this.packageName);

URL url = this.getResource(this.packagePath);

if (url == null)

return new ArrayList<>();

return this.parseUrlThenScan(url, handler);

}

private void initPackageNameAndPath(String packageName) {

this.packageName = packageName;

this.packagePath = PathUtils.packageToPath(packageName);

}

}

函數(shù)getResource()會根據(jù)包名來通過類加載器獲得當(dāng)前項(xiàng)目下的URL對象，如果這個URL為空則直接返回一個空的ArrayList。

protected URL getResource(String packagePath) {

URL url = this.classLoader.getResource(packagePath);

if (url != null)

logger.debug("Get resource: {} success!", packagePath);

else

logger.debug("Get resource: {} failed,end of scan.", packagePath);

return url;

}

函數(shù)parseUrlThenScan()會解析URL對象并進(jìn)行掃描，最終返回一個類列表。

protected List<Class<?>> parseUrlThenScan(URL url, ScannedClassHandler handler) {

String urlPath = "";

try {

// 先提取出URL中的路徑（不含協(xié)議名等信息）

urlPath = PathUtils.getUrlMainPath(url);

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

logger.debug("Get url path failed.");

}

// 判斷URL的類型

ResourceType type = PathUtils.getResourceType(url);

List<Class<?>> classList = new ArrayList<>();

try {

switch (type) {

case FILE:

classList = this.getClassListFromFile(urlPath, this.packageName);

break;

case JAR:

classList = this.getClassListFromJar(urlPath);

break;

default:

logger.debug("Unsupported file type.");

}

} catch (IOException | ClassNotFoundException e) {

e.printStackTrace();

logger.debug("Get class list failed.");

}

// 執(zhí)行回調(diào)函數(shù)

this.invokeCallback(classList, handler);

logger.debug("End of scan <{}>.", urlPath);

return classList;

}

函數(shù)getClassListFromFile()會掃描路徑下的所有class文件，并拼接包名生成Class對象。

protected List<Class<?>> getClassListFromFile(String path, String packageName) throws ClassNotFoundException {

File file = new File(path);

List<Class<?>> classList = new ArrayList<>();

File[] listFiles = file.listFiles();

if (listFiles != null) {

for (File f : listFiles) {

if (f.isDirectory()) {

// 如果是一個文件夾，則繼續(xù)遞歸調(diào)用，注意傳遞的包名

List<Class<?>> list = getClassListFromFile(f.getAbsolutePath(),

PathUtils.concat(packageName, ".", f.getName()));

classList.addAll(list);

} else if (PathUtils.isClassFile(f.getName())) {

// 我們不添加名字帶有$的class文件，這些都是JVM動態(tài)生成的

String className = PathUtils.trimSuffix(f.getName());

if (-1 != className.lastIndexOf("$"))

continue;

String finalClassName = PathUtils.concat(packageName, ".", className);

classList.add(Class.forName(finalClassName));

}

}

}

return classList;

}

函數(shù)getClassListFromJar()會掃描Jar中的class文件。

protected List<Class<?>> getClassListFromJar(String jarPath) throws IOException, ClassNotFoundException {

if (logger.isDebugEnabled())

logger.debug("Start scanning jar: {}", jarPath);

JarInputStream jarInputStream = new JarInputStream(new FileInputStream(jarPath));

JarEntry jarEntry = jarInputStream.getNextJarEntry();

List<Class<?>> classList = new ArrayList<>();

while (jarEntry != null) {

String name = jarEntry.getName();

if (name.startsWith(this.packageName) && PathUtils.isClassFile(name))

classList.add(Class.forName(name));

jarEntry = jarInputStream.getNextJarEntry();

}

return classList;

}

函數(shù)invokeCallback()遍歷類對象列表，然后執(zhí)行回調(diào)函數(shù)。

protected void invokeCallback(List<Class<?>> classList, ScannedClassHandler handler) {

if (classList != null && handler != null) {

for (Class<?> clazz : classList) {

handler.execute(clazz);

}

}

}

本文地址： http://m.registerjl.com/suibizatan/377.html

版權(quán)聲明：內(nèi)容均來源于互聯(lián)網(wǎng) 如有侵權(quán)聯(lián)系刪除

上一篇：干貨! 程序員從入門到大神的三個階段

下一篇：觀點(diǎn)：有關(guān)DevOps的7個趨勢