反射
概念
用途
反射基本信息
反射相关的类
获取类对象

概念
让一个对象在运行时，能够认清自己，例如知道自己有哪些属性，哪些方法，以及每个属性叫什么名字，是什么类型，是私有还是公有等等
.java文件=>.class(二进制)，程序运行时，JVM会加载到对应类到内存中（.class文件），然后可以使用反射获取到对象的更详细细节
.class文件可以加载出class对象，对象就是类对象（这个对象的图纸，包含了这个对象的内部结构）在方法区中，每个类在使用之前都需要把对应类的的.class文件加载到内存中(类加载)双亲委派模型其实就是一系列的路径查找机制，在合适的目录中找到需要的.class文件，并且要保证同一个类不需要重复加载。
同一个类不管在代码中实际被使用多少次，对应的类对象一定只有一个（类对象是一个单例）单例：有的类只能被实例化一次。
用途
1、当遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应 用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。

2、反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论 是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类 的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。
反射基本信息
Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new

Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
反射相关的类


Class类 是类对象的类型
获取类对象
1、直接通过全限定类名获取,使用 Class.forName(“类的全路径名”); 静态方法
前提：已明确类的全路径名有包的时候就必须加包的路径，还要有异常处理，优点就是在写代码的时候可以不用知道类的具体名字，它可以自动在运行时获取，也可以文本读入、用户输入等方式获得，是最灵活的。



2、通过类的实例化获取,每个类都有隐藏的getClass（）方法



3、通过类来直接获取(仅适合在编译前就已经明确要操作的 Class,最安全可靠，程序性能更高 这说明任何一个类都有一个隐含的静态成员变量 class)



一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的三种类对象进行比较，发现都是true


class Cat{
    private String name;

    public void eat(String food){
        System.out.println(name + "正在吃" + food);
    }
    public Cat(String name){
        this.name = name;
    }
}
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取类对象Cat，Cat类的说明书
        //1、直接通过全限定类名获取
        Class catClass = Class.forName("Cat");
        
        //2、通过类的实例化获取
        Cat cat = new Cat("mimi");
        Class catClass2 = cat.getClass();

        //3、通过类来直接获取
        Class catClass3 = Cat.class;

        System.out.println(catClass == catClass2);
        System.out.println(catClass == catClass3);
        System.out.println(catClass2 == catClass3);

    }

}

反射
反射是什么 有什么用

反射是动态语言的基本特征。java是不是动态语言？所谓动态语言就是在代码的运行期才知道变量的类型。java是

静态语言，在反射之前是做不了动态的创建对象这种事的。在jdk1.4之后出现了反射机制，用反射来实现动态语言

的特性。简单来说，反射就是使用动态的方式，创建对象，调用方法，访问属性。

java中反射的使用都是从内置的Class对象开始的。每个类创建好之后都会生成一个Class对象。

Class对象获取的三种方式
package com.aaa.reflect.entity;

public class Person2 {
		public static void main(String[] args) throws Exception { 
			//第一种方式，通过调用Class.forName方法 
			Class clazz1 = Class.forName("com.aaa.reflect.entity.Person2"); 
			System.out.println(clazz1); 			  	 
			//第二种方式 通过调用来的class对象 
			Class clazz2 = Person2.class; System.out.println(clazz2); 
			//第三种方式 通过调用对象的getClass方法 
			Person2 p= new Person2(); Class clazz3 = p.getClass(); 		  
			System.out.println(clazz3); 
		}
 }

