ok!ko
ok!ko

java--注解和反射

一、注解

1.1 注解Annotation的概念

1.注解的作用：

注解Annotation是从JDK1.5开始引入的新技术，我们在编程中经常会使用到注解，它的作用有：

1) 编译检查：比如@SuppressWarnings，@Deprecated和@Override都具有编译检查作用；

2) 替代配置文件：使用反射来读取注解信息。

目前大部分框架（如Spring）都使用了注解简化代码并提高编码的效率（使用注解之前使用的xml进行配置）。

注解其实就是对程序作出解释（这一点和注释类似），不是程序本身，可以被其他程序读取。可以通过注解告诉类如何运行。

2.注解的使用范围：

在Java技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。注解可以标记在package包、class类、field属性、method方法等上面，且在同一个地方可以同时标记多个注解。

注解可以在编译(source),类加载(class),运行时(runtime)被读取，并执行相应的处理，以便于其他工具补充信息或者进行部署。

3.注解的格式：

@注解名称（参数名=“参数值”，...）

例如：@SuppressWarnings(value = "unchecked")

4.注解的作用分类：

编写文档：通过代码里标识的注解生成文档（生成文档doc文档）

代码分析：通过代码里标识的注解对代码进行分析（使用反射）

编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查（@SuppressWarnings等）

1.2 内置注解

主要的内置注解有三个：

@Override -只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明。

@Deprecated -标记过时的方法，不建议使用该方法。

@SuppressWarnings -用来抑制编译时的警告信息，还需要添加一个参数。

@SuppressWarnings("all/unchecked")，指示关闭警告的范围。

1.3 元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明.

1.@Target -用来描述注解可以使用的范围（比如：方法、类或字段），其中ElementType是枚举类型。若没有@Target，则该注解可以用于任何地方。

public enum ElementType {
    /**标明该注解可以用于类、接口（包括注解类型）或enum声明*/
    TYPE,
    /** 标明该注解可以用于字段(域)声明，包括enum实例 */
    FIELD,
    /** 标明该注解可以用于方法声明 */
    METHOD,
    /** 标明该注解可以用于参数声明 */
    PARAMETER,
    /** 标明注解可以用于构造函数声明 */
    CONSTRUCTOR,
    /** 标明注解可以用于局部变量声明 */
    LOCAL_VARIABLE,
    /** 标明注解可以用于注解声明(应用于另一个注解上)*/
    ANNOTATION_TYPE,
    /** 标明注解可以用于包声明 */
    PACKAGE,
    /**
     * 标明注解可以用于类型参数声明（1.8新加入）
     * @since 1.8
     */
    TYPE_PARAMETER,
    /**
     * 类型使用声明（1.8新加入)
     * @since 1.8
     */
    TYPE_USE
}

比如：@Target(value = {ElementType.TYPE,ElementType.METHOD})，表示该注解可以用在类（接口）或者方法上。

2.@Retention用来约束注解的生命周期，分别有三个值，源码级别source、类文件级别class和运行时级别runtime。若没有@Retention，则默认是类文件级别class。(生命周期source)

SOURCE：注解将被编译器丢弃（该类型的注解信息只会保留在源码里，源码经过编译后，注解信息会被丢弃，不会保留在编译好的class文件里）

CLASS：注解在class文件中可用，但会被JVM丢弃（该类型的注解信息会保留在源码里和class文件里，在执行的时候，不会加载到虚拟机中）。

RUNTIME：注解信息将在运行期(JVM)也保留，因此可以通过反射机制读取注解的信息（源码、class文件和执行的时候都有注解的信息），如SpringMvc中的@Controller、@Autowired、@RequestMapping等。

3.@Documented -说明该注解将被包含在用户文档javadoc中

4.@Inherited -说明子类可以继承父类中的该注解。如：当类B继承了类A，@Inherited注解加到了A上，则B也会带上该注解。

1.4 自定义注解

使用@interface来声明一个注解，格式：public @interface 注解名{ 定义内容； }，定义内容中的每一个“方法”实际上是声明了一个配置参数。如下，定义了MyAnnotation注解：

