亚洲精品成a人在线观看夫,亚洲av一综合av一区,久久亚洲精品11p

Java Annotation 注解

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

Annotation�Q�注解）是什么？

附加在代码中的一些元信息�Q�用于一些工具在�~�译、运行时�q�行解析和��用，起到说明、配�|�的功能�?br />注解不会也不能媄响代码的实际逻辑�Q�仅仅�v到辅助性的作用。包含在 java.lang.annotation 包中�?br />

1、Annotation的定�?/h2> 首先看一下如何定义我们自��q��注解�Q�下面是SpringMvc中RequestParam注解的定义�?br />
@Retention(RetentionPolicy.RUNTIME) // 注解的保留策�?/span>
@Target(ElementType.PARAMETER) // 注解的作用目�?/span>
@Documented
public @interface RequestParam { // 使用@interface定义注解
    String value() default ""; // �c�M��Ҏ��的属�?/span>
    boolean required() default true; // 使用default指定属性的默认�?/span>
    String defaultValue() default ValueConstants.DEFAULT_NONE;
}

使用方式如下�Q?br />
void deleteUser(@RequestParam(value="id",required=false) Long id)  { }

2、元注解

元注解是指注解的注解。包�?nbsp; @Retention @Target @Document @Inherited四种�?br />

2.1、@Retention: 定义注解的保留策�?/h4>
@Retention(RetentionPolicy.SOURCE)   注解仅存在于源码中，在class字节码文件中不包�?/span>

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

@Retention(RetentionPolicy.RUNTIME)   注解会在class字节码文件中存在�Q�在�q�行时可以通过反射获取�?/span>
2.2、@Target�Q�定义注解的作用目标

@Target(ElementType.TYPE)   接口、类、枚举、注�?/span>

@Target(ElementType.FIELD) 字段、枚丄��帔R��

@Target(ElementType.METHOD) �Ҏ��

@Target(ElementType.PARAMETER) �Ҏ��参数

@Target(ElementType.CONSTRUCTOR) 构造函�?/span>

@Target(ElementType.LOCAL_VARIABLE) 局部变�?/span>

@Target(ElementType.ANNOTATION_TYPE) 注解

