BlogJava-流传的储藏罐-文章分类-Java

Java Annotation 注解

liucs — Mon, 22 Aug 2011 10:33:00 GMT

Annotation（注解）是什么？

附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。
注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

1、Annotation的定义

首先看一下如何定义我们自己的注解，下面是SpringMvc中RequestParam注解的定义。

@Retention(RetentionPolicy.RUNTIME) // 注解的保留策略
@Target(ElementType.PARAMETER) // 注解的作用目标
@Documented
public @interface RequestParam { // 使用@interface定义注解
    String value() default ""; // 类似方法的属性
    boolean required() default true; // 使用default指定属性的默认值
    String defaultValue() default ValueConstants.DEFAULT_NONE;
}

使用方式如下：

void deleteUser(@RequestParam(value="id",required=false) Long id) { }

2、元注解

元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。

2.1、@Retention: 定义注解的保留策略

@Retention(RetentionPolicy.SOURCE) 注解仅存在于源码中，在class字节码文件中不包含

@Retention(RetentionPolicy.CLASS) 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

@Retention(RetentionPolicy.RUNTIME) 注解会在class字节码文件中存在，在运行时可以通过反射获取到

2.2、@Target：定义注解的作用目标

@Target(ElementType.TYPE) 接口、类、枚举、注解

@Target(ElementType.FIELD) 字段、枚举的常量

@Target(ElementType.METHOD) 方法

@Target(ElementType.PARAMETER) 方法参数

@Target(ElementType.CONSTRUCTOR) 构造函数

@Target(ElementType.LOCAL_VARIABLE) 局部变量

@Target(ElementType.ANNOTATION_TYPE) 注解

@Target(ElementType.PACKAGE) 包

2.3、@Document：说明该注解将被包含在javadoc中

2.4、@Inherited：说明子类可以继承父类中的该注解

3、通过反射读取注解

package java.lang.reflect;
import java.lang.annotation.Annotation;

public interface AnnotatedElement {
    /**判断该元素中某个注解类型是否存在*/
     boolean isAnnotationPresent(Class extends Annotation> annotationClass);

   /**获得该元素中某个注解类型的注解*/
    <T extends Annotation> T getAnnotation(Class<T> annotationClass);

    /**获得该元素中所有可见的注解，包含继承得到的注解*/
    Annotation[] getAnnotations();

    /**获得该元素自身什么的注解，不包含继承得到的注解*/
    Annotation[] getDeclaredAnnotations();
}

java.lang.Package
java.lang.Class
java.lang.reflect.Construtor
java.lang.reflect.Field
java.lang.reflect.Method
均实现了该接口，所以我们可以通过反射获取到 Class、Construtor、Field、Mehtod等，然后再通过上述接口方法，获得作用在这些元素上的注解。
下面是RequestParam注解的使用，为便于演示，略作修改，见org.springframework.web.bind.annotation.support.HandlerMethodInvoker源码

Method handlerMethod = *****;
Annotation[] paramAnns = handlerMethod.getParameterAnnotations();

String paramName = null;
boolean required = false;
String defaultValue = null;

for (Annotation paramAnn : paramAnns) {
    if (RequestParam.class.isInstance(paramAnn)) {
        RequestParam requestParam = (RequestParam) paramAnn;
        paramName = requestParam.value();
        required = requestParam.required();
        defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
        annotationsFound++;
    }
       // *******其他处理*******************
}

4、常见注解的说明及使用

@Override :@Target(ElementType.METHOD)   @Retention(RetentionPolicy.SOURCE) 说明方法是对父类方法的覆盖，用于编译器编译时进行检查
@Deprecated: @Documented @Retention(RetentionPolicy.RUNTIME)   用于建议不要使用某元素
@SuppressWarnings：@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.SOURCE)
    说明对被批注的代码元素内部的某些警告保持静默

liucs 2011-08-22 18:33 发表评论

Volatile变量

liucs — Fri, 08 Apr 2011 08:28:00 GMT

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html 一文笔记