@Target({ElementType.TYPE,ElementType.METHOD}) //作用范围

@Retention(RetentionPolicy.RUNTIME) //生命周期

@Documented // 生成javadoc中含有

@Inherited // 子类可以继承

@interface MyAnnotation{

String value() default ""; //使用类型 名称（）默认值 的格式；

int age();

String[ ] school() default {"yndx", "清华大学"};

}

该注解中有三个配置参数，String类型的value，int类型的age和String数组类型的school，其中使用default定义了默认值。

注意：

定义注解时，意味着它实现了 java.lang.annotation.Annotation 接口，即该注解就是一个Annotation。

和我们通常 implements实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 @interface 定义注解后，该注解不能继承其他注解或接口。

二、反射

2.1 Java反射机制概述

2.1.1 静态语言和动态语言

1.动态语言：是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

主要的动态语言有：C#、JavaScript、PHP、Python等；

function f() {  
    var x = "var a=3;var b=5;alert(a+b)";  
    eval(x);  
//    运行时改变x的类型和值  
}

2.静态语言：与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

注：Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

2.1.2 Reflection反射

Reflection（反射)是java被视为动态语言的关键，反射机制允许程序在指定期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射。

java--注解和反射_第1张图片

2.1.3 Java反射机制提供的功能

在运行时判断任意一个对象所属的类；

在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；

在运行时获取泛型信息；

在运行时调用任意一个对象的成员变量和方法；

在运行时处理注解；

生成动态代理；

2.1.4 Java反射的优点和缺点

优点：可以实现动态创建对象和编译，体现出很大的灵活性。

缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作（直接通过对象操作的方式）。

2.2 理解Class类并获取Class实例

2.2.1 Class类

1.概述

对象照镜子后可以得到一个信息：某个类的属性、方法和构造器，某个类到底实现了哪些接口。

对于每个类而言，JRE都为其保留一个不变的Class类型的对象，一个Class对象包含了特定某个结构的有关信息。

Class本身也是一个类。

Class对象只能由系统建立。

一个加载的类在JVM中只会有一个Class实例。

一个Class对象对应的是一个加载到JVM中的.class文件。

每个类的实例都会记得自己是由哪个Class实例所生成的。

通过Class可以完整地得到一个类中的所有被加载的结构。

Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

2.Class类的常用方法：

ClassforName(String name);返回指定类名name的Class对象。

Object newInstance();调用缺省构造函数，返回Class对象的一个实例。

getName();返回此Class对象所表示的实体类（类、接口、数组类或void）的名称。

Class getSuperClass();返回当前Class对象的父类的Class对象。

Class[ ] getinterfaces();获取当前Class对象的接口。

ClassLoader getClassLoader();返回该类的类加载器。

Constructor[ ] getConstructors();返回一个包含某些Constructor对象的数组。

Method getMothed(String name,Class… T);返回一个Method对象，此对象的形参类型为paramType。

Field[ ] getDeclaredFields();返回Field对象的一个数组。

2.2.2 获得Class类的方式

1.若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。如：

Class clazz = Person.class;

2.已知某个类的实例，调用该实例的getClass()方法获取Class对象。如：

Class clazz = person.getClass();

在Object类中定义了getClass()方法，此方法被所有子类继承：

public final Class getClass()；

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即:可以通过对象反射求出类的名称。

java--注解和反射_第2张图片

因此，所有类都继承了getClass()方法。

3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException。如：

Class clazz = Class.forName("demo01.Student");

4.内置基本数据类型可以直接用类名.Type。

Class c = Integer.TYPE;

5.还可以利用ClassLoader。

2.2.3 哪些类型有Class对象

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

interface：接口

[ ]：数组

enum：枚举

annotation：注解@interface

primitive type：基本数据类型

void：空类型

import java.lang.annotation.ElementType;  
  
// 所有类型的class  
public class Test04 {  
  