以前做过很多个网站系统，大都是用asp或者php做的，.net也用过，不过是用asp的思路来做.net，基本体现不出vs面向对象的特征。
    最近也要做一个网站，决心用c#，用严格的三层构架+反射工厂来做。于是网上找了一些示例的代码，开始看的是Shangducms和他的开发文档，看完之后，什么感觉没有，一头雾水。连三层构架和反射工厂的含义都没领会。然后听说微软的petshop不错，于是下载petshop4.0，又在csdn找到某大侠写的《petshop详解》，今晚上读了--数据访问层的相关介绍，终于对其构架有了一定的认识。感谢...
   下面吧我认为的精髓部分写下：
    在PetShop中，系统需要处理的数据库对象分为两类：一是数据实体，对应数据库中相应的数据表。它们没有行为，仅用于表现对象的数据。这些实体类都被放到Model程序集中，例如数据表Order对应的实体类OrderInfo，我的理解就是按照数据表的结构创建一个对应的类。这些类的属性分别映射了数据表的列，而每一个对象实例也恰恰对应于数据表的每一行。第二类对象就是对数据表的操作（Select，Insert，Update和Delete）他们仅具有行为而与数据无关，因此它们均被抽象为一个单独的接口模块IDAL，例如数据表Order对应的接口IOrder，其他的都是IXXX，（IXXX）就是接口。
    将数据实体与相关的数据库操作分离出来，符合面向对象的精神。首先，它体现了“职责分离”的原则。将数据实体与其行为分开，使得两者之间依赖减弱，当数据行为发生改变时，并不影响Model模块中的数据实体对象，避免了因一个类职责过多、过大，从而导致该类的引用者发生“灾难性”的影响。其次，它体现了“抽象”的精神，或者说是“面向接口编程”的最佳体现。抽象的接口模块IDAL，与具体的数据库访问实现完全隔离。这种与实现无关的设计，保证了系统的可扩展性，同时也保证了数据库的可移植性。
    现在我们已经有了数据实体，数据对象的抽象接口和实现，可以说有关数据库访问的主体就已经完成了。留待我们的还有两个问题需要解决：
    1、数据对象创建的管理
    2、利于数据库的移植
    在PetShop中，要创建的数据对象包括Order，Product，Category，Inventory，Item。在前面的设计中，这些对象已经被抽象为对应的接口，而其实现则根据数据库的不同而有所不同。也就是说，创建的对象有多种类别，而每种类别又有不同的实现，这是典型的抽象工厂模式的应用场景。
    例如，创建SQL Server的Order对象如下：PetShopFactory factory = new SQLServerFactory();IOrder = factory.CreateOrder();
    要考虑到数据库的可移植性，则factory必须作为一个全局变量，并在主程序运行时被实例化。但这样的设计虽然已经达到了“封装变化”的目的，但在创建PetShopFactory对象时，仍不可避免的出现了具体的类SQLServerFactory，也即是说，程序在这个层面上产生了与SQLServerFactory的强依赖。一旦整个系统要求支持Oracle，那么还需要修改这行代码为：PetShopFactory factory = new OracleFactory();
修改代码的这种行为显然是不可接受的。解决的办法是“依赖注入”。“依赖注入”的功能通常是用专门的IoC容器提供的，在Java平台下，这样的容器包括Spring，PicoContainer等。而在.Net平台下，最常见的则是Spring.Net。不过，在PetShop系统中，并不需要专门的容器来实现“依赖注入”，简单的做法还是利用配置文件和反射功能来实现。也就是说，我们可以在web.config文件中，配置好具体的Factory对象的完整的类名。然而，当我们利用配置文件和反射功能时，具体工厂的创建就显得有些“画蛇添足”了，我们完全可以在配置文件中，直接指向具体的数据库对象实现类，例如PetShop.SQLServerDAL.IOrder。那么，抽象工厂模式中的相关工厂就可以简化为一个工厂类了，所以我将这种模式称之为“具有简单工厂特质的抽象工厂模式”
 

什么是类反射—原理？

☆什么是反射

（1）Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

（2）反射(Reflection)是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查， 也称自审，并能直接操作程序的内部属性。例如，使用它能获得Java类中各成员的名称并显示出来。

（3）Java的这一能力在实际应用中应用得很多，在其它的程序语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。

（4）JavaBean是类反射的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架，基本上都会有反射的使用。

☆反射引例(HelloWorld、USB)

反射最大的好处就是解耦

最简单的类反射：（相当于HelloWorld）

一个ReflectionHelloWorld类演示：

package cn.hncu.reflect.test;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/**

 * 1、类反射使用的步骤：<br>

 *      (1)Class c=Class.forName("类全名：包名[.子包名].类名");<br>

 *      (2)调用c对象中的成员方法：Field(字段)、Method(方法)、Constructor(构造方法)、Modifier(静态方法和常量)<br>

 *      (3)遍历出所有信息<br>

 *@author <a"283505495@qq.com">lxd</a>

 *@version 1.0 2017-4-15 下午12:30:31

 *@fileName ReflectionHelloWorld.java

 */

public class ReflectionHelloWorld {