在java中，为了提高性能，线程一般把变量从内存中备份一个副本到寄存器。volatile 关键字意思是易失性，明确表示
一个变量是会被多线程访问的，每个线程在每次读取都要从内存读取原始副本的值，而不是缓存在寄存器中的值。每次修改
都是把值写回到内存中。

Java语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量。

synchronized锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的。否则，线程看到的共享变量可能是修改前的值或不一致的值，引发严重问题。

volatile能够实现上述可见性，因为线程每次都是读取原始版本的值，前一个线程的修改对后续线程来说是可见的。但volatile不能确保互斥。

volatile适用的原则：

对变量的写操作不依赖于当前值。
该变量没有包含在具有其他变量的不变式中。

所以volatile不能用作计数器，因为计数器的自增是一个读-增-写的过程，不是原子操作，在volatile不确保互斥的情况下，结果不准确。
不变式的意思是一个需要不变的规律，如起始要小于等于结束。上述2点简单来说：即变量真正独立于其他变量和自己以前的值，在这些
情况下可以使用 volatile 代替 synchronized 来简化代码。

volatile由于不阻塞线程，在性能一般比synchronized表现更好。

适用volatile的几个场景：
1、状态标志比如标示服务启动或停止。
2、独立观察定期 “发布” 观察结果供程序内部使用，
3、结合使用 volatile 和 synchronized 实现 “开销较低的读－写锁”

@ThreadSafe

public class CheesyCounter {

private volatile int value;

// 使用volatile实现可见性，开销低

public int getValue() { return value; }

// 使用synchronized实现互斥

public synchronized int increment() {

return value++;

}

}

liucs 2011-04-08 16:28 发表评论

java动态代理

liucs — Wed, 06 Apr 2011 02:58:00 GMT

java dynamic proxy

核心java.lang.reflect.Proxy类

// 根据给定接口和ClassLoader获取Class对象
// 使用Class.forName动态加载Class
public static Class getProxyClass(ClassLoader loader, Class interfaces)；
// 创建代理对象
// 通过反射的Constructor创建代理对象
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)；
// 判断是否是代理Class
public static boolean isProxyClass(Class cl)；
// 获得代理对象的InvocationHandler
public static InvocationHandler getInvocationHandler(Object proxy)

java.lang.reflect.InvocationHandler接口

// 反射调用代理类方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;

org.springframework.aop.framework.JdkDynamicAopProxy
springframeworkAOP特性实现的基础之一，通过动态代理实现

  1 package org.springframework.aop.framework;
  2
  3 final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  4
  5     /** 代理的配置信息 */
  6     private final AdvisedSupport advised;
  7
  8     public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
  9         Assert.notNull(config, "AdvisedSupport must not be null");