    public static void main(String[] args) {  
        Class c1 = Object.class;    // 类  
        Class c2 = Comparable.class;    // 接口  
        Class c3 = String[].class;  // 一维数组  
        Class c4 = int[][].class;   // 二维数组  
        Class c5 = Override.class;   // 注解  
        Class c6 = ElementType.class;   // 枚举  
        Class c7 = Integer.class;   // 基本数据类型  
        Class c8 = void.class;   //void  
        Class c9 = Class.class;      // Class类型  
  
        System.out.println(c1);  
        System.out.println(c2);  
        System.out.println(c3);  
        System.out.println(c4);  
        System.out.println(c5);  
        System.out.println(c6);  
        System.out.println(c7);  
        System.out.println(c8);  
        System.out.println(c9);  
  
        // 只要元素类型与维度一样就是同一个Class。  
        int[] a = new int[10];  
        int[] b = new int[100];  
        System.out.println(a.getClass().hashCode());  
        System.out.println(b.getClass().hashCode());  
    }  
} 
   
运行结果：
 
   
 
    
 
     
 java--注解和反射_第3张图片 
     
 
    
 
   
 
   
2.3 类的加载与ClassLoader
 
   
2.3.1 Java内存分析
 
   
堆
 
   
存放new的对象和数组；
 
   
可以被所有的线程共享，不会存放别的对象的引用。
 
   
栈
 
   
存放基本变量类型（会包含这个基本类型的具体数值）；
 
   
引用对象的变量（会存放这个引用在堆里面的具体地址）。
 
   
方法区
 
   
可以被所有的线程共享；
 
   
包含了所有的class和static变量。
 
   
2.3.2 类的加载过程
 
   
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过这三个步骤对该类进行初始化：
 
   
1.类的加载（Load）
 
   
将类的class文件读入内部，并为之创建一个java.lang.Class对象。此过程由类加载器完成
 
   
加载:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
 
   
2.类的链接（Link）
 
   
将类的二进制数据合并到JRE中；
 
   
链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。包括：
 
   
验证:确保加载的类信息符合JVM规范，没有安全方面的问题
 
   
 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
 
   
 解析:虚拟机常量池内的符号引用（常量名）替换为直接引用(地址)的过程。
 
   
3.类的初始化（Initialize）
 
   
 1）JVM负责对类进行初始化：
 
   
 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(<类构造器是构造类信息的，不是构造该类对象的构造器>)。
 
   
 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
 
   
 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
 
   
 2）什么时候会发生类的初始化？
 
   
 1.类的主动引用（一定会发生类的初始化）
 
   
 当虚拟机启动，先初始化main方法所在的类;
 
   
 new 一个类的对象;
 
   
 调用类的静态成员（除了final常量）和静态方法;
 
   
 使用java.lang.reflect包的方法对类进行反射调用;
 
   
 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类。
 
   
 2.类的被动引用（不会发生类的初始化）
 
   
 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
 
   
 通过数组定义类引用，不会触发此类的初始化；
 
   
 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）。
 
   
 
   
代码演示：
 
   
public class Test05 {  
  
    public static void main(String[] args) {  
        A a = new A();  
        System.out.println(A.m);  
    }  
}  
  
class A{  
  
    static {  
        System.out.println("A类静态代码块初始化");  
        m = 300;  
    }  
  
    static int m = 100;  
  
    public A(){  
        System.out.println("A类的无参数构造函数初始化");  
    }  
}
 
   
运行结果：
 
   
 
    
 
     
 java--注解和反射_第4张图片 
     
 
    
 
   
 
   
解释：
 
   
执行过程
 
   
1.加载到内存，会产生一个类对应Class对象；
 
   
2.链接，连接结束后分配内存设置初始值 m=0；
 
   
3.初始化
 
   
 (){ //将静态代码块合并执行
 
   
System.out.println("A类静态代码块初始化");
 
   
m=300
 
   
m=100}
 
   
2.3.3 类的加载器
 
   
类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
 
   
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将持续加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
 
   
 
    
 
     
 java--注解和反射_第5张图片 
     
 
    
 
   
 
   
 
   