@Target(ElementType.PACKAGE) �?/span>
2.3、@Document�Q�说明该注解��被包含在javadoc�?/h4>
2.4、@Inherited�Q�说明子�c�d��以��承父�c�M��的该注解
3、通过反射��d��注解

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

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

   /**获得该元素中某个注解�c�d��的注�?/span>*/
    <T extends Annotation> T getAnnotation(Class<T> annotationClass);

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

    /**获得该元素自�w�什么的注解�Q�不包含�l�承得到的注�?/span>/
    Annotation[] getDeclaredAnnotations();
}

java.lang.Package
java.lang.Class
java.lang.reflect.Construtor
java.lang.reflect.Field
java.lang.reflect.Method
均实��C��该接口，所以我们可以通过反射获取�?Class、Construtor、Field、Mehtod�{�，然后再通过上述接口�Ҏ��Q�获得作用在�q�些元素上的注解�?br />下面是RequestParam注解的��用，��Z��于演�C�，略作修改�Q�见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、常见注解的说明及��?/h2>@Override :@Target(ElementType.METHOD)   @Retention(RetentionPolicy.SOURCE) 说明�Ҏ��是对父类�Ҏ��的覆盖，用于�~�译器编译时�q�行��?br />@Deprecated: @Documented @Retention(RetentionPolicy.RUNTIME)   用于��不要使用某元�?br />@SuppressWarnings�Q�@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 一文笔�?br />
在java中，��Z��提高性能�Q�线�E�一般把变量从内存中备䆾一个副本到寄存器。volatile 关键字意思是易失性，明确表示
一个变量是会被多线�E�访问的�Q�每个线�E�在每次��d��都要从内存读取原始副本的��|��而不是缓存在寄存器中的倹{��每�ơ修�?br /> 都是把值写回到内存中�?br />
Java语言包含两种内在的同步机�Ӟ��同步块（或方法）�?volatile 变量�?br />
synchronized锁提供了两种主要�Ҏ��：互斥�Q�mutual exclusion�Q?/em> �?em>可见性（visibility�Q?/em>。互斥即一�ơ只允许一个线�E�持有某个特定的锁，因此可��用该�Ҏ��实现对�׃�n数据的协调访问协议，�q�样�Q�一�ơ就只有一个线�E�能够��用该�׃�n数据。可见性必��ȝ��保释��N��之前对共享数据做出的更改对于随后获得该锁的另一个线�E�是可见的�?否则�Q�线�E�看到的�׃�n变量可能是修改前的值或不一致的��|��引发严重问题�?

volatile能够实现上述可见性，因�ؓ�U�程每次都是��d��原始版本的��|��前一个线�E�的修改对后�l�线�E�来说是可见的。但volatile不能��保互斥�?br />
volatile适用的原则：

对变量的写操作不依赖于当前倹{�?/li>
该变量没有包含在��h��其他变量的不变式中�?/li>
所以volatile不能用作计数器，因�ؓ计数器的自增是一个读-�?写的�q�程�Q�不是原子操作，在volatile不确保互斥的情况下，�l�果不准��?br /> 不变式的意思是一个需要不变的规律�Q�如起始要小于等于结束。上�q?点简单来��_��卛_��量真正独立于其他变量和自�׃��前的�?�Q?在这�?br /> 情况下可以��?volatile 代替 synchronized 来简化代码�?br />
volatile�׃��不阻塞线�E�，在性能一般比synchronized表现更好�?br />
适用volatile的几个场景：
1、状态标�?nbsp; 比如标示服务启动或停止�?br /> 2、独立观�?nbsp; 定期 “发布” 观察�l�果供程序内部��用，
3�?a name="listing6">�l�合使用 volatile �?synchronized 实现 “开销较低的读�Q�写�?#8221;

@ThreadSafe
public class CheesyCounter {
private volatile int value;
// 使用volatile实现可见性，开销�?br /> public int getValue() { return value; }
// 使用synchronized实现互斥
public synchronized int increment() {
return value++;
}
}

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

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

核心java.lang.reflect.Proxy�c?br />

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

java.lang.reflect.InvocationHandler接口

// 反射调用代理�c�L��?/span>
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;

org.springframework.aop.framework.JdkDynamicAopProxy
springframeworkAOP�Ҏ��实现的基础之一�Q�通过动态代理实�?br />
  1 package org.springframework.aop.framework;
  2
  3 final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  4
  5     /** 代理的配�|�信�?nbsp;*/
  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动态代理创��Z��理对�?/span>
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                 // 如果拦截链是�I�的�Q�直接通过反射调用target对象的方�?br /> 78                 // method.invoke(target, args);
79                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
80             }else {
81                 // 如果拦截链不为空�Q�包装一个反��方法调�?br /> 82                 // 先调用织入的拦截器，最后仍然是反射调用target对象的方�?/span>
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 是一�U?strong>内省机制�Q�帮助程序在�q�行�?/strong>对自�w�及软�g环境�q�行��查，�q�根据检查得到的�E�序�l�构�Q�改变自�w�的部分行�ؓ�?

核心�c�Mؓ java.lang.Class �c�，抽象了程序的元数据，每一个类的元数据��是一个Class对象实例。这个Class实例是一个静态实例，对应�cȝ��每一个实例都会关联这个静态实例。通过Class�c�d��以查询该�cȝ��Ҏ��、字�D�c��接口、构造器�{�一�p�d��信息。详见下面�?

对象回去自��n对应的Class实例是通过�l�承自Object�cȝ��getClass()�Ҏ��Q?
对于基本�c�d��Q�每一�U�也有一个名为class的静态实例，如int.class double.class boolean.class�Q?
对于数组�c�d��Q�也有Object[].class, 注意 int[][].class==int[].class

判断对象�c�d��的接口：
String getName() 获得�c�d��?
Class getComponentType() 如果对象是数�l�，�q�回数据中元素的�cȝ��?
boolean isArray()
boolean isInterface()
boolean isPrimitive()
boolean isAnnotation()

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

Class�c�d��Object�c�d��在比较纠�l�的关系
Class.class.isIntance(Class.class) == true Class�cȝ��class实例是Class本��n的实�?
Class.class.isInstance(Object.class) == true
Object.class.isAssignableFrom(Class.class) == true
Object.class.isIntance(Class.class) == true

###########################################################################################################
java.lang.reflect部分�c�d��

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

java.lang.reflect.Constructor
java.lang.Class中相��x��?

Constructor getConstructor(Class[] parameterTypes)
Constructor getDeclaredConstructor�Q�Class[]parameterTypes)
Constructor[] getConstructors()
Constructor[] getDeclaredConstructors()

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

对于数组�Q��?java.lang.reflect.Array.newInstance(String.class,5)形式创徏实例

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

java.lang.reflect.Method

java.lang.Class�c�M��定义了如下接口查询一个类所��h��的方法�?
Method getMethod(String name,Class[]parameterTypes)
Method[] getMethods()
上述2个接口查询��承获得和自��n声明的方�?
Method getDeclaredMethod(String name,Class[]parameterTypes)
Method[] getDeclaredMethods()
上述2个接口查询自�w�声明的�Ҏ��

java.lang.reflect.Method�c�d��义的�Ҏ��
Class getDeclaringClass() 声明该方法的�c�d��?
Class[] getExceptionTypes() �Ҏ��的异常类�?
int getModifiers() �Ҏ��的可见�?
String getName() �Ҏ��?
Class[] getParameterTypes() �Ҏ��参数�c�d��
Class getReturnType() �Ҏ��q�回�c�d��
Object invoke(Object obj,Object[]args) 反射调用一个对象上面的该方�?

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

java.lang.reflect.Field

java.lang.Class�c�M��关于Field的相��x��法：
Field getField(String name)
Field[] getFields()
Field getDeclaredField(String name)
Field[] getDeclaredFields()

java.lang.relect.Field中主要方�?
Class getType() �q�回字段的Class
Class getDeclaringClass() �q�回什么该字段的Class
String getName()
int getModifiers()
Object get(Object obj) �q�回obj该字�D늚��?
boolean getBoolean(Object obj)
void set(Object obj,Object value) 讄��obj该字�D늚��?
void setBoolean(Object obj,boolean value)

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

java.lang.reflect.Modifier 字段或者方法的讉K��?
static boolean isPublic(int mod)
static boolean isPrivate(int mod)

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

###########################################################################################################
动态加�?br />
Class cls = Class.forName(String className);
Object obj = cls.newInstance();

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

注意�Q�基本类型，不能通过Class.forName�Q�）加蝲,会抛出异�?br />

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

liucs — Thu, 31 Mar 2011 06:05:00 GMT
Java在方法参��C��递时�Q?br />
1、对于基本类型，传递�?br /> 2、对于对象类型，传递对象引�?br /> 需要注意的是：对于上述两种传递类型，在传递时都是拯��传递，卛_��g��递时拯��Z��个新��|��引用
传递时拯��Z��个新的拷贝�?br />
有时候也说Java只有��g��递，意思是对于引用�c�d��Q�传递引用的倹{��一个概念，不用�U�缠�?br />
在内存中对象�c�d��可以看做两块�Q�一块是对象的引用，一块是数据区。引用块里面保存了数据区的地址�?br /> 看如下示例代码：

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

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

亚洲精品成a人在线观看夫,亚洲av一综合av一区,久久亚洲精品11p

Java Annotation 注解

Annotation�Q�注解）是什么？

2、元注解

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

2.3、@Document�Q�说明该注解���被包含在javadoc�?/h4>

2.4、@Inherited�Q�说明子�c�d��以��承父�c�M��的该注解

3、通过反射��d��注解

Volatile变量

Java 反射

2.3、@Document�Q�说明该注解��被包含在javadoc�?/h4>