10         if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
11             throw new AopConfigException("No advisors and no TargetSource specified");
12         }
13         this.advised = config;
14     }
15
16
17     public Object getProxy() {
18         return getProxy(ClassUtils.getDefaultClassLoader());
19     }
20
21     // 获取代理对象
22     public Object getProxy(ClassLoader classLoader) {
23         if (logger.isDebugEnabled()) {
24             logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
25         }
26         Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
27         findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
28         // 使用了Proxy动态代理创建代理对象
29         return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
30     }
31
32
33     // 回调代理对象
34     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
35         MethodInvocation invocation;
36         Object oldProxy = null;
37         boolean setProxyContext = false;
38
39         TargetSource targetSource = this.advised.targetSource;
40         Class targetClass = null;
41         Object target = null;
42
43         try {
44             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
45                 // The target does not implement the equals(Object) method itself.
46                 return equals(args[0]);
47             }
48             if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
49                 // The target does not implement the hashCode() method itself.
50                 return hashCode();
51             }
52             if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
53                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {
54                 // Service invocations on ProxyConfig with the proxy config
55                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
56             }
57
58             Object retVal;
59
60             if (this.advised.exposeProxy) {
61                 // Make invocation available if necessary.
62                 oldProxy = AopContext.setCurrentProxy(proxy);
63                 setProxyContext = true;
64             }
65
66             // May be null. Get as late as possible to minimize the time we "own" the target,
67             // in case it comes from a pool.
68             target = targetSource.getTarget();
69             if (target != null) {
70                 targetClass = target.getClass();
71             }
72
73             // Get the interception chain for this method.
74             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
75
76             if (chain.isEmpty()) {
77                 // 如果拦截链是空的，直接通过反射调用target对象的方法
78                 // method.invoke(target, args);
79                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
80             }else {
81                 // 如果拦截链不为空，包装一个反射方法调用
82                 // 先调用织入的拦截器，最后仍然是反射调用target对象的方法
83                 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
84                 // Proceed to the joinpoint through the interceptor chain.
85                 retVal = invocation.proceed();
86             }
87
88             // Massage return value if necessary.
89             if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
90                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
91                 // Special case: it returned "this" and the return type of the method
92                 // is type-compatible. Note that we can't help if the target sets
93                 // a reference to itself in another returned object.
94                 retVal = proxy;
95             }
96             return retVal;
97         }
98         finally {
99             if (target != null && !targetSource.isStatic()) {
100                 // Must have come from TargetSource.
101                 targetSource.releaseTarget(target);
102             }
103             if (setProxyContext) {
104                 // Restore old proxy.
105                 AopContext.setCurrentProxy(oldProxy);
106             }
107         }
108     }
109 }
110

liucs 2011-04-06 10:58 发表评论

Java 反射

liucs — Thu, 31 Mar 2011 06:06:00 GMT

Java Reflection 是一种内省机制，帮助程序在运行时对自身及软件环境进行检查，并根据检查得到的程序结构，改变自身的部分行为。

核心类为 java.lang.Class 类，抽象了程序的元数据，每一个类的元数据就是一个Class对象实例。这个Class实例是一个静态实例，对应类的每一个实例都会关联这个静态实例。通过Class类可以查询该类的方法、字段、接口、构造器等一系列信息。详见下面。

对象回去自身对应的Class实例是通过继承自Object类的getClass()方法；
对于基本类型，每一种也有一个名为class的静态实例，如int.class double.class boolean.class；
对于数组类型，也有Object[].class, 注意 int[][].class==int[].class

判断对象类型的接口：
String getName() 获得类全名
Class getComponentType() 如果对象是数组，返回数据中元素的类类型
boolean isArray()
boolean isInterface()
boolean isPrimitive()
boolean isAnnotation()

###########################################################################################################
接口
java.lang.Class中定义的检查接口的接口：
Class[] getInterfaces()
Class getSuperClass() 直系父类，对于Object、接口、void关键字、基本类型，返回null
boolean isAssignableFrom(Class cls) 该类是参数的类型或参数的父类型
boolean isInstance(Object obj) 该类是参数的实例或者参数的子类实例

Class类和Object类存在比较纠结的关系
Class.class.isIntance(Class.class) == true Class类的class实例是Class本身的实例
Class.class.isInstance(Object.class) == true
Object.class.isAssignableFrom(Class.class) == true
Object.class.isIntance(Class.class) == true

###########################################################################################################
java.lang.reflect部分类图

###########################################################################################################

java.lang.reflect.Constructor
java.lang.Class中相关方法

Constructor getConstructor(Class[] parameterTypes)
Constructor getDeclaredConstructor（Class[]parameterTypes)
Constructor[] getConstructors()
Constructor[] getDeclaredConstructors()

java.lang.reflect.Constructor
Class getDeclaredClass()
Class[] getExceptionTypes()
int getModifiers()
String getName()
Class[] getParameterTypes()
Object newInstance(Object[] initArgs) 创建实例

对于数组，使用 java.lang.reflect.Array.newInstance(String.class,5)形式创建实例

###########################################################################################################

java.lang.reflect.Method