类加载器的分类
 
   
引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库,用来装载核心类库，该加载器无法直接获取。
 
   
扩展类加载器：负责jre/lib/ext目录下的jar包或-D Java.ext.dirs指定目录下的jar包装入工作库
 
   
系统类加载器：负责java -classpath或 -D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器。
 
   
 
    
 
     
 java--注解和反射_第6张图片 
     
 
    
 
   
 
   
 
   
public class Test07 {  
    public static void main(String[] args) throws ClassNotFoundException {  
        // 获取系统类的加载器  
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();  
        System.out.println(systemClassLoader);  
  
        // 获取系统类加载器的父类加载器 --> 扩展类加载器  
        ClassLoader parent = systemClassLoader.getParent();  
        System.out.println(parent);  
  
        // 获取扩展类加载器的父类加载器 -->  根加载器(c/c++实现)  
        ClassLoader parent1 = parent.getParent();  
        System.out.println(parent1);  
  
        //测试当前类是哪个类加载器加载的  
        ClassLoader classLoader = Class.forName("com.yjx.reflection.Test07").getClassLoader();  
        System.out.println(classLoader);  
  
        // 测试JDK内置的类是谁加载的  
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();  
        System.out.println(classLoader1);  
  
        //  如何获得系统类加载器可以加载的路径  
        System.out.println(System.getProperty("java.class.path"));  
    }  
}
 
   
2.4 Class对象的作用
 
   
2.4.1 使用Class对象获得运行时类的完整结构
 
   
通过反射获取运行时类的完整结构：Field属性、Method方法、Constructor构造器、SuperClass父类、Interface接口、Annotation注解
 
   
import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
// 获取类的信息  
public class Test08 {  
  
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {  
        Class c1 = Class.forName("com.yjx.reflection.User");  
        
//        User user = new User();  
//        c1 = user.getClass();       //通过反射也能获得类Class  
  
        // 获得类的名字  
        System.out.println(c1.getName());       // 获得包名 + 类名  
        System.out.println(c1.getSimpleName());   // 获得类名  
  
        // 获得类的属性  
        System.out.println("================");  
        Field[] fields = c1.getFields();      //  只能找到public属性  
        for (Field field : fields) {  
            System.out.println(field);  
        }  
  
        //  获得类的属性   能打印出来  
        System.out.println("==========");  
        Field[] declaredFields = c1.getDeclaredFields();    // 找到全部的属性  
        for (Field declaredField : declaredFields) {  
            System.out.println(declaredField);  
        }  
  
        //  获得指定属性  
        System.out.println(c1.getDeclaredField("age"));  
  
        //获得类的方法  
        System.out.println("=====获得类的方法1=====");       //获得本类和父类的所有public方法：User类和Object类  
        Method[] methods = c1.getMethods();  
        for (Method method : methods) {  
            System.out.println(method);  
        }  
  
        System.out.println("=====获得类的方法2=====");  
        Method[] declaredMethods = c1.getDeclaredMethods();       // 获得本类的所有方法  
        for (Method declaredMethod : declaredMethods) {  
            System.out.println(declaredMethod);  
        }  
  
        // 获得指定的方法  
        System.out.println("获得指定的方法============");  
        Method getName = c1.getMethod("getName", null);  //需要方法名和参数类型  ==>  解决重载问题  
        Method setName = c1.getMethod("setName", String.class);  
        System.out.println(getName);  
        System.out.println(setName);  
  
  
        //  获得所有的构造器  
        System.out.println("获得构造器===========");  
        Constructor[] constructors = c1.getConstructors();    // 获得本类的public构造方法  
        for (Constructor constructor : constructors) {  
            System.out.println(constructor);  
        }  
        constructors = c1.getDeclaredConstructors();        // 获得本类所有的构造方法  
        for (Constructor constructor : constructors) {  
            System.out.println("****" + constructor);  
        }  
  
        // 需要指明构造器参数类型  
        System.out.println("获得指定构造器：" + c1.getDeclaredConstructor(null));  
        System.out.println("获得指定构造器：" + c1.getDeclaredConstructor(int.class, int.class, String.class));  
    }  
}
 
   
2.4.2 创建对象
 
   
创建类的对象：调用Class对象的newInstance()方法
 
   
1.类必须有一个无参数的构造器；
 
   
没有无参构造器创建对象的方法：
 
   
只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作：
 
   
 步骤：
 
   
 1.通过Class类的getDeclaredConstructor(Class...parameterTypes)取得本类的指定形参类型的构造器；
 
   
 2.向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数；
 
   
 3.通过Constructor实例化对象。
 
   