    public static void main(String[] args) {

        try {

            Class c=Class.forName("cn.hncu.reflect.test.UserModel");

            /*

             * 提供有关类或接口的单个字段信息，以及对他的动态访问权限

             */

            Field[] flds=c.getDeclaredFields();

            for(Field fild:flds){

                System.out.println(fild);

            }

            System.out.println("------------------------");

            /*

             *  提供关于类的单个构造方法的信息以及对它的访问权限。得到的构造方法只能是public类型的。

             */

            Constructor[] cons=c.getConstructors();

            for(Constructor con:cons){

                System.out.println(con);

            }

            System.out.println("------------------------");

            /*

             * 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，

             * 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

             */

            Method[] ms=c.getDeclaredMethods();

            for(Method m:ms){

                System.out.println(m);

            }

            System.out.println("------------------------");

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

UserModel类：

package cn.hncu.reflect.test;

import java.io.Serializable;

/**

 * 用户uuid,name

 *@author <a"283505495@qq.com">lxd</a>

 *@version 1.0 2017-3-20 下午1:56:33

 *@fileName UserModel.java

 */

interface Intera{

    public void aa();

}

public class UserModel implements Serializable{

    private static final long serialVersionUID = 1L;

    private String uuid;

    private String name;

    private int type;

    private String pwd;

    public UserModel(String uuid, String name, int type, String pwd) {

        super();

        this.uuid = uuid;

        this.name = name;

        this.type = type;

        this.pwd = pwd;

    }

    public UserModel(String uuid, String name, int type) {

        super();

        this.uuid = uuid;

        this.name = name;

        this.type = type;

    }

    public UserModel(){

    }

    public void a(){

        System.out.println("我是接口的抽象方法");

    }

    public String getUuid() {

        return uuid;

    }

    public void setUuid(String uuid) {

        this.uuid = uuid;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getType() {

        return type;

    }

    public void setType(int type) {

        this.type = type;

    }

    public String getPwd() {

        return pwd;

    }

    public void setPwd(String pwd) {

        this.pwd = pwd;

    }

    public static long getSerialversionuid() {

        return serialVersionUID;

    }

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());

        return result;

    }

    @Override

    public boolean equals(Object obj) {

        if (this == obj)

            return true;

        if (obj == null)

            return false;

        if (getClass() != obj.getClass())

            return false;

        UserModel other = (UserModel) obj;

        if (uuid == null) {

            if (other.uuid != null)

                return false;

        } else if (!uuid.equals(other.uuid))

            return false;

        return true;

    }

    @Override

    public String toString() {

        return "ID：\t" + uuid + "  , \t" + name + "\t , " + (type);

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

运行结果：

private static final long cn.hncu.reflect.test.UserModel.serialVersionUID

private java.lang.String cn.hncu.reflect.test.UserModel.uuid

private java.lang.String cn.hncu.reflect.test.UserModel.name

private int cn.hncu.reflect.test.UserModel.type

private java.lang.String cn.hncu.reflect.test.UserModel.pwd

------------------------

public cn.hncu.reflect.test.UserModel()

public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int)

public cn.hncu.reflect.test.UserModel(java.lang.String,java.lang.String,int,java.lang.String)

------------------------

public java.lang.String cn.hncu.reflect.test.UserModel.toString()

public int cn.hncu.reflect.test.UserModel.hashCode()

public boolean cn.hncu.reflect.test.UserModel.equals(java.lang.Object)

public java.lang.String cn.hncu.reflect.test.UserModel.getName()

public int cn.hncu.reflect.test.UserModel.getType()

public void cn.hncu.reflect.test.UserModel.setName(java.lang.String)

public static long cn.hncu.reflect.test.UserModel.getSerialversionuid()

public java.lang.String cn.hncu.reflect.test.UserModel.getUuid()

public void cn.hncu.reflect.test.UserModel.setType(int)

public void cn.hncu.reflect.test.UserModel.setPwd(java.lang.String)

public void cn.hncu.reflect.test.UserModel.a()

public java.lang.String cn.hncu.reflect.test.UserModel.getPwd()

public void cn.hncu.reflect.test.UserModel.setUuid(java.lang.String)

------------------------

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

反射使用的三个步骤

用于反射的类，如Method，可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤：

第一步：获得你想操作的类的java.lang.Class对象。在运行中的Java程序中，用java.lang.Class类来描述类和接口等。

第二步：调用诸如getDeclaredMethods的方法，取得该类中定义的所有方法的列表。

第三步：使用反射的API来操作这些信息。

如下面这段代码：

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

Method ms[] = c.getDeclaredMethods();

System.out.println(ms[0].toString());

1

2

3

4

它将以文本方式打印出String中定义的第一个方法的原型。

获取Class对象的三种方式：

★ 方式一

通过对象的getClass方法进行获取。这种方式需要具体的类和该类的对象，以及调用getClass方法。

★ 方式二

任何数据类型(包括基本数据类型)都具备着一个静态的属性class，通过它可直接获取到该类型对应的Class对象。这种方式要使用具体的类，然后调用类中的静态属性class完成，无需调用方法，性能更好。

★ 方式三

通过Class.forName()方法获取。这种方式仅需使用类名，就可以获取该类的Class对象，更有利于扩展。

代码演示：

package cn.hncu.reflect.test;

import org.junit.Test;

/**

 * 1、演示获取Class c对象的三种方法

 *@author <a"283505495@qq.com">lxd</a>

 *@version 1.0 2017-4-15 下午2:57:05

 *@fileName ReflectGetClass.java

 */

public class ReflectGetClass {

    /**

     * 法1：通过对象---对象.getClass()来获取c(一个Class对象)

     */

    @Test

    public void get1(){

        Person p=new Person("Jack", 23);

        Class c=p.getClass();//来自Object方法

    }

    /**

     * 法2：通过类(类型)---任何数据类型包括(基本数据类型)都有一个静态的属性class ，他就是c 一个Class对象

     */

    @Test

    public void get2(){

        Class c=Person.class;

        Class c2=int.class;

    }

    /**

     * 法3：通过字符串(类全名 )---能够实现解耦：Class.forName(str)

     */

    @Test

    public void get3(){

        try {

            Class c=Class.forName("cn.hncu.reflect.test.Person");

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

}