java.lang.Class类中定义了如下接口查询一个类所具有的方法。
Method getMethod(String name,Class[]parameterTypes)
Method[] getMethods()
上述2个接口查询继承获得和自身声明的方法
Method getDeclaredMethod(String name,Class[]parameterTypes)
Method[] getDeclaredMethods()
上述2个接口查询自身声明的方法

java.lang.reflect.Method类定义的方法
Class getDeclaringClass() 声明该方法的类实例
Class[] getExceptionTypes() 方法的异常类型
int getModifiers() 方法的可见性
String getName() 方法名
Class[] getParameterTypes() 方法参数类型
Class getReturnType() 方法返回类型
Object invoke(Object obj,Object[]args) 反射调用一个对象上面的该方法

###########################################################################################################

java.lang.reflect.Field

java.lang.Class类中关于Field的相关方法：
Field getField(String name)
Field[] getFields()
Field getDeclaredField(String name)
Field[] getDeclaredFields()

java.lang.relect.Field中主要方法
Class getType() 返回字段的Class
Class getDeclaringClass() 返回什么该字段的Class
String getName()
int getModifiers()
Object get(Object obj) 返回obj该字段的值
boolean getBoolean(Object obj)
void set(Object obj,Object value) 设置obj该字段的值
void setBoolean(Object obj,boolean value)

###########################################################################################################

java.lang.reflect.Modifier 字段或者方法的访问性
static boolean isPublic(int mod)
static boolean isPrivate(int mod)

共包括以下：
public static native volatile protected transient
abstract synchronized strictfp private final

###########################################################################################################
动态加载

Class cls = Class.forName(String className);
Object obj = cls.newInstance();

动态加载机制使得可以避开编译器类范围的限制，常见场景是jdbc驱动。动态加载机制也是通过ClassLoader实现。
通过动态加载机制的类名并不是一般意义的类名，而是：
1、基本类型，首字母大写，如 int -> I
2、引用类型，L+全类名，如 Ljava.lang.String
3、数组类型，[+***，如[I, [Ljava.lang.String , [[I, [[Ljava.lang.String

注意：基本类型，不能通过Class.forName（）加载,会抛出异常

liucs 2011-03-31 14:06 发表评论

Java 参数传递

liucs — Thu, 31 Mar 2011 06:05:00 GMT

Java在方法参数传递时：

1、对于基本类型，传递值
2、对于对象类型，传递对象引用
需要注意的是：对于上述两种传递类型，在传递时都是拷贝传递，即值传递时拷贝出一个新值，引用
传递时拷贝出一个新的拷贝。

有时候也说Java只有值传递，意思是对于引用类型，传递引用的值。一个概念，不用纠缠。

在内存中对象类型可以看做两块，一块是对象的引用，一块是数据区。引用块里面保存了数据区的地址。
看如下示例代码：

1 public class Test {
2
3     public static void main(String[] args) {
4         // 值传递
5         int i = 1;
6         addInt1(i);
7         System.out.println(i);// 输出1
8         addInt2(i);
9         System.out.println(i);// 输出1
10
11         // 引用传递实例1
12         String str = "123";
13         modifyStr1(str);
14         System.out.println(str);// 输出123
15
16         // 引用传递实例2
17         StringBuilder stringBuilder = new StringBuilder("123");
18         modifyStringBuilder(stringBuilder);
19         System.out.println(stringBuilder.toString());// 输出123456
20     }
21
22     // 拷贝了新的值，原值不变
23     public static void addInt1(int i) {
24         i = 2;
25     }
26
27     // 拷贝了新的值，原值不变
28     public static void addInt2(int i) {
29         i++;
30     }
31
32     // 新的拷贝引用指向了一块新数据区，原拷贝仍然指向原数据区
33     public static void modifyStr1(String str) {
34         str = "456";
35     }
36
37     // 新的拷贝引用仍然指向原数据区，但修改了原数据区的内容
38     public static void modifyStringBuilder(StringBuilder str) {
39         str.append("456");
40     }
41
42 }

liucs 2011-03-31 14:05 发表评论