2.类的构造器的访问权限需要足够。
 
   
import java.lang.reflect.Field;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
  
//  动态的创建对象， 通过反射  
public class Test09 {  
  
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {  
  
        // 获得class对象  
        Class c1 = Class.forName("com.yjx.reflection.User");  
  
        // 构造一个对象   使用无参构造器  
//        User user = (User)c1.getDeclaredConstructor(null).newInstance();   //本质是调用了类的无参构造器  
//        System.out.println(user);  
  
        //  使用有参构造器创建对象  
        User user = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(18, 1, "yjx");  
        System.out.println(user);  
  
        // 通过反射调用普通方法  
        User user1 = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(24, 2, "dyt");  
        // 通过反射获取一个方法  
        Method setName = c1.getDeclaredMethod("setName", String.class);  
        setName.invoke(user1, "tt");       //invoke（）激活的意思，  (对象，“方法的值”)  
        System.out.println(user1.getName());  
  
  
        // 通过反射操作属性  
        User user2 = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(22, 3, "dyt");  
        Field name = c1.getDeclaredField("name");  
  
        // 操作私有属性name   不能直接操作私有属性，我们需要关闭程序的安全检测，通过设置属性或者方法的setAccessible(true)实现  
        name.setAccessible(true);   // 关掉私有权限访问的问题  
        name.set(user2, "框看");  
        System.out.println(user2.getName());  
    }  
}
 
   
2.4.3 调用指定方法
 
   
调用指定的方法：
 
   
1.通过Class类的getMethod("方法名", 参数类型列表)获得一个Method对象；
 
   
2. Method.invoke("执行方法的对象",参数值列表)进行调用，格式：
 
   
Object invoke（Object obj, Object...args）：
 
   
Object对应原方法的返回值，若原方法没有返回值，此时返回null；
 
   
若原方法为静态方法，此时形参Object obj可为null；
 
   
若原方法形参列表为空，则Object[ ]args为null；
 
   
若原方法声明为private，则需要在调用此invoke（）方法前，显式调用方法对象的setAccessible(true)方法，才可访问该方法。
 
   
（代码示例同上）
 
   
2.4.4 性能分析
 
   
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
  
// 分析性能问题  
public class Test10 {  
  
  
    //  普通方式调用  
    public static void test01(){  
        User user = new User();  
  
        long startTime = System.currentTimeMillis();  
        for (int i = 0; i < 1000000000; i++) {  
            user.getName();  
        }  
        long endTime = System.currentTimeMillis();  
  
        System.out.println("普通方式执行10亿次：" + (endTime - startTime) + "ms");  
    }  
  
    // 反射方式调用  
    public static void test02() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {  
        User user = new User();  
        Class c1 = user.getClass();  
        Method getName = c1.getDeclaredMethod("getName",null);  
        long startTime = System.currentTimeMillis();  
        for (int i = 0; i < 1000000000; i++) {  
            getName.invoke(user,null);  
        }  
        long endTime = System.currentTimeMillis();  
  
        System.out.println("通过反射的方式调用10亿次：" + (endTime-startTime) + "ms");  
    }  
  
    // 反射方式调用 + 关闭检测  
    public static void test03() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {  
        User user = new User();  
        Class c1 = user.getClass();  
        Method getName = c1.getDeclaredMethod("getName", null);  
        getName.setAccessible(true);    //关闭检测  
        long startTime = System.currentTimeMillis();  
        for (int i = 0; i < 1000000000; i++) {  
            getName.invoke(user,null);  
        }  
        long endTime = System.currentTimeMillis();  
  
        System.out.println("通过反射的方式和关闭检测调用10亿次：" + (endTime-startTime) + "ms");  
    }  
  
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {  
        test01();  
        test02();  
        test03();  
    }  
}
 
   
运行结果：
 
   
 
    
 
     
 java--注解和反射_第7张图片 
     
 
    
 
   
 
   
 
   
2.4.5 通过反射获取泛型信息
 
   
通过反射获取泛型
 
   
Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成﹐所有和泛型有关的类型全部擦除。
 
   
为了通过反射操作这些类型，Java新增了ParameterizedType , GenericArrayType ,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
 
   
ParameterizedType:表示一种参数化类型,比如Collection 
 
   
GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
 
   
TypeVariabie:是各种类型变量的公共父接口
 
   
WildcardType:代表一种通配符类型表达式
 
   
import java.lang.reflect.Method;  
import java.lang.reflect.ParameterizedType;  
import java.lang.reflect.Type;  
import java.util.List;  
import java.util.Map;  
  
//   通过反射获取泛型  
public class Test11 {  
  
    public static void test01(Map map, List list){  
        System.out.println("test01");  
    }  
  
    public Map test02(){  
        System.out.println("test02");  
        return null;    }  
  
    public static void main(String[] args) throws NoSuchMethodException {  
        Method method = Test11.class.getDeclaredMethod("test01", Map.class, List.class);  
        Type[] genericParameterTypes = method.getGenericParameterTypes();        //获得泛型的参数  
        for (Type genericParameterType : genericParameterTypes) {  
            System.out.println("#"+genericParameterType);  
            if (genericParameterType instanceof ParameterizedType){   //如果类型是参数化类型/泛型  
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();  
                for (Type actualTypeArgument : actualTypeArguments) {  
                    System.out.println(actualTypeArgument);  
                }  
            }  
        }  
  
        Method method2 = Test11.class.getDeclaredMethod("test02", null);  
        Type genericReturnType = method2.getGenericReturnType();  
        if (genericReturnType instanceof ParameterizedType){  //如果返回值类型是参数化类型/泛型  
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();  
            for (Type actualTypeArgument : actualTypeArguments) {  
                System.out.println("**" + actualTypeArgument);  
            }  
        }  
    }  
}
 
   
2.4.6 反射操作注解
 
   
注解类：
 
   
// 类名的注解  
@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@interface Tablekuang{  
    String value();  
}  
  
// 属性的注解  
@Target(ElementType.FIELD)  
@Retention(RetentionPolicy.RUNTIME)  
@interface Fieldkuang{  
    String columnName();  
    String type();  
    int length();  
}
 
   
实体类：
 
   
@Tablekuang("db_student")  
class Student2{  
    @Fieldkuang(columnName = "db_id",type = "int", length = 10)  
    private int id;  
    @Fieldkuang(columnName = "db_age",type = "int", length = 10)  
    private int age;  
    @Fieldkuang(columnName = "db_name",type = "varchar", length = 3)  
    private String name;  
  
    public Student2(int id, int age, String name) {  
        this.id = id;  
        this.age = age;  
        this.name = name;  
    }  
  
    @Override  
    public String toString() {  
        return "Student2{" +  
                "id=" + id +  
                ", age=" + age +  
                ", name='" + name + '\'' +  
                '}';  
    }  
  
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public Student2() {  
    }  
}
 
   
测试：
 
   
import java.lang.annotation.*;  
import java.lang.reflect.Field;  
  
// 练习反射操作注解  
public class Test12 {  
  
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {  
        Class c1 = Class.forName("com.yjx.reflection.Student2");  
  
        // 通过反射获得注解  
        Annotation[] annotations = c1.getAnnotations();  
        for (Annotation annotation : annotations) {  
            System.out.println(annotation);  
        }  
  
        // 获得指定注解的value的值  
        Tablekuang tablekuang = c1.getAnnotation(Tablekuang.class);  
        String value = tablekuang.value();  
        System.out.println("tablekuang注解的值为：" + value);  
  
        // 获得类指定属性的指定值注解  
        Field f = c1.getDeclaredField("id");  
        Fieldkuang annotation = f.getAnnotation(Fieldkuang.class);  
        System.out.println(annotation.columnName());  
        System.out.println(annotation.type());  
        System.out.println(annotation.length());  
  
        // 反射框架的实现就是利用这个获得信息，实现SQL语言的拼接  
    }  
}
 
   
运行结果：
 
   
 
    
 
     
 java--注解和反射_第8张图片 
     
 
    
 
   
 
   
 
   
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,jvm,spring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • Spring中@Value注解，需要注意的地方
                                    无量
springbean@Valuexml
                                    
    Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 
 
 
1、在applicationContext.xml文件(或引用文件中)中配置properties文件 
 
<bean id="appProperty"
    class="org.springframework.beans.fac
    
                                
    • 
                                
  • mongoDB 分片
                                    开窍的石头
mongodb
                                    
        mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。 
    第一步启动两台以上的mongo服务 
&nb
    
                                
    • 
                                
  • OVER(PARTITION BY)函数用法
                                    0624chenhong
oracle
                                    
    这篇写得很好，引自 
http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html 
 
 
OVER(PARTITION BY)函数用法 
 
 2010年10月26日 
 
OVER(PARTITION BY)函数介绍 
 
开窗函数        &nb
    
                                
    • 
                                
  • Android开发中，ADB server didn't ACK 解决方法
                                    一炮送你回车库
Android开发
                                    
    首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。 
  
一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 
参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 
简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 
&nb
    
                                
    • 
                                
  • canvas中的像素绘制问题
                                    换个号韩国红果果
JavaScriptcanvas
                                    
    pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 
2.如果绘制点为一个像素的
    
                                
    • 
                                
  • 编码乱码问题
                                    灵静志远
javajvmjsp编码
                                    
    1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 
3、getBytes()、getByte
    
                                
    • 
                                
  • java 求几个月后的日期
                                    darkranger
calendargetinstance
                                    
    Date plandate = planDate.toDate();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(plandate);
// 取得三个月后时间
cal.add(Calendar.M
    
                                
    • 
                                
  • 数据库设计的三大范式（通俗易懂）
                                    aijuans
数据库复习
                                    
    关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 
目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
    
                                
    • 
                                
  • 想学工作流怎么入手
                                    atongyeye
jbpm
                                    
    工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 
 
 
系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 
 
本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 
 
1  首先要
    
                                
    • 
                                
  • Context和SQLiteOpenHelper创建数据库
                                    百合不是茶
androidContext创建数据库
                                    
           一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 
  
  
一:SQLiteOpenHelper创建数据库: 
  
1,SQLi
    
                                
    • 
                                
  • 浅谈group by和distinct
                                    bijian1013
oracle数据库group bydistinct
                                    
            group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。 
        譬如：统计每id数并且只显示数大于3 
select id ,count(id) from ta
    
                                
    • 
                                
  • vi opertion
                                    征客丶
macoprationvi
                                    
    进入 command mode （命令行模式） 
按 esc 键 
再按 shift + 冒号 
 
注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 
 
一、文件操作 
1.1、强制退出不保存 
$ q! 
1.2、保存 
$ w 
1.3、保存并退出 
$ wq 
1.4、刷新或重新加载已打开的文件 
$ e 
 
二、光标移动 
2.1、跳到指定行 
数字
    
                                
    • 
                                
  • 【Spark十四】深入Spark RDD第三部分RDD基本API
                                    bit1129
spark
                                    
      
对于K/V类型的RDD,如下操作是什么含义？ 
  
val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5))
rdd.reduceByKey(_+_).collect 
 reduceByKey在这里的操作，是把
    
                                
    • 
                                
  • java类加载机制
                                    BlueSkator
java虚拟机
                                    
    java类加载机制 
1.java类加载器的树状结构 
引导类加载器 
^ 
| 
扩展类加载器 
^ 
| 
系统类加载器 
java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 
虚拟机区分一个Cla
    
                                
    • 
                                
  • 动态添加文本框
                                    BreakingBad
文本框
                                    
      <script>     var num=1; function AddInput() {      var str="";     str+="<input 
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-单例模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



public class Singleton {
}

/*
 * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题
 */
class LazySingleton
    
                                
    • 
                                
  • iOS应用打包发布常见问题
                                    chenhbc
iosiOS发布iOS上传iOS打包
                                    
    这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 
  
1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
    
                                
    • 
                                
  • 工作流复杂拓扑结构处理新思路
                                    comsci
设计模式工作算法企业应用OO
                                    
     我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
    
                                
    • 
                                
  • oracle 11g新特性Flashback data archive
                                    daizj
oracle
                                    
    1. 什么是flashback data archive 
 
Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。 
    
                                
    • 
                                
  • 多叉树:2-3-4树
                                    dieslrae
树
                                    
        平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 
    1、有一个数据项的节点总是有2个子节点(称为2-节点) 
    2、有两个数据项的节点总是有3个子节点(称为3-节
    
                                
    • 
                                
  • C语言学习七动态分配 malloc的使用
                                    dcj3sjt126com
clanguagemalloc
                                    
    /*
	2013年3月15日15:16:24
	malloc 就memory(内存) allocate(分配)的缩写
	本程序没有实际含义，只是理解使用	
 */
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int i = 5;	//分配了4个字节 静态分配
	int * p 
    
                                
    • 
                                
  • Objective-C编码规范[译]
                                    dcj3sjt126com
代码规范
                                    
         
 
  
  原文链接 : The official raywenderlich.com Objective-C style guide  
  原文作者 : raywenderlich.com Team  
  译文出自 : raywenderlich.com Objective-C编码规范  
  译者 : Sam Lau  
  
    
                                
    • 
                                
  • 0.性能优化-目录
                                    frank1234
性能优化
                                    
    从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 
主要内容包括： 
一、性能测试指标 
吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 
http://frank1234.iteye.com/blog/2180305 
 
二、性能测试策略 
生产环境相同 基准测试 预热等 
htt
    
                                
    • 
                                
  • Java父类取得子类传递的泛型参数Class类型
                                    happyqing
java泛型父类子类Class
                                    
      
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

abstract class BaseDao<T> {
	public void getType() {
		//Class<E> clazz =
    
                                
    • 
                                
  • 跟我学SpringMVC目录汇总贴、PDF下载、源码下载
                                    jinnianshilongnian
springMVC
                                    
      
----广告-------------------------------------------------------------- 
网站核心商详页开发 
掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 
掌握数据库技术，表设计和索引优化，分库分表/读写分离； 
了解缓存技术，熟练使用如Redis/Memcached等主流技术； 
了解Ngin
    
                                
    • 
                                
  • the HTTP rewrite module requires the PCRE library
                                    流浪鱼
rewrite
                                    
    ./configure: error: the HTTP rewrite module requires the PCRE library. 
模块依赖性Nginx需要依赖下面3个包 
1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 
2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 
3. s
    
                                
    • 
                                
  • 第12章 Ajax（中）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Optimize query with Query Stripping in Web Intelligence
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence 
and a very straightfoward video 
http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
    
                                
    • 
                                
  • Java开发者写SQL时常犯的10个错误
                                    tomcat_oracle
javasql
                                    
    1、不用PreparedStatements   　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：   　　他们对PreparedStatements不了解   　　他们认为使用PreparedStatements太慢了   　　他们认为写Prepar
    
                                
    • 
                                
  • 世纪互联与结盟有感
                                    阿尔萨斯

                                    
     10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 
 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 
 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
    
                                